结构型模式

• 组合类和对象以形成更大的结构
• 简化结构中的关系，使系统更易于理解和扩展。
• 减少系统中不同部分之间的依赖关系，提高系统的灵活性和可维护性。

结构型模式主要包括以下几种：

1. 适配器模式（Adapter）：允许将一个类的接口转换成客户端期望的另一个接口，使原本接口不兼容的类可以一起工作。
2. 桥接模式（Bridge）：将抽象部分与实现部分分离，使它们可以独立变化，通过组合的方式建立两者之间的联系，而不是继承。
3. 组合模式（Composite）：允许将对象组合成树形结构以表示“部分-整体”的层次结构。使得用户对单个对象和组合对象的使用具有一致性。
4. 装饰器模式（Decorator）：动态地给一个对象添加一些额外的职责，就增加功能来说，装饰器模式相比生成子类更为灵活。
5. 外观模式（Facade）：提供了一个统一的接口，用来访问子系统中的一群接口。外观定义了一个高层接口，让子系统更容易使用。
6. 享元模式（Flyweight）：运用共享技术有效地支持大量细粒度的对象，以减少创建对象的数量，降低程序内存的占用，提高效率。
7. 代理模式（Proxy）：为其他对象提供一种代理以控制对这个对象的访问，可以在客户端和目标对象之间起到中介的作用，并可以添加一些功能。

这些模式在不同的应用场景中有着广泛的应用，比如在系统需要使用现有的类但其接口不符合系统的需要时，可以使用适配器模式来进行接口适配；当系统需要对一系列的对象进行操作而不想关心这些对象是简单的还是复杂的组合时，可以使用组合模式来统一对待。

通过运用结构型模式，开发者可以更容易地设计出结构清晰、关系简单、高效灵活的系统架构。

创建型模式 Creational Patterns

• 创建型模式关注如何创建对象，将对象的实例化和声明相分离。
• 关注于对象的创建过程，目的是将对象的实例化与客户端的使用分离。
• 通过这种方式，系统中的具体类的实例化不会使代码变得僵硬，增加了系统的灵活性和可维护性。
• 更有效地封装和抽象化对象的创建过程。

创建型模式包括：

• 单例模式（Singleton）：确保一个类只有一个实例，并提供一个全局访问点。
• 工厂方法模式（Factory Method）：定义一个创建对象的接口，让子类决定实例化哪一个类。
• 抽象工厂模式（Abstract Factory）：提供一个接口，用于创建相关或依赖对象的家族，而不需要指定具体类。
• 建造者模式（Builder）：使用多个简单的对象一步一步构建成一个复杂的对象。
• 原型模式（Prototype）：通过复制现有的实例来创建新的实例，而不是通过新建实例。

单例模式

保证一个类只有一个实例， 并提供一个访问该实例的全局节点。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
            if (singleton == null) {  
                singleton = new Singleton();  
            }  
        }  
    }  
    return singleton;  
    }  
}

• volatile: 这是 Java 语言的一个关键字，用于指示 JVM（Java 虚拟机），这个变量可能会被多个线程同时访问和修改，但是它不会被线程缓存（每次访问变量时都要从主内存中读取），并且每次修改都会立即写入主内存。这个关键字的主要作用是确保变量的可见性和防止指令重排序优化，这对于多线程环境下安全创建单例至关重要。

工厂方法模式

• 在父类中提供一个创建对象的方法， 允许子类决定实例化对象的类型。
• 如果无法预知对象确切类别及其依赖关系时， 可使用工厂方法。
• 如果你希望用户能扩展你软件库或框架的内部组件， 可使用工厂方法。
• 如果你希望复用现有对象来节省系统资源， 而不是每次都重新创建对象， 可使用工厂方法。

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

public interface Shape {
   void draw();
}
////////////////////////////////
public class Rectangle implements Shape {
   @Override
   public void draw() {
      System.out.println();
   }
}
//////////////
public class ShapeFactory {
    
   //使用 getShape 方法获取形状类型的对象
   public Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }        
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();
      } else if ...
      return null;
   }
}

抽象工厂模式

• 创建一系列相关的对象
• 无需指定其具体类。
• 其他工厂的工厂。

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

//定义抽象工厂

public interface GUIFactory {
    Button createButton();
    Checkbox createCheckbox();
}

// 接着，定义 Button 和 Checkbox 接口：

public interface Button {
    void paint();
}

public interface Checkbox {
    void paint();
}

// 然后，实现具体的工厂类 WinFactory 和 MacFactory：

public class WinFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new WinButton();
    }

    @Override
    public Checkbox createCheckbox() {
        return new WinCheckbox();
    }
}

public class MacFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new MacButton();
    }

    @Override
    public Checkbox createCheckbox() {
        return new MacCheckbox();
    }
}

// 定义具体产品类 WinButton, WinCheckbox, MacButton, 和 MacCheckbox：

public class WinButton implements Button {
    @Override
    public void paint() {
        System.out.println("Rendering a button in Windows style.");
    }
}

public class MacButton implements Button {
    @Override
    public void paint() {
        System.out.println("Rendering a button in macOS style.");
    }
}

public class WinCheckbox implements Checkbox {
    @Override
    public void paint() {
        System.out.println("Rendering a checkbox in Windows style.");
    }
}

public class MacCheckbox implements Checkbox {
    @Override
    public void paint() {
        System.out.println("Rendering a checkbox in macOS style.");
    }
}

// 最后，实现客户端代码 Application 和 ApplicationConfigurator：

public class Application {
    private GUIFactory factory;
    private Button button;

    public Application(GUIFactory factory) {
        this.factory = factory;
    }

    public void createUI() {
        this.button = factory.createButton();
    }

    public void paint() {
        button.paint();
    }
}

public class ApplicationConfigurator {
    public static void main(String[] args) {
        GUIFactory factory;
        String OS = System.getProperty("os.name");
        
        if (OS.contains("Windows")) {
            factory = new WinFactory();
        } else if (OS.contains("Mac")) {
            factory = new MacFactory();
        } else {
            throw new RuntimeException("Error! Unknown operating system.");
        }

        Application app = new Application(factory);
        app.createUI();
        app.paint();
    }
}

这段 Java 代码完整实现了抽象工厂模式，包括抽象工厂接口、具体工厂类、抽象产品接口、具体产品类以及客户端代码。客户端代码仅依赖于抽象类型（GUIFactory、Button 和 Checkbox），使得你可以在不修改客户端代码的情况下引入新的工厂或产品变体。

建造者模式

• AKA生成器模式
• 分步骤创建复杂对象
• 使用相同的创建代码生成不同类型和形式的对象。
• 链式编程
• 只有当产品较为复杂且需要详细配置时，使用生成器模式才有意义。

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

public class Car {
    // 假设这里有一些属性和方法来表示汽车的各种特性
}

public class Manual {
    // 假设这里有一些属性和方法来表示手册的各种特性
}

// 接下来是 `Builder` 接口的定义，包括创建产品对象不同部件的方法：

public interface Builder {
    void reset();
    void setSeats(int number);
    void setEngine(String engine);
    void setTripComputer(boolean present);
    void setGPS(boolean present);
}

// 然后，我们实现具体的生成器类 `CarBuilder` 和 `CarManualBuilder`：

public class CarBuilder implements Builder {
    private Car car;

    public CarBuilder() {
        this.reset();
    }

    @Override
    public void reset() {
        this.car = new Car();
    }

    @Override
    public void setSeats(int number) {
        // 实现设置座位数的逻辑
    }

    @Override
    public void setEngine(String engine) {
        // 实现设置引擎的逻辑
    }

    @Override
    public void setTripComputer(boolean present) {
        // 实现设置行车电脑的逻辑
    }

    @Override
    public void setGPS(boolean present) {
        // 实现设置GPS的逻辑
    }

    public Car getProduct() {
        Car product = this.car;
        this.reset();
        return product;
    }
}

public class CarManualBuilder implements Builder {
    private Manual manual;

    public CarManualBuilder() {
        this.reset();
    }

    @Override
    public void reset() {
        this.manual = new Manual();
    }

    @Override
    public void setSeats(int number) {
        // 实现添加关于座椅的文档逻辑
    }

    @Override
    public void setEngine(String engine) {
        // 实现添加关于引擎的介绍逻辑
    }

    @Override
    public void setTripComputer(boolean present) {
        // 实现添加关于行车电脑的介绍逻辑
    }

    @Override
    public void setGPS(boolean present) {
        // 实现添加关于GPS的介绍逻辑
    }

    public Manual getProduct() {
        Manual product = this.manual;
        this.reset();
        return product;
    }
}

// 接着，实现 `Director` 类，它负责定义构建过程的不同步骤：

public class Director {
    public void constructSportsCar(Builder builder) {
        builder.reset();
        builder.setSeats(2);
        builder.setEngine("SportEngine");
        builder.setTripComputer(true);
        builder.setGPS(true);
    }

    // 这里可以添加更多的方法来构建不同类型的汽车
}

// 最后是客户端代码，它演示了如何使用这些类来构建产品：

public class Application {
    public static void main(String[] args) {
        Director director = new Director();

        CarBuilder carBuilder = new CarBuilder();
        director.constructSportsCar(carBuilder);
        Car car = carBuilder.getProduct();

        CarManualBuilder manualBuilder = new CarManualBuilder();
        director.constructSportsCar(manualBuilder);
        Manual manual = manualBuilder.getProduct();

        // 在这里，car 和 manual 是根据相同的构建过程创建的，
        // 但它们是完全不同的产品。
    }
}

这段 Java 代码展示了如何实现生成器模式，其中包括创建复杂对象的过程，使得最终产品的构建与其表示分离，允许相同的构建过程创建不同的表示。

原型模式

• 复制已有对象

• 当直接创建对象的代价比较大时，则采用这种模式。

• Java 中，原型模式通常通过实现 Cloneable 接口并重写 Object 类的 clone() 方法来实现。

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

import java.util.HashMap;
import java.util.Map;

// 抽象类实现 Cloneable 接口
abstract class Shape implements Cloneable {
    private String id;
    protected String type;

    abstract void draw();

    public String getType() {
        return type;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public Object clone() {
        Object clone = null;
        try {
            clone = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return clone;
    }
}

// 具体的形状类
class Rectangle extends Shape {
    public Rectangle() {
        type = "Rectangle";
    }

    @Override
    void draw() {
        System.out.println("Inside Rectangle::draw() method.");
    }
}

class Circle extends Shape {
    public Circle() {
        type = "Circle";
    }

    @Override
    void draw() {
        System.out.println("Inside Circle::draw() method.");
    }
}

// 缓存类
class ShapeCache {
    private static Map<String, Shape> shapeMap = new HashMap<>();

    public static Shape getShape(String shapeId) {
        Shape cachedShape = shapeMap.get(shapeId);
        return (Shape) cachedShape.clone();
    }

    public static void loadCache() {
        Circle circle = new Circle();
        circle.setId("1");
        shapeMap.put(circle.getId(), circle);

        Rectangle rectangle = new Rectangle();
        rectangle.setId("2");
        shapeMap.put(rectangle.getId(), rectangle);
    }
}

// 客户端代码
public class PrototypePatternDemo {
    public static void main(String[] args) {
        ShapeCache.loadCache();

        Shape clonedShape1 = ShapeCache.getShape("1");
        System.out.println("Shape : " + clonedShape1.getType());

        Shape clonedShape2 = ShapeCache.getShape("2");
        System.out.println("Shape : " + clonedShape2.getType());
    }
}

这段代码展示了原型设计模式的核心：通过克隆现有对象来创建新对象，从而避免了通过 new 关键字创建对象带来的成本。这里，Shape 抽象类实现了 Cloneable 接口，允许其子类 Rectangle 和 Circle 被克隆。ShapeCache 类用于预存储和克隆形状对象，而客户端代码演示了如何从缓存中获取并使用这些克隆对象。

end

设计模式原则

设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。

1、开闭原则 Open Close Principle

• 对扩展开放，对修改关闭。
• 使程序的扩展性好，易于维护和升级。
• 需要使用接口和抽象类

2、里氏代换原则Liskov Substitution Principle

• 任何基类可以出现的地方，子类一定可以出现。
• 里氏代换原则是对实现抽象化的具体步骤的规范。

3、依赖倒转原则Dependence Inversion Principle

• 针对接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则Interface Segregation Principle

• 使用多个隔离的接口，比使用单个接口要好。
• 降低类之间的耦合度。

5、迪米特法则，又称最少知道原则Demeter Principle

• 一个实体应当尽量少地与其他实体之间发生相互作用。

6、合成复用原则Composite Reuse Principle

• 尽量使用合成/聚合的方式，而不是使用继承。

类型

• 23 种设计模式。
• 创建型模式Creational Patterns
• 结构型模式Structural Patterns
• 行为型模式Behavioral Patterns。

使用 Marp for VS Code 将 Markdown 转换为 PPT

Markdown 是一种轻量级标记语言，广泛用于撰写文档和笔记。

VSCode 是一个功能丰富的代码编辑器，它支持许多插件，包括 Marp，可以将 Markdown 文档转换为演示文稿。

安装和设置

1. 打开 VSCode
2. 安装 Marp for VS Code 扩展

创建 Marp 演示文稿

1. 新建一个 Markdown 文件
2. 启用 Marp：在文件的顶部添加 YAMLFront Matter``：

1
2
3

---
marp: true
---

3. 撰写幻灯片：每页幻灯片由一个 --- 分隔，在单页顶部使用<!-- -->修改局部配置，语法支持markdown。

常用Front Matter：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

---
marp: true
<!-- 设置主题 -->
theme: 
<!-- 显示页码 -->
paginate: true
<!-- 全局background -->
backgroundColor:
backgroundImage:
<!-- 页眉 -->
header: 
<!-- 页脚 -->
footer:
---

for example:

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

---
marp: true
theme: gaia
_class: lead
paginate: true
backgroundImage: url('https://marp.app/assets/hero-background.svg')
---

![bg left:40% 80%](https://marp.app/assets/marp.svg)

# **Marp**

`Markdown` Presentation Ecosystem

https://marp.app/

---
<!-- _header: header -->

# title

```java
class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, world.");
    }
}

1
2
3
4
5
6
7
8
9
10
11

![Alt text](https://s2.loli.net/2024/01/31/qnQA7gk2vw59JbF.png)

## 配置`directives`

局部设置有`local`和`spot`两种。

常用的是`spot`，用来设置单页的页眉。用法如下：

```markdown 格式
<!-- _header: 小标题 -->

配置themes

配置项：

1
2
3
4

"markdown.marp.themes": [
  "yourlocalpathOrurl/yourthemes.css",
  "another"
]

导出

1. 预览演示文稿：点击右上角的预览图标

2. 导出为 PPT：点击右上角 Marp 图标，然后选择 export slide deck 导出为pptx。

end

推荐一个好看的主题Awesome-Marp

更多marp信息查看Marpit documentation

原生语法

``` markdown # this is h1

this is code

this is block quote

this is b

this is i

中划线

下划线

Maven笔记整理

Project Object Model

Project Object Model (POM) 是 Maven 项目配置的核心概念。在 Maven 项目中，POM 通过一个名为 pom.xml 的 XML 文件表示。它包含了项目的基本信息和配置详情，如项目名称、版本、依赖项、插件、目标等。POM 使得项目的构建过程变得透明化，并且可重复，确保了持续集成和部署的一致性。

下面是 POM 中一些关键部分的概述：

1. 基本信息：包括项目的坐标，即 groupId, artifactId, 和 version。这些元素唯一地定义了项目在仓库中的位置。

2. 依赖管理：在 <dependencies> 部分定义项目所需的库。每个依赖项都有其自己的坐标和范围，指明了库在项目生命周期中的使用阶段。

3. 插件和目标：<build> 部分中的 <plugins> 定义了项目构建过程中使用的插件及其配置。这些插件可以绑定到生命周期的不同阶段上。

4. 属性：可以定义一些属性来简化配置，例如，可以指定编译器版本或者文件编码方式。

5. 构建配置：如源码路径、测试路径、输出文件等也在 POM 中配置。

6. 构建生命周期：POM 文件定义了项目的构建生命周期，包括编译、测试、打包和部署等阶段。

7. 项目继承：通过 <parent> 元素，POM 可以继承另一个 POM 的配置。这在多模块项目中特别有用。

8. 项目聚合：通过 <modules> 元素，可以定义项目的子模块，允许一次性构建多个模块。

9. 仓库管理：指定项目使用的仓库地址，用于依赖项的下载和项目成果的上传。

10. 配置管理：可以包括对源代码管理系统的引用。

命令

在实际开发过程中，经常使用的命令有： - mvn clean：清理所有生成的class和jar； - mvn clean compile：先清理，再执行到compile； - mvn clean test：先清理，再执行到test，因为执行test前必须执行compile，所以这里不必指定compile； - mvn clean package：先清理，再执行到package。

构建过程

大多数阶段(phase)在执行过程中，因为我们通常没有在pom.xml中配置相关的设置，所以这些phase什么事情都不做。 经常用到的phase其实只有几个： clean：清理 compile：编译 test：运行测试 package：打包

目录

1
2
3
4
5
6
7
8

根目录：工程名
|---`src`：源码
|---|---`main`: 存放主程序
|---|---|---`java`：java源码文件
|---|---|---`resource`：存放框架的配置文件
|---|---`test`：存放测试程序
|---`pom.xml`：maven的核心配置文件

前言

Streamlit特别适合需要在Web应用中快速展示数据或算法的项目， 比如 1. 数据分析、数据可视化或数据报告 2. 机器学习和人工智能应用

这是我实现的一个应用：

https://github.com/VKKKV/cypherpro

安装并创建

1. 安装Streamlit：在终端或命令提示符中运行以下命令：

   1	pip install streamlit

2. 创建一个新的Python文件：在你的工作目录中创建一个新的Python文件，比如叫做app.py。

3. 编写Streamlit代码：在app.py文件中，写下以下代码：

   1 2 3 4 5 6 7 8 9 10

   import streamlit as st # 设置页面标题 st.title('我的Streamlit应用') # 显示文本 st.write('这是一个基本的Streamlit应用，用于展示文本和图像。') # 显示图像 st.image('image.jpg', caption='Sunrise by the mountains')

4. 运行

   1	streamlit run app.py

分列

st.columns()用于在水平方向上分割页面布局，创建并排放置的多个元素。

1
2
3
4
5
6
7
8
9
10

# 分列
col1, col2, col3 = st.columns(3)
with col1:
    st.write("这是第一列")

with col2:
    st.write("这是第二列")

with col3:
    st.write("这是第三列")

这段代码会在页面上创建三列，每列分别显示不同的文本。

分页

创建入口文件后，在pages目录中创建.py文件添加页面。

下面是多页应用的有效目录结构：

1
2
3
4
5

Home.py # This is the file you run with "streamlit run"
└─── pages/
  └─── About.py # This is a page
  └─── 2_Page_two.py # This is another page
  └─── 3_😎_three.py # So is this

常用API

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 这是最通用的命令，用于在应用中显示文本、数据、图表等。
st.write()
   
# 用Markdown格式显示文本。
st.markdown()

# 创建一个文本输入框。
st.text_input()

# 创建一个按钮，当被点击时返回True。
st.button()

# 创建标题.
st.header()

# 创建一个文件上传控件。
st.file_uploader()

end

更多关于Streamlit API的信息，请参考

https://docs.streamlit.io/

https://cheat-sheet.streamlit.app/

第三方组件

https://streamlit.io/components

zero

自2022年9月搭建博客，至今2024年细算已有一年有余。其间数次意欲证明己身实力，post篇技术文章。奈何脑中文字所得尽数拾人牙慧，一无所长，以至于达不到理想中的原创文章。我能轻松学会的知识、技术，为何别人不能学会，我能写出的博客，为何别人写不出。一念之间想法打消，怔怔空对文档，对博客的热情也淡了下来。文章标题为zero-blog。因为过去的一无所获，无一可数，只好从零数起开始反省。反思我在已经得到所有想要的东西后还能想要什么，在失去得不到的东西后还能再失去什么。心中剩下的只有对于电子设备的热情，这情绪的由来早已遗忘，还停留的是小时候摸到psp扳机的触感，点击键盘见到flash游戏的新鲜感。那时觉得电脑键盘是永远都玩不腻的玩具，中学接触信息课是这么想，填写志愿是这么想，多少学了点皮毛技术的现在也是。恐怕我一生都会这么想，这个人可以离开很多东西，但早已经离不开计算机和游戏了。如今不敢回想2021年的夏天，那是第一次拥有一台笔记本电脑，有机会天天摸到键盘，学习编程，那是连键盘盲打都不会，鼠标也用不顺手，却依然对控制台输出星号三角形乐此不疲的时间。那种勃勃生机，万物竞发的境界犹在眼前。这样的体验带来的感觉虽然不再常有，但我还有的是时间去找感觉。

ps

搭建博客参考的文章。

1. [攻城狮杰森的博客搭建教程]https://pdpeng.github.io/2022/01/19/setup-personal-blog/
2. [观月真由理的Hexo主题Shoka]https://shoka.lostyu.me/computer-science/note/theme-shoka-doc/

(#5)#5#5#5#5 #55#3#2

(#7)(#6)(#5)(#5)(#3)(#5)(#3)(#6)(#7)

(#7)(#6)(#5)(#5) (#5)(#3)(#5)(#6)#3#2

(#7)(#6)(#5)(#6)#2(#7)

(#5)#5#5#5#5 #55#3#2

(#7)(#6)(#5)(#5)(#3)(#5)(#3)(#6)(#7)#2#3#2

(#7)(#6)(#5)(#5)

(#5)(#3)(#5)(#6)#3#2 #2#3(#7)(#6)(#5)(#5)

(#5)#5#5#5#5 #55#3#2

(#7)(#6)(#7)(#5)(#5)(#5)(#5)(#3)(#6)(#7)

(#7)(#6)(#5)(#5)(#5)(#5)(#3)(#5)(#6)#3#2

(#7)(#6)(#5)(#6)(#5)#2

(#5)#5#5#5#5 #55#3#2

(#7)(#6)(#5)(#5)(#3)(#5)(#3)(#6)(#7)#2#3#2

(#7)(#6)(#5)(#5)(#3)(#5)(#6)#3#2 #2#3(#7)(#6)(#5)(#5)

(#5)(#5)(#5)#5 #3#2

#2#2#3(#7)(#6)(#5)#2

#2#2#2#2

(#7)(#6)(#5)(#6)(#7)(#6)(#7)(#2)

#2#2#2#2(#7)(#6)(#5)

#2(#7)(#6)(#5) (#5)(#5)(#6)(#5)(#7)

(#5)(#5)#5 #3#2

#2#2#3(#7)(#6)(#5)#2

#2#2#2#3 #5#5 #6#7#6#7#7#2

#2#2#23#5 #5333#5#5#6 #7#6#5

#7#7#7#6#5#6[#2][#2]#7

#2#2#2#3#5#6 [#3][#2][#3] #7#6#5#6#7 [#2]#55#5

#2#3#5#6#7#6#5

#7#7#7#6#5#6[#2]#6#7

#2#2#2#3#5#6 [#3][#2][#3] [#5] [#6][#5][#6][#5]

[#5] [#3][#2]#7#6#5

#5#2 #5#6#7[#1][2] #7#6#5

#5#5#5#5 #55#3#2

(#7)(#6)(#5)(#5)(#3)(#5)(#3)(#6)(#7)

(#7)(#6)(#5)(#5)(#5)(#3)(#5)(#6)#3#2

(#7)(#6)(#5)(#6)#2(#7)

(#5)#5#5#5#5 #55#3#2

(#7)(#6)(#5)(#5) (#5)(#3)(#5)(#6)#2(#7)

#3#2(#7)(#6)(#5) (#5)(#3)(#5)(#6) #3#2 #2#3(#7)(#6)(#5)(#5)

(#5)(#5)(#5)#5#3#2 #2#2#3 (#7)(#6)(#5)#2

#2#2#2#2(#7)(#6)(#5)(#6)(#7)(#6)(#7)(#2)

(#2)(#3)(#5)(#6)(#5)(#6)(#5) (#6)(#7)#2(#7)(#6)(#5)(#6)(#5)(#7)

(#5)(#5)#5 #3#2

#2#2#3 (#7)(#6)(#5)#2

#2#2#2#3 #5#5 #6#7[#2]#7#6#5

#2#2#23#5 #5333#5#5#6

#7#7#7#6#5#6[#2][#2]#7

#2#2#2#3#5#6 [#3][#2][#3] #7#6#5#6#7 [#2]#55#5

#2#3#5#5#6#7#6#5

#7#7#7#6#5#6[#2]#6#7

#2#2#2#3#5#6 [#3][#2][#3] [#5] [#6][#5][#6][#5]

[#5] [#2][#3]#7#6#5

#2#3#5 #5#6#7[#1][#2] #7#6#5

#2#5#6#7[#2] #5[#3][#2] #7#6#7#6#5

#2#35#55 #2(#7)(#6)#2(#7)(#6)

#7#6#5#2#3 #2#6#5

[#2]#7#6#5#6#5#3#2

(#7)#2(#7)#2#3#5

#2#5#7#6[#2]#2[#3][#2][#3]#7#6#5#2#3

5#5#6#5#6#5#6[#2]#7

#6#5#7#6#5#2#3#6#5 #6#7[#2]#7#6#5

[3][#2][#1]#5#6

#7#7#7#6#5#6[#2][#2]#7

#2#2#2#3#5#6 [#3][#2][#3] #7#6#5#6#7 [#2]#55#5

#2#3#5#5#6#7#6#5

#7#7#7#6#5#6[#2]#6#7

#2#2#2#3#5#6 [#3][#2][#5][#3][#2][#3][#5]

[#3][#2][#3] #7#6#5

#2#3#5#7#6#5#2#6#5

(#5)#5#5#5#5 #55#3#2

(#7)(#6)(#5)(#5)(#3)(#5)(#3)(#6)(#7)

(#7)(#6)(#5)(#5)(#5)(#3)(#5)(#6)

#3#2(#7)(#6)(#5)(#6)#2(#7)

word5