【個人アプリ開発記】ビジュアル言語による作図ソフトを開発しました

## できたもの
![スクリーンショット 2022-06-26 16.36.06.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/549093/d08f5da3-fa70-0f1a-abab-7284f0c9fa95.jpeg)
![dekitamono-2.gif](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/549093/37835162-06d1-515f-3994-8644b71a6388.gif)

端的(？)に表すと「ビジュアル言語によって作図ができ，かつディスプレイ上の図形の定義をユーザが確認できる動的幾何ソフトウェア」です．
## 動的幾何ソフトによる作図
アプリの説明に入る前に，前提知識をざっと書きます．
[wikipedia](https://ja.wikipedia.org/wiki/動的幾何学ソフトウエア)によると、動的幾何ソフトとは以下のような定義と特徴となっています。
>コンピュータソフトウェアであって、おもに平面幾何学の作図を行うことができるものをいう。これらの動的幾何学ソフトにおいては、作図は点・直線・円などをマウスクリック・ドラッグによって行い、作図手順が記録される。作図を行った後に、幾何要素（点・直線・円など）を動かして、作図全体を変化させることができるのが主な特徴である。
>

動的幾何ソフトによる作図とは，動的幾何環境に用意された以下の3種類の点を適切に用いて，動かしても「定義の崩れない」図形を描くことです．
- どこにでも動かせる点(自由度2)
- 線や円など特定の図形の上しか動けない点(自由度1)
- 交点や回転移動によって定まる点など，他の図形の動きに完全に依存する点(自由度0)

具体例として菱形の作図を紹介します．
### 菱形の作図
菱形の定義は「すべての辺の長さが等しい」ことです．この定義によると，以下の手順で作図できます．
![tutrail.gif](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/549093/14c4ed54-e5df-ac90-1f11-66ecf8a3083c.gif)

1. 線分ABを引く
2. Aを中心としてBを通る円を描く
3. 2で描いた円上を動く点Cをとる
4. AとCを結ぶ
5. Bを中心としてAを通る円、Cを中心としてAを通る円を描く
6. 5で描いた円の交点をとる
7. それぞれの点を結ぶ

これで動的幾何ソフトによる菱形の作図が完了したことになります。

これは菱形の定義である「すべての辺の長さが等しい」から作図しましたが，菱形の性質である
- 2組の対辺は互いに平行で長さは等しい
- 2組の対角の大きさも互いに等しい
- 対角線がそれぞれの中点で垂直に交わる
などを利用しても作図できます．

### アンチパターン
#### 崩れる
![anti-1.gif](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/549093/72f6e146-0ef9-5345-712d-6a17f51761c1.gif)


上で作図した菱形はどの点を動かしても「崩れる」ことはありませんでした。ここで「崩れる」とは、点を動かすことで菱形の定義を満たさなくなることを意味しています。
#### 特定の菱形でしかない
![anti-2.gif](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/549093/fdc3e25a-5a23-40a2-bba8-e02997f21e23.gif)

一見菱形の定義を満たしているように見えますが、制約が強すぎるため(この作図では60°・120°しかとれない)動的幾何ソフトの作図ではNGです。

## 既存のソフトウェアの問題だと感じる点
前置きがとても長くなってしまいました。上述した方法によって作図を行うことはできますが、学習者は主に小中学生です。直感的な操作は魅力的ですが、初学者にとっての壁となり得るのではと思いました。

## ビジュアル言語で作図できるようにする
### 日本語→JavaScript
　GoogleのOSS[Blockly](https://developers.google.com/blockly)を使えば簡単にビジュアル言語を作成することができます。
![スクリーンショット 2022-06-26 9.39.25.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/549093/59f3ceb7-ae01-f0b4-9232-518f4decf0c8.jpeg)
作成したいビジュアル言語の引数の数や型に合わせてブロックを並べます．(ビジュアル言語を作成するためのツールもビジュアル言語でできています．)ビジュアル言語の配置に応じてJSON(またはXML)とJavaScriptの関数が自動で生成されます．
具体的には以下のようになります．
```JSON
{
  "type": "connectablesegment",
  "message0": "線分 %1 %2 %3",
  "args0": [
    {
      "type": "input_dummy"
    },
    {
      "type": "input_value",
      "name": "point1"
    },
    {
      "type": "input_value",
      "name": "point2"
    }
  ],
  "inputsInline": true,
  "output": null,
  "colour": 315,
  "tooltip": "",
  "helpUrl": ""
}
```

```JavaScript
Blockly.JavaScript['connectablesegment'] = function(block) {
    var value_point1 = Blockly.JavaScript.valueToCode(block, 'point1', Blockly.JavaScript.ORDER_ATOMIC);
    var value_point2 = Blockly.JavaScript.valueToCode(block, 'point2', Blockly.JavaScript.ORDER_ATOMIC);
    //()の部分をカットする
    var firstCharacterSlicedPoint1 = value_point1.slice(1);
    var lastCharacterSlicedPoint1 = firstCharacterSlicedPoint1.slice(0,-1);

    var firstCharacterSlicedPoint2 = value_point2.slice(1);
    var lastCharacterSlicedPoint2 = firstCharacterSlicedPoint2.slice(0,-1);

    // TODO: Assemble JavaScript into code variable.
    var code = `${Segment(lastCharacterSlicedPoint1,lastCharacterSlicedPoint2)}`;
    return [code, Blockly.JavaScript.ORDER_NONE];
  };
```

これを線分,直線，平行線，垂線，垂直二等分線，円...など必要なものをすべて用意します．
### JavaScript→GeoGebraScript
GeoGebraにはコードで作図を行うためのGeoGebraScriptというものが用意されており，線分ABであれば以下のようにして作図できます．

```JavaScript
ggbApplet.evalCommand('A = (0,0)');
ggbApplet.evalCommand('B = (1,0)');
ggbApplet.evalCommand('Segment(A,B)');
```
このときA,Bの座標はクリック操作では必要かった情報ですが，コードによる作図では必要になります．
GeoGebraでのコードでの作図は以下で詳しく書いているので，そちらを参照ください．
- [JavaScriptによるオブジェクトの配置【GeoGebra】](https://qiita.com/Hyperbolic_____/items/c64805717b7a2359cb63)
- [【GeoGebra】3種類のスクリプト記述について](https://qiita.com/Hyperbolic_____/items/a5829bcea4d0afafe106)

実際にはhtmlでボタンを配置して，押されたときに`evalCommand()`を叩き，code内に入っている文字列を描くようにしました．

## 動的幾何環境とビジュアル言語エディタを備えたWebページを作成する
GeoGebraはWebページに貼り付けることができます．Blocklyのエディタと共にそれらを貼り付けたWebページを作成します．

![スクリーンショット 2022-06-26 10.20.49.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/549093/9cc65acc-790b-218e-fcce-b1489b8842d3.jpeg)

これでビジュアル言語によって操作可能な動的幾何ソフトが実現できました．これで菱形を作図すると以下のようになります．

![hoge.gif](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/549093/d1d16d3f-e98c-310b-1bd5-40d1e49a14f8.gif)

## ビジュアル言語で作図するソフトが抱える問題点
↑で作成したソフトには，図形を言葉による定義で理解する必要があるため，作図しにくいです．具体的には
![スクリーンショット 2022-06-26 14.39.12.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/549093/22a633f6-6ceb-ef55-afd4-63a2960e320f.jpeg)
など長く複雑な場合，作図する都度確認しなければなりません．そこで定義を図に追従させるようにしました．

## 図形に定義を追従させる
GeoGebraのAPIにはオブジェクトの追加を監視するものと，オブジェクトの定義を取得するものと，オブジェクトの名前を変更するものがあります．それらを組み合わせればなんとかできそうです．

### 定義を取得し日本語に置き換え図形の名前にする．
GeoGebraでは，点はA,B,D...，直線はf,g,h...といったように作成された図形に対して名前が自動で与えられます．これを定義に置き換えることがゴールとなります．

```JavaScript
var descriptionStr = ggbApplet.getDefinitionString(objName);
//Segment(A,B)やPerpendicularLine(A,f)など
```
のようにして，定義を取得することができるので，オブジェクトが追加されたときにこれで定義を取得し，

```JavaScript
descriptionStr = descriptionStr.replace(`Segment(A, B)`, `線分AB`);
descriptionStr = descriptionStr.replace(`PerpendicularLine(A,f)`, `Aを通りfに垂直な直線`);
```
で日本語に置き換え，

```JavaScript
ggbApplet.renameObject(objName, descriptionStr);
```
のようにすることで，図形の名前を定義に変更することができました．

#### 複数のオブジェクトが入れ子になっている場合
↑で書いた方法では，線分ABといった単純な図形を表示することはできますが，`PerpendicularLine(A, Segment(A,B))`つまり，`Aを通り線分(A,B)に垂直な直線`には対応できません．
`PerpendicularLine(A, Segment(A,B))`を`Aを通り線分(A,B)に垂直な直線`に変換するためには，まず`Segment(A,B)`を`線分AB`に変換する必要があります．しかし，おそらくJavaScriptが()がどこで終わるのか判断できないのです．
そのため以下のような正規表現でよしなにする関数が必要になります．
```JavaScript
const functions = {
        "Line": (point, line) => `(${point}を通り(${line})に平行な直線)`,
      }

function parse(string, funcs) {
        const funcNames = Object.keys(funcs);
        const pattern = new RegExp(`(?<func>${funcNames.join('|')})\\((?<args>.*?)\\)`);
        let rest = string;
        let result = "";
        let match = null;
        while (match = pattern.exec(rest)) {
          result += rest.substring(0, match.index);
          const { func, args } = match.groups;
          result += funcs[func](...args.split(","));
          rest = rest.substring(match.index + match[0].length);
        }
        return result + rest;
      }
```

しかし，これで対応できるのも入れ子が一重の時だけです．`Line(B,PerpendicularLine(A,Segment(A,B)))`，つまり`Bを通りAを通り線分ABに垂直な直線に平行な直線`など入れ子が二重になっている場合には対応できないのです．これは作図で使われないほど複雑に見えるかもしれませんが，長方形などの作図でさえ必要になり得ます．
これを考慮した関数を作成するのはとても大変そうです．(そもそも↑の関数もつよつよ同期に作ってもらいました)

#### 起こりうるパターンをすべて網羅しゴリ押しする
置き換えることの難しさが伝わったかと思います．しかし，やりたいことは明確なので，人力でやってしまえば良いのです．(プログラマの美学に反するかもしれませんが，数十回のコピペを行うだけです)

```JavaScript
//Aが含まれる線分
descriptionStr = descriptionStr.replace(`Segment(A, B)`, `線分AB`);
descriptionStr = descriptionStr.replace(`Segment(B, A)`, `線分BA`);
descriptionStr = descriptionStr.replace(`Segment(A, C)`, `線分AC`);
descriptionStr = descriptionStr.replace(`Segment(C, A)`, `線分CA`);
descriptionStr = descriptionStr.replace(`Segment(A, D)`, `線分AD`);
descriptionStr = descriptionStr.replace(`Segment(D, A)`, `線分DA`);
```
のように起こりうるパターンを網羅して，置き換えを用意しておきます．
<details><summary>想像を絶するほど長い置き換えコード</summary>

```JavaScript
          //Aが含まれる線分
          descriptionStr = descriptionStr.replace(`Segment(A, B)`, `線分AB`);
          descriptionStr = descriptionStr.replace(`Segment(B, A)`, `線分BA`);
          descriptionStr = descriptionStr.replace(`Segment(A, C)`, `線分AC`);
          descriptionStr = descriptionStr.replace(`Segment(C, A)`, `線分CA`);
          descriptionStr = descriptionStr.replace(`Segment(A, D)`, `線分AD`);
          descriptionStr = descriptionStr.replace(`Segment(D, A)`, `線分DA`);
          descriptionStr = descriptionStr.replace(`Segment(A, E)`, `線分AE`);
          descriptionStr = descriptionStr.replace(`Segment(E, A)`, `線分EA`);
          descriptionStr = descriptionStr.replace(`Segment(A, F)`, `線分AF`);
          descriptionStr = descriptionStr.replace(`Segment(F, A)`, `線分FA`);
          //Aが含まれる直線
          descriptionStr = descriptionStr.replace(`Line(A, B)`, `直線AB`);
          descriptionStr = descriptionStr.replace(`Line(B, A)`, `直線BA`);
          descriptionStr = descriptionStr.replace(`Line(A, C)`, `直線AC`);
          descriptionStr = descriptionStr.replace(`Line(C, A)`, `直線CA`);
          descriptionStr = descriptionStr.replace(`Line(A, D)`, `直線AD`);
          descriptionStr = descriptionStr.replace(`Line(D, A)`, `直線DA`);
          descriptionStr = descriptionStr.replace(`Line(A, E)`, `直線AE`);
          descriptionStr = descriptionStr.replace(`Line(E, A)`, `直線EA`);
          descriptionStr = descriptionStr.replace(`Line(A, F)`, `直線AF`);
          descriptionStr = descriptionStr.replace(`Line(F, A)`, `直線FA`);
          //Aが含まれる垂直二等分線
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(A, B)`, `ABの垂直二等分線`);
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(B, A)`, `BAの垂直二等分線`);
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(A, C)`, `ACの垂直二等分線`);
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(C, A)`, `CAの垂直二等分線`);
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(A, D)`, `ADの垂直二等分線`);
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(D, A)`, `DAの垂直二等分線`);
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(A, E)`, `AEの垂直二等分線`);
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(E, A)`, `EAの垂直二等分線`);
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(A, F)`, `AFの垂直二等分線`);
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(F, A)`, `FAの垂直二等分線`);
          //Bが含まれる線分
          descriptionStr = descriptionStr.replace(`Segment(B, C)`, `線分BC`);
          descriptionStr = descriptionStr.replace(`Segment(C, B)`, `線分CB`);
          descriptionStr = descriptionStr.replace(`Segment(B, D)`, `線分BD`);
          descriptionStr = descriptionStr.replace(`Segment(D, B)`, `線分DB`);
          descriptionStr = descriptionStr.replace(`Segment(B, E)`, `線分BE`);
          descriptionStr = descriptionStr.replace(`Segment(E, B)`, `線分EB`);
          descriptionStr = descriptionStr.replace(`Segment(B, F)`, `線分BF`);
          descriptionStr = descriptionStr.replace(`Segment(F, B)`, `線分FB`);
          //Bが含まれる直線
          descriptionStr = descriptionStr.replace(`Line(B, C)`, `直線BC`);
          descriptionStr = descriptionStr.replace(`Line(C, B)`, `直線CB`);
          descriptionStr = descriptionStr.replace(`Line(B, D)`, `直線BD`);
          descriptionStr = descriptionStr.replace(`Line(D, B)`, `直線DB`);
          descriptionStr = descriptionStr.replace(`Line(B, E)`, `直線BE`);
          descriptionStr = descriptionStr.replace(`Line(E, B)`, `直線EB`);
          descriptionStr = descriptionStr.replace(`Line(B, F)`, `直線BF`);
          descriptionStr = descriptionStr.replace(`Line(F, B)`, `直線FB`);
          //Bが含まれる垂直二等分線
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(B, C)`, `BCの垂直二等分線`);
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(C, B)`, `CBの垂直二等分線`);
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(B, D)`, `BDの垂直二等分線`);
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(D, B)`, `DBの垂直二等分線`);
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(B, E)`, `BEの垂直二等分線`);
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(E, B)`, `EBの垂直二等分線`);
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(B, F)`, `BFの垂直二等分線`);
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(F, B)`, `FBの垂直二等分線`);
          //Cが含まれる線分
          descriptionStr = descriptionStr.replace(`Segment(C, D)`, `線分CD`);
          descriptionStr = descriptionStr.replace(`Segment(D, C)`, `線分DC`);
          descriptionStr = descriptionStr.replace(`Segment(C, E)`, `線分CE`);
          descriptionStr = descriptionStr.replace(`Segment(E, C)`, `線分EC`);
          descriptionStr = descriptionStr.replace(`Segment(C, F)`, `線分CF`);
          descriptionStr = descriptionStr.replace(`Segment(F, C)`, `線分FC`);
          //Cが含まれる直線
          descriptionStr = descriptionStr.replace(`Line(C, D)`, `直線CD`);
          descriptionStr = descriptionStr.replace(`Line(D, C)`, `直線DC`);
          descriptionStr = descriptionStr.replace(`Line(C, E)`, `直線CE`);
          descriptionStr = descriptionStr.replace(`Line(E, C)`, `直線EC`);
          descriptionStr = descriptionStr.replace(`Line(C, F)`, `直線CF`);
          descriptionStr = descriptionStr.replace(`Line(F, C)`, `直線FC`);
          //Cが含まれる垂直二等分線
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(C, D)`, `CDの垂直二等分線`);
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(D, C)`, `DCの垂直二等分線`);
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(C, E)`, `CEの垂直二等分線`);
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(E, C)`, `ECの垂直二等分線`);
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(C, F)`, `CFの垂直二等分線`);
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(F, C)`, `FCの垂直二等分線`);
          //Dが含まれる線分
          descriptionStr = descriptionStr.replace(`Segment(D, E)`, `線分DE`);
          descriptionStr = descriptionStr.replace(`Segment(E, D)`, `線分ED`);
          descriptionStr = descriptionStr.replace(`Segment(D, F)`, `線分DF`);
          descriptionStr = descriptionStr.replace(`Segment(F, D)`, `線分FD`);
          //Dが含まれる直線
          descriptionStr = descriptionStr.replace(`Line(D, E)`, `直線DE`);
          descriptionStr = descriptionStr.replace(`Line(E, D)`, `直線ED`);
          descriptionStr = descriptionStr.replace(`Line(D, F)`, `直線DF`);
          descriptionStr = descriptionStr.replace(`Line(F, D)`, `直線FD`);
          //Dが含まれる垂直二等分線
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(D, E)`, `DE垂直二等分線`);
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(E, D)`, `ED垂直二等分線`);
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(D, F)`, `DF垂直二等分線`);
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(F, D)`, `FD垂直二等分線`);
          //Eが含まれる線分
          descriptionStr = descriptionStr.replace(`Segment(E, F)`, `線分EF`);
          descriptionStr = descriptionStr.replace(`Segment(F, E)`, `線分FE`);
          //Eが含まれる直線
          descriptionStr = descriptionStr.replace(`Line(E, F)`, `直線EF`);
          descriptionStr = descriptionStr.replace(`Line(F, E)`, `直線FE`);
          //Eが含まれる垂直二等分線
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(E, F)`, `EF垂直二等分線`);
          descriptionStr = descriptionStr.replace(`PerpendicularBisector(F, E)`, `FE垂直二等分線`);

          //Aを通る垂線
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分AB)`, `(Aを通り線分ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分BA)`, `(Aを通り直線BAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線AB)`, `(Aを通り線分ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線BA)`, `(Aを通り直線BAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線AB)`, `(Aを通りABの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線BA)`, `(Aを通りBAの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分AC)`, `(Aを通り線分ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分CA)`, `(Aを通り直線ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線AC)`, `(Aを通り線分ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線CA)`, `(Aを通り直線ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線AC)`, `(Aを通りACの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線CA)`, `(Aを通りCAの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分AD)`, `(Aを通り線分ADに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分DA)`, `(Aを通り直線DAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線AD)`, `(Aを通り線分ADに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線DA)`, `(Aを通り直線DAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線AD)`, `(Aを通りADの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線DA)`, `(Aを通りDAの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分AE)`, `(Aを通り線分AEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分EA)`, `(Aを通り直線EAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線AE)`, `(Aを通り線分AEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線EA)`, `(Aを通り直線EAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線AE)`, `(Aを通りAEの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線EA)`, `(Aを通りEAの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分AF)`, `(Aを通り線分AFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分FA)`, `(Aを通り直線FAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線AF)`, `(Aを通り線分AFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線FA)`, `(Aを通り直線FAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線AF)`, `(Aを通りAFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線FA)`, `(Aを通りFAの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分BC)`, `(Aを通り線分BCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分CB)`, `(Aを通り直線CBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線BC)`, `(Aを通り線分BCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線CB)`, `(Aを通り直線CBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線BC)`, `(Aを通りBCの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線CB)`, `(Aを通りCBの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分BD)`, `(Aを通り線分BDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分DB)`, `(Aを通り直線DBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線BD)`, `(Aを通り線分BDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線DB)`, `(Aを通り直線DBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線BD)`, `(Aを通りBDの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線DB)`, `(Aを通りDBの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分BE)`, `(Aを通り線分BEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分EB)`, `(Aを通り直線EBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線BE)`, `(Aを通り線分BEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線EB)`, `(Aを通り直線EBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線BE)`, `(Aを通りBEの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線EB)`, `(Aを通りEBの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分BF)`, `(Aを通り線分BFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分FB)`, `(Aを通り直線FBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線BF)`, `(Aを通り線分BFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線FB)`, `(Aを通り直線FBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線BF)`, `(Aを通りBFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線FB)`, `(Aを通りFBの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分CD)`, `(Aを通り線分CDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分DC)`, `(Aを通り直線DCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線CD)`, `(Aを通り線分CDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線DC)`, `(Aを通り直線DCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線CD)`, `(Aを通りCDの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線DC)`, `(Aを通りDCの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分CE)`, `(Aを通り線分CEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分EC)`, `(Aを通り直線ECに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線CE)`, `(Aを通り線分CEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線EC)`, `(Aを通り直線ECに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線CE)`, `(Aを通りCEの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線EC)`, `(Aを通りECの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分CF)`, `(Aを通り線分CFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分FC)`, `(Aを通り直線FCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線CF)`, `(Aを通り線分CFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線FC)`, `(Aを通り直線FCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線CF)`, `(Aを通りCFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線FC)`, `(Aを通りFCの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分DE)`, `(Aを通り線分DEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分ED)`, `(Aを通り直線EDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線DE)`, `(Aを通り線分DEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線ED)`, `(Aを通り直線EDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線DE)`, `(Aを通りDEの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線ED)`, `(Aを通りEDの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分DF)`, `(Aを通り線分DFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分FD)`, `(Aを通り直線FDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線DF)`, `(Aを通り線分DFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線FD)`, `(Aを通り直線FDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線DF)`, `(Aを通りDFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線FD)`, `(Aを通りFDの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分EF))`, `(Aを通り線分EFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分FE)`, `(Aを通り直線FEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線EF)`, `(Aを通り線分EFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線FE)`, `(Aを通り直線FEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線EF)`, `(Aを通りEFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 垂直二等分線FE)`, `(Aを通りFEの垂直二等分線に垂直な直線)`);
          //Bを通る垂線
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分AB)`, `(Bを通り線分ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分BA)`, `(Bを通り直線BAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線AB)`, `(Bを通り線分ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線BA)`, `(Bを通り直線BAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線AB)`, `(Bを通りABの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線BA)`, `(Bを通りBAの垂直二等分線BAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分AC)`, `(Bを通り線分ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分CA)`, `(Bを通り直線ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線AC)`, `(Bを通り線分ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線CA)`, `(Bを通り直線ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線AC)`, `(Bを通りACの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線CA)`, `(Bを通りCAの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分AD)`, `(Bを通り線分ADに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分DA)`, `(Bを通り直線DAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線AD)`, `(Bを通り線分ADに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線DA)`, `(Bを通り直線DAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線AD)`, `(Bを通りADの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線DA)`, `(Bを通りDAの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分AE)`, `(Bを通り線分AEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分EA)`, `(Bを通り直線EAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線AE)`, `(Bを通り線分AEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線EA)`, `(Bを通り直線EAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線AE)`, `(Bを通りAEの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線EA)`, `(Bを通りEAの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分AF)`, `(Bを通り線分AFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分FA)`, `(Bを通り直線FAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線AF)`, `(Bを通り線分AFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線FA)`, `(Bを通り直線FAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線AF)`, `(Bを通りAFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線FA)`, `(Bを通りFAの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分BC)`, `(Bを通り線分BCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分CB)`, `(Bを通り直線CBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線BC)`, `(Bを通り線分BCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線CB)`, `(Bを通り直線CBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線BC)`, `(Bを通りBCの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線CB)`, `(Bを通りCBの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分BD)`, `(Bを通り線分BDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分DB)`, `(Bを通り直線DBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線BD)`, `(Bを通り線分BDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線DB)`, `(Bを通り直線DBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線BD)`, `(Bを通りBDの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線DB)`, `(Bを通りDBの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分BE)`, `(Bを通り線分BEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分EB)`, `(Bを通り直線EBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線BE)`, `(Bを通り線分BEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線EB)`, `(Bを通り直線EBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線BE)`, `(Bを通りBEの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線EB)`, `(Bを通りEBの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分BF)`, `(Bを通り線分BFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分FB)`, `(Bを通り直線FBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線BF)`, `(Bを通り線分BFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線FB)`, `(Bを通り直線FBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線BF)`, `(Bを通りBFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線FB)`, `(Bを通りFBの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分CD)`, `(Bを通り線分CDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分DC)`, `(Bを通り直線DCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線CD)`, `(Bを通り線分CDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線DC)`, `(Bを通り直線DCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線CD)`, `(Bを通りCDの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線DC)`, `(Bを通りDCの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分CE)`, `(Bを通り線分CEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分EC)`, `(Bを通り直線ECに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線CE)`, `(Bを通り線分CEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線EC)`, `(Bを通り直線ECに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線CE)`, `(Bを通りCEの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線EC)`, `(Bを通りECの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分CF)`, `(Bを通り線分CFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分FC)`, `(Bを通り直線FCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線CF)`, `(Bを通り線分CFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線FC)`, `(Bを通り直線FCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線CF)`, `(Bを通りCFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線FC)`, `(Bを通りFCの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分DE)`, `(Bを通り線分DEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分ED)`, `(Bを通り直線EDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線DE)`, `(Bを通り線分DEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線ED)`, `(Bを通り直線EDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線DE)`, `(Bを通りDEの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線ED)`, `(Bを通りEDの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分DF)`, `(Bを通り線分DFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分FD)`, `(Bを通り直線FDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線DF)`, `(Bを通り線分DFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線FD)`, `(Bを通り直線FDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線DF)`, `(Bを通りDFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線FD)`, `(Bを通りFDの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分EF)`, `(Bを通り線分EFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 線分FE)`, `(Bを通り直線FEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線EF)`, `(Bを通り線分EFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 直線FE)`, `(Bを通り直線FEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線EF)`, `(Bを通りEFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(B, 垂直二等分線FE)`, `(Bを通りFEの垂直二等分線に垂直な直線)`);
          //Cを通る垂線
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分AB)`, `(Cを通り線分ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分BA)`, `(Cを通り直線BAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線AB)`, `(Cを通り線分ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線BA)`, `(Cを通り直線BAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線AB)`, `(Cを通りABの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線BA)`, `(Cを通りBAの垂直二等分線BAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分AC)`, `(Cを通り線分ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分CA)`, `(Cを通り直線ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線AC)`, `(Cを通り線分ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線CA)`, `(Cを通り直線ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線AC)`, `(Cを通りACの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線CA)`, `(Cを通りCAの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分AD)`, `(Cを通り線分ADに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分DA)`, `(Cを通り直線DAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線AD)`, `(Cを通り線分ADに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線DA)`, `(Cを通り直線DAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線AD)`, `(Cを通りADの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線DA)`, `(Cを通りDAの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分AE)`, `(Cを通り線分AEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分EA)`, `(Cを通り直線EAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線AE)`, `(Cを通り線分AEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線EA)`, `(Cを通り直線EAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線AE)`, `(Cを通りAEの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線EA)`, `(Cを通りEAの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分AF)`, `(Cを通り線分AFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分FA)`, `(Cを通り直線FAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線AF)`, `(Cを通り線分AFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線FA)`, `(Cを通り直線FAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線AF)`, `(Cを通りAFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線FA)`, `(Cを通りFAの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分BC)`, `(Cを通り線分BCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分CB)`, `(Cを通り直線CBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線BC)`, `(Cを通り線分BCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線CB)`, `(Cを通り直線CBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線BC)`, `(Cを通りBCの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線CB)`, `(Cを通りCBの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分BD)`, `(Cを通り線分BDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分DB)`, `(Cを通り直線DBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線BD)`, `(Cを通り線分BDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線DB)`, `(Cを通り直線DBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線BD)`, `(Cを通りBDの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線DB)`, `(Cを通りDBの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分BE)`, `(Cを通り線分BEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分EB)`, `(Cを通り直線EBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線BE)`, `(Cを通り線分BEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線EB)`, `(Cを通り直線EBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線BE)`, `(Cを通りBEの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線EB)`, `(Cを通りEBの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分BF)`, `(Cを通り線分BFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分FB)`, `(Cを通り直線FBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線BF)`, `(Cを通り線分BFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線FB)`, `(Cを通り直線FBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線BF)`, `(Cを通りBFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線FB)`, `(Cを通りFBの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分CD)`, `(Cを通り線分CDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分DC)`, `(Cを通り直線DCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線CD)`, `(Cを通り線分CDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線DC)`, `(Cを通り直線DCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線CD)`, `(Cを通りCDの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線DC)`, `(Cを通りDCの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分CE)`, `(Cを通り線分CEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分EC)`, `(Cを通り直線ECに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線CE)`, `(Cを通り線分CEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線EC)`, `(Cを通り直線ECに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線CE)`, `(Cを通りCEの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線EC)`, `(Cを通りECの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分CF)`, `(Cを通り線分CFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分FC)`, `(Cを通り直線FCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線CF)`, `(Cを通り線分CFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線FC)`, `(Cを通り直線FCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線CF)`, `(Cを通りCFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線FC)`, `(Cを通りFCの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分DE)`, `(Cを通り線分DEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分ED)`, `(Cを通り直線EDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線DE)`, `(Cを通り線分DEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線ED)`, `(Cを通り直線EDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線DE)`, `(Cを通りDEの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線ED)`, `(Cを通りEDの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分DF)`, `(Cを通り線分DFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分FD)`, `(Cを通り直線FDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線DF)`, `(Cを通り線分DFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線FD)`, `(Cを通り直線FDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線DF)`, `(Cを通りDFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線FD)`, `(Cを通りFDの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分EF))`, `(Cを通り線分EFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 線分FE)`, `(Cを通り直線FEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線EF)`, `(Cを通り線分EFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 直線FE)`, `(Cを通り直線FEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線EF)`, `(Cを通りEFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(C, 垂直二等分線FE)`, `(Cを通りFEの垂直二等分線に垂直な直線)`);
          //Dを通る垂線
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分AB)`, `(Dを通り線分ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分BA)`, `(Dを通り直線BAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線AB)`, `(Dを通り線分ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線BA)`, `(Dを通り直線BAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線AB)`, `(Dを通りABの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線BA)`, `(Dを通りBAの垂直二等分線BAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分AC)`, `(Dを通り線分ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分CA)`, `(Dを通り直線ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線AC)`, `(Dを通り線分ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線CA)`, `(Dを通り直線ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線AC)`, `(Dを通りACの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線CA)`, `(Dを通りCAの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分AD)`, `(Dを通り線分ADに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分DA)`, `(Dを通り直線DAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線AD)`, `(Dを通り線分ADに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線DA)`, `(Dを通り直線DAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線AD)`, `(Dを通りADの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線DA)`, `(Dを通りDAの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分AE)`, `(Dを通り線分AEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分EA)`, `(Dを通り直線EAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線AE)`, `(Dを通り線分AEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線EA)`, `(Dを通り直線EAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線AE)`, `(Dを通りAEの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線EA)`, `(Dを通りEAの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分AF)`, `(Dを通り線分AFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分FA)`, `(Dを通り直線FAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線AF)`, `(Dを通り線分AFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線FA)`, `(Dを通り直線FAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線AF)`, `(Dを通りAFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線FA)`, `(Dを通りFAの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分BC)`, `(Dを通り線分BCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分CB)`, `(Dを通り直線CBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線BC)`, `(Dを通り線分BCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線CB)`, `(Dを通り直線CBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線BC)`, `(Dを通りBCの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線CB)`, `(Dを通りCBの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分BD)`, `(Dを通り線分BDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分DB)`, `(Dを通り直線DBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線BD)`, `(Dを通り線分BDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線DB)`, `(Dを通り直線DBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線BD)`, `(Dを通りBDの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線DB)`, `(Dを通りDBの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分BE)`, `(Dを通り線分BEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分EB)`, `(Dを通り直線EBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線BE)`, `(Dを通り線分BEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線EB)`, `(Dを通り直線EBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線BE)`, `(Dを通りBEの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線EB)`, `(Dを通りEBの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分BF)`, `(Dを通り線分BFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分FB)`, `(Dを通り直線FBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線BF)`, `(Dを通り線分BFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線FB)`, `(Dを通り直線FBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線BF)`, `(Dを通りBFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線FB)`, `(Dを通りFBの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分CD)`, `(Dを通り線分CDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分DC)`, `(Dを通り直線DCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線CD)`, `(Dを通り線分CDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線DC)`, `(Dを通り直線DCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線CD)`, `(Dを通りCDの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線DC)`, `(Dを通りDCの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分CE)`, `(Dを通り線分CEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分EC)`, `(Dを通り直線ECに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線CE)`, `(Dを通り線分CEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線EC)`, `(Dを通り直線ECに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線CE)`, `(Dを通りCEの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線EC)`, `(Dを通りECの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分CF)`, `(Dを通り線分CFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分FC)`, `(Dを通り直線FCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線CF)`, `(Dを通り線分CFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線FC)`, `(Dを通り直線FCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線CF)`, `(Dを通りCFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線FC)`, `(Dを通りFCの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分DE)`, `(Dを通り線分DEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分ED)`, `(Dを通り直線EDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線DE)`, `(Dを通り線分DEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線ED)`, `(Dを通り直線EDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線DE)`, `(Dを通りDEの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線ED)`, `(Dを通りEDの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分DF)`, `(Dを通り線分DFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分FD)`, `(Dを通り直線FDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線DF)`, `(Dを通り線分DFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線FD)`, `(Dを通り直線FDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線DF)`, `(Dを通りDFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線FD)`, `(Dを通りFDの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分EF)`, `(Dを通り線分EFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 線分FE)`, `(Dを通り直線FEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線EF)`, `(Dを通り線分EFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 直線FE)`, `(Dを通り直線FEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線EF)`, `(Dを通りEFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(D, 垂直二等分線FE)`, `(Dを通りFEの垂直二等分線に垂直な直線)`);
          //Eを通る垂線
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分AB)`, `(Eを通り線分ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分BA)`, `(Eを通り直線BAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線AB)`, `(Eを通り線分ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線BA)`, `(Eを通り直線BAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線AB)`, `(Eを通りABの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線BA)`, `(Eを通りBAの垂直二等分線BAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分AC)`, `(Eを通り線分ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分CA)`, `(Eを通り直線ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線AC)`, `(Eを通り線分ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線CA)`, `(Eを通り直線ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線AC)`, `(Eを通りACの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線CA)`, `(Eを通りCAの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分AD)`, `(Eを通り線分ADに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分DA)`, `(Eを通り直線DAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線AD)`, `(Eを通り線分ADに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線DA)`, `(Eを通り直線DAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線AD)`, `(Eを通りADの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線DA)`, `(Eを通りDAの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分AE)`, `(Eを通り線分AEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分EA)`, `(Eを通り直線EAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線AE)`, `(Eを通り線分AEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線EA)`, `(Eを通り直線EAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線AE)`, `(Eを通りAEの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線EA)`, `(Eを通りEAの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分AF)`, `(Eを通り線分AFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分FA)`, `(Eを通り直線FAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線AF)`, `(Eを通り線分AFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線FA)`, `(Eを通り直線FAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線AF)`, `(Eを通りAFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線FA)`, `(Eを通りFAの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分BC)`, `(Eを通り線分BCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分CB)`, `(Eを通り直線CBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線BC)`, `(Eを通り線分BCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線CB)`, `(Eを通り直線CBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線BC)`, `(Eを通りBCの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線CB)`, `(Eを通りCBの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分BD)`, `(Eを通り線分BDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分DB)`, `(Eを通り直線DBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線BD)`, `(Eを通り線分BDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線DB)`, `(Eを通り直線DBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線BD)`, `(Eを通りBDの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線DB)`, `(Eを通りDBの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分BE)`, `(Eを通り線分BEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分EB)`, `(Eを通り直線EBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線BE)`, `(Eを通り線分BEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線EB)`, `(Eを通り直線EBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線BE)`, `(Eを通りBEの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線EB)`, `(Eを通りEBの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分BF)`, `(Eを通り線分BFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分FB)`, `(Eを通り直線FBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線BF)`, `(Eを通り線分BFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線FB)`, `(Eを通り直線FBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線BF)`, `(Eを通りBFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線FB)`, `(Eを通りFBの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分CD)`, `(Eを通り線分CDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分DC)`, `(Eを通り直線DCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線CD)`, `(Eを通り線分CDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線DC)`, `(Eを通り直線DCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線CD)`, `(Eを通りCDの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線DC)`, `(Eを通りDCの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分CE)`, `(Eを通り線分CEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分EC)`, `(Eを通り直線ECに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線CE)`, `(Eを通り線分CEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線EC)`, `(Eを通り直線ECに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線CE)`, `(Eを通りCEの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線EC)`, `(Eを通りECの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分CF)`, `(Eを通り線分CFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分FC)`, `(Eを通り直線FCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線CF)`, `(Eを通り線分CFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線FC)`, `(Eを通り直線FCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線CF)`, `(Eを通りCFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線FC)`, `(Eを通りFCの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分DE)`, `(Eを通り線分DEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分ED)`, `(Eを通り直線EDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線DE)`, `(Eを通り線分DEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線ED)`, `(Eを通り直線EDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線DE)`, `(Eを通りDEの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線ED)`, `(Eを通りEDの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分DF)`, `(Eを通り線分DFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分FD)`, `(Eを通り直線FDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線DF)`, `(Eを通り線分DFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線FD)`, `(Eを通り直線FDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線DF)`, `(Eを通りDFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線FD)`, `(Eを通りFDの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分EF)`, `(Eを通り線分EFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 線分FE)`, `(Eを通り直線FEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線EF)`, `(Eを通り線分EFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 直線FE)`, `(Eを通り直線FEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線EF)`, `(Eを通りEFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(E, 垂直二等分線FE)`, `(Eを通りFEの垂直二等分線に垂直な直線)`);
          //Fを通る垂線
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分AB)`, `(Fを通り線分ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分BA)`, `(Fを通り直線BAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線AB)`, `(Fを通り線分ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線BA)`, `(Fを通り直線BAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線AB)`, `(Fを通りABの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線BA)`, `(Fを通りBAの垂直二等分線BAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分AC)`, `(Fを通り線分ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分CA)`, `(Fを通り直線ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線AC)`, `(Fを通り線分ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線CA)`, `(Fを通り直線ABに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線AC)`, `(Fを通りACの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線CA)`, `(Fを通りCAの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分AD)`, `(Fを通り線分ADに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分DA)`, `(Fを通り直線DAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線AD)`, `(Fを通り線分ADに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線DA)`, `(Fを通り直線DAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線AD)`, `(Fを通りADの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線DA)`, `(Fを通りDAの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分AE)`, `(Fを通り線分AEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分EA)`, `(Fを通り直線EAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線AE)`, `(Fを通り線分AEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線EA)`, `(Fを通り直線EAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線AE)`, `(Fを通りAEの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線EA)`, `(Fを通りEAの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分AF)`, `(Fを通り線分AFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分FA)`, `(Fを通り直線FAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線AF)`, `(Fを通り線分AFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線FA)`, `(Fを通り直線FAに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線AF)`, `(Fを通りAFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線FA)`, `(Fを通りFAの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分BC)`, `(Fを通り線分BCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分CB)`, `(Fを通り直線CBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線BC)`, `(Fを通り線分BCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線CB)`, `(Fを通り直線CBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線BC)`, `(Fを通りBCの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線CB)`, `(Fを通りCBの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分BD)`, `(Fを通り線分BDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分DB)`, `(Fを通り直線DBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線BD)`, `(Fを通り線分BDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線DB)`, `(Fを通り直線DBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線BD)`, `(Fを通りBDの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線DB)`, `(Fを通りDBの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分BE)`, `(Fを通り線分BEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分EB)`, `(Fを通り直線EBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線BE)`, `(Fを通り線分BEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線EB)`, `(Fを通り直線EBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線BE)`, `(Fを通りBEの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線EB)`, `(Fを通りEBの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分BF)`, `(Fを通り線分BFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分FB)`, `(Fを通り直線FBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線BF)`, `(Fを通り線分BFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線FB)`, `(Fを通り直線FBに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線BF)`, `(Fを通りBFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線FB)`, `(Fを通りFBの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分CD)`, `(Fを通り線分CDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分DC)`, `(Fを通り直線DCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線CD)`, `(Fを通り線分CDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線DC)`, `(Fを通り直線DCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線CD)`, `(Fを通りCDの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線DC)`, `(Fを通りDCの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分CE)`, `(Fを通り線分CEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分EC)`, `(Fを通り直線ECに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線CE)`, `(Fを通り線分CEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線EC)`, `(Fを通り直線ECに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線CE)`, `(Fを通りCEの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線EC)`, `(Fを通りECの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分CF)`, `(Fを通り線分CFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分FC)`, `(Fを通り直線FCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線CF)`, `(Fを通り線分CFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線FC)`, `(Fを通り直線FCに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線CF)`, `(Fを通りCFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線FC)`, `(Fを通りFCの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分DE)`, `(Fを通り線分DEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分ED)`, `(Fを通り直線EDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線DE)`, `(Fを通り線分DEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線ED)`, `(Fを通り直線EDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線DE)`, `(Fを通りDEの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線ED)`, `(Fを通りEDの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分DF)`, `(Fを通り線分DFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分FD)`, `(Fを通り直線FDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線DF)`, `(Fを通り線分DFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線FD)`, `(Fを通り直線FDに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線DF)`, `(Fを通りDFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線FD)`, `(Fを通りFDの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分EF)`, `(Fを通り線分EFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 線分FE)`, `(Fを通り直線FEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線EF)`, `(Fを通り線分EFに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 直線FE)`, `(Fを通り直線FEに垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線EF)`, `(Fを通りEFの垂直二等分線に垂直な直線)`);
          descriptionStr = descriptionStr.replace(`PerpendicularLine(F, 垂直二等分線FE)`, `(Fを通りFEの垂直二等分線に垂直な直線)`);

          //Aを通る平行線
          descriptionStr = descriptionStr.replace(`Line(A, (線分AB))`, `(Aを通り線分ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分BA))`, `(Aを通り直線BAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線AB))`, `(Aを通り線分ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線BA))`, `(Aを通り直線BAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線AB))`, `(Aを通りABの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線BA))`, `(Aを通りBAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分AC))`, `(Aを通り線分ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分CA))`, `(Aを通り直線ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線AC))`, `(Aを通り線分ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線CA))`, `(Aを通り直線ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線AC))`, `(Aを通りACの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線CA))`, `(Aを通りCAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分AD))`, `(Aを通り線分ADに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分DA))`, `(Aを通り直線DAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線AD))`, `(Aを通り線分ADに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線DA))`, `(Aを通り直線DAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線AD))`, `(Aを通りADの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線DA))`, `(Aを通りDAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分AE))`, `(Aを通り線分AEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分EA))`, `(Aを通り直線EAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線AE))`, `(Aを通り線分AEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線EA))`, `(Aを通り直線EAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線AE))`, `(Aを通りAEの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線EA))`, `(Aを通りEAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分AF))`, `(Aを通り線分AFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分FA))`, `(Aを通り直線FAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線AF))`, `(Aを通り線分AFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線FA))`, `(Aを通り直線FAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線AF))`, `(Aを通りAFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線FA))`, `(Aを通りFAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分BC))`, `(Aを通り線分BCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分CB))`, `(Aを通り直線CBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線BC))`, `(Aを通り線分BCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線CB))`, `(Aを通り直線CBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線BC))`, `(Aを通りBCの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線CB))`, `(Aを通りCBの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分BD))`, `(Aを通り線分BDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分DB))`, `(Aを通り直線DBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線BD))`, `(Aを通り線分BDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線DB))`, `(Aを通り直線DBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線BD))`, `(Aを通りBDの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線DB))`, `(Aを通りDBの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分BE))`, `(Aを通り線分BEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分EB))`, `(Aを通り直線EBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線BE))`, `(Aを通り線分BEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線EB))`, `(Aを通り直線EBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線BE))`, `(Aを通りBEの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線EB))`, `(Aを通りEBの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分BF))`, `(Aを通り線分BFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分FB))`, `(Aを通り直線FBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線BF))`, `(Aを通り線分BFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線FB))`, `(Aを通り直線FBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線BF))`, `(Aを通りBFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線FB))`, `(Aを通りFBの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分CD))`, `(Aを通り線分CDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分DC))`, `(Aを通り直線DCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線CD))`, `(Aを通り線分CDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線DC))`, `(Aを通り直線DCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線CD))`, `(Aを通りCDの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線DC))`, `(Aを通りDCの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分CE))`, `(Aを通り線分CEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分EC))`, `(Aを通り直線ECに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線CE))`, `(Aを通り線分CEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線EC))`, `(Aを通り直線ECに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線CE))`, `(Aを通りCEの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線EC))`, `(Aを通りECの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分CF))`, `(Aを通り線分CFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分FC))`, `(Aを通り直線FCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線CF))`, `(Aを通り線分CFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線FC))`, `(Aを通り直線FCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線CF))`, `(Aを通りCFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線FC))`, `(Aを通りFCの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分DE))`, `(Aを通り線分DEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分ED))`, `(Aを通り直線EDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線DE))`, `(Aを通り線分DEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線ED))`, `(Aを通り直線EDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線DE))`, `(Aを通りDEの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線ED))`, `(Aを通りEDの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分DF))`, `(Aを通り線分DFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分FD))`, `(Aを通り直線FDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線DF))`, `(Aを通り線分DFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線FD))`, `(Aを通り直線FDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線DF))`, `(Aを通りDFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線FD))`, `(Aを通りFDの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分EF))`, `(Aを通り線分EFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (線分FE))`, `(Aを通り直線FEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線EF))`, `(Aを通り線分EFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (直線FE))`, `(Aを通り直線FEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線EF))`, `(Aを通りEFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(A, (垂直二等分線FE))`, `(Aを通りFEの垂直二等分線に平行な直線)`);
          //Bを通る平行線
          descriptionStr = descriptionStr.replace(`Line(B, (線分AB))`, `(Bを通り線分ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分BA))`, `(Bを通り直線BAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線AB))`, `(Bを通り線分ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線BA))`, `(Bを通り直線BAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線AB))`, `(Bを通りABの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線BA))`, `(Bを通りBAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分AC))`, `(Bを通り線分ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分CA))`, `(Bを通り直線ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線AC))`, `(Bを通り線分ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線CA))`, `(Bを通り直線ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線AC))`, `(Bを通りACの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線CA))`, `(Bを通りCAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分AD))`, `(Bを通り線分ADに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分DA))`, `(Bを通り直線DAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線AD))`, `(Bを通り線分ADに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線DA))`, `(Bを通り直線DAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線AD))`, `(Bを通りADの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線DA))`, `(Bを通りDAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分AE))`, `(Bを通り線分AEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分EA))`, `(Bを通り直線EAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線AE))`, `(Bを通り線分AEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線EA))`, `(Bを通り直線EAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線AE))`, `(Bを通りAEの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線EA))`, `(Bを通りEAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分AF))`, `(Bを通り線分AFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分FA))`, `(Bを通り直線FAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線AF))`, `(Bを通り線分AFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線FA))`, `(Bを通り直線FAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線AF))`, `(Bを通りAFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線FA))`, `(Bを通りFAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分BC))`, `(Bを通り線分BCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分CB))`, `(Bを通り直線CBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線BC))`, `(Bを通り線分BCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線CB))`, `(Bを通り直線CBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線BC))`, `(Bを通りBCの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線CB))`, `(Bを通りCBの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分BD))`, `(Bを通り線分BDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分DB))`, `(Bを通り直線DBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線BD))`, `(Bを通り線分BDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線DB))`, `(Bを通り直線DBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線BD))`, `(Bを通りBDの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線DB))`, `(Bを通りDBの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分BE))`, `(Bを通り線分BEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分EB))`, `(Bを通り直線EBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線BE))`, `(Bを通り線分BEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線EB))`, `(Bを通り直線EBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線BE))`, `(Bを通りBEの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線EB))`, `(Bを通りEBの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分BF))`, `(Bを通り線分BFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分FB))`, `(Bを通り直線FBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線BF))`, `(Bを通り線分BFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線FB))`, `(Bを通り直線FBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線BF))`, `(Bを通りBFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線FB))`, `(Bを通りFBの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分CD))`, `(Bを通り線分CDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分DC))`, `(Bを通り直線DCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線CD))`, `(Bを通り線分CDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線DC))`, `(Bを通り直線DCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線CD))`, `(Bを通りCDの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線DC))`, `(Bを通りDCの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分CE))`, `(Bを通り線分CEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分EC))`, `(Bを通り直線ECに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線CE))`, `(Bを通り線分CEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線EC))`, `(Bを通り直線ECに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線CE))`, `(Bを通りCEの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線EC))`, `(Bを通りECの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分CF))`, `(Bを通り線分CFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分FC))`, `(Bを通り直線FCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線CF))`, `(Bを通り線分CFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線FC))`, `(Bを通り直線FCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線CF))`, `(Bを通りCFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線FC))`, `(Bを通りFCの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分DE))`, `(Bを通り線分DEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分ED))`, `(Bを通り直線EDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線DE))`, `(Bを通り線分DEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線ED))`, `(Bを通り直線EDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線DE))`, `(Bを通りDEの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線ED))`, `(Bを通りEDの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分DF))`, `(Bを通り線分DFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分FD))`, `(Bを通り直線FDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線DF))`, `(Bを通り線分DFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線FD))`, `(Bを通り直線FDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線DF))`, `(Bを通りDFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線FD))`, `(Bを通りFDの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分EF))`, `(Bを通り線分EFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分FE))`, `(Bを通り直線FEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線EF))`, `(Bを通り線分EFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線FE))`, `(Bを通り直線FEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線EF))`, `(Bを通りEFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線FE))`, `(Bを通りFEの垂直二等分線に平行な直線)`);
          //Cを通る垂線
          descriptionStr = descriptionStr.replace(`Line(B, (線分AB))`, `(Cを通り線分ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分BA))`, `(Cを通り直線BAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線AB))`, `(Cを通り線分ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線BA))`, `(Cを通り直線BAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線AB))`, `(Cを通りABの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線BA))`, `(Cを通りBAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分AC))`, `(Cを通り線分ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分CA))`, `(Cを通り直線ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線AC))`, `(Cを通り線分ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線CA))`, `(Cを通り直線ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線AC))`, `(Cを通りACの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線CA))`, `(Cを通りCAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分AD))`, `(Cを通り線分ADに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分DA))`, `(Cを通り直線DAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線AD))`, `(Cを通り線分ADに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線DA))`, `(Cを通り直線DAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線AD))`, `(Cを通りADの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線DA))`, `(Cを通りDAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分AE))`, `(Cを通り線分AEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分EA))`, `(Cを通り直線EAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線AE))`, `(Cを通り線分AEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線EA))`, `(Cを通り直線EAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線AE))`, `(Cを通りAEの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線EA))`, `(Cを通りEAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分AF))`, `(Cを通り線分AFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分FA))`, `(Cを通り直線FAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線AF))`, `(Cを通り線分AFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線FA))`, `(Cを通り直線FAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線AF))`, `(Cを通りAFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線FA))`, `(Cを通りFAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分BC))`, `(Cを通り線分BCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分CB))`, `(Cを通り直線CBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線BC))`, `(Cを通り線分BCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線CB))`, `(Cを通り直線CBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線BC))`, `(Cを通りBCの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線CB))`, `(Cを通りCBの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分BD))`, `(Cを通り線分BDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分DB))`, `(Cを通り直線DBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線BD))`, `(Cを通り線分BDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線DB))`, `(Cを通り直線DBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線BD))`, `(Cを通りBDの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線DB))`, `(Cを通りDBの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分BE))`, `(Cを通り線分BEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分EB))`, `(Cを通り直線EBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線BE))`, `(Cを通り線分BEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線EB))`, `(Cを通り直線EBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線BE))`, `(Cを通りBEの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線EB))`, `(Cを通りEBの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分BF))`, `(Cを通り線分BFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分FB))`, `(Cを通り直線FBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線BF))`, `(Cを通り線分BFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線FB))`, `(Cを通り直線FBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線BF))`, `(Cを通りBFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線FB))`, `(Cを通りFBの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分CD))`, `(Cを通り線分CDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分DC))`, `(Cを通り直線DCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線CD))`, `(Cを通り線分CDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線DC))`, `(Cを通り直線DCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線CD))`, `(Cを通りCDの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線DC))`, `(Cを通りDCの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分CE))`, `(Cを通り線分CEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分EC))`, `(Cを通り直線ECに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線CE))`, `(Cを通り線分CEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線EC))`, `(Cを通り直線ECに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線CE))`, `(Cを通りCEの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線EC))`, `(Cを通りECの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分CF))`, `(Cを通り線分CFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分FC))`, `(Cを通り直線FCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線CF))`, `(Cを通り線分CFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線FC))`, `(Cを通り直線FCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線CF))`, `(Cを通りCFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線FC))`, `(Cを通りFCの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分DE))`, `(Cを通り線分DEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分ED))`, `(Cを通り直線EDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線DE))`, `(Cを通り線分DEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線ED))`, `(Cを通り直線EDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線DE))`, `(Cを通りDEの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線ED))`, `(Cを通りEDの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分DF))`, `(Cを通り線分DFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分FD))`, `(Cを通り直線FDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線DF))`, `(Cを通り線分DFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線FD))`, `(Cを通り直線FDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線DF))`, `(Cを通りDFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線FD))`, `(Cを通りFDの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分EF))`, `(Cを通り線分EFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (線分FE))`, `(Cを通り直線FEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線EF))`, `(Cを通り線分EFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (直線FE))`, `(Cを通り直線FEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線EF))`, `(Cを通りEFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(B, (垂直二等分線FE))`, `(Cを通りFEの垂直二等分線に平行な直線)`);
          //Dを通る垂線
          descriptionStr = descriptionStr.replace(`Line(D, (線分AB))`, `(Dを通り線分ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分BA))`, `(Dを通り直線BAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線AB))`, `(Dを通り線分ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線BA))`, `(Dを通り直線BAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線AB))`, `(Dを通りABの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線BA))`, `(Dを通りBAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分AC))`, `(Dを通り線分ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分CA))`, `(Dを通り直線ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線AC))`, `(Dを通り線分ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線CA))`, `(Dを通り直線ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線AC))`, `(Dを通りACの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線CA))`, `(Dを通りCAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分AD))`, `(Dを通り線分ADに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分DA))`, `(Dを通り直線DAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線AD))`, `(Dを通り線分ADに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線DA))`, `(Dを通り直線DAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線AD))`, `(Dを通りADの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線DA))`, `(Dを通りDAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分AE))`, `(Dを通り線分AEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分EA))`, `(Dを通り直線EAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線AE))`, `(Dを通り線分AEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線EA))`, `(Dを通り直線EAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線AE))`, `(Dを通りAEの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線EA))`, `(Dを通りEAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分AF))`, `(Dを通り線分AFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分FA))`, `(Dを通り直線FAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線AF))`, `(Dを通り線分AFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線FA))`, `(Dを通り直線FAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線AF))`, `(Dを通りAFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線FA))`, `(Dを通りFAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分BC))`, `(Dを通り線分BCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分CB))`, `(Dを通り直線CBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線BC))`, `(Dを通り線分BCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線CB))`, `(Dを通り直線CBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線BC))`, `(Dを通りBCの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線CB))`, `(Dを通りCBの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分BD))`, `(Dを通り線分BDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分DB))`, `(Dを通り直線DBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線BD))`, `(Dを通り線分BDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線DB))`, `(Dを通り直線DBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線BD))`, `(Dを通りBDの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線DB))`, `(Dを通りDBの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分BE))`, `(Dを通り線分BEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分EB))`, `(Dを通り直線EBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線BE))`, `(Dを通り線分BEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線EB))`, `(Dを通り直線EBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線BE))`, `(Dを通りBEの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線EB))`, `(Dを通りEBの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分BF))`, `(Dを通り線分BFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分FB))`, `(Dを通り直線FBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線BF))`, `(Dを通り線分BFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線FB))`, `(Dを通り直線FBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線BF))`, `(Dを通りBFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線FB))`, `(Dを通りFBの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分CD))`, `(Dを通り線分CDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分DC))`, `(Dを通り直線DCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線CD))`, `(Dを通り線分CDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線DC))`, `(Dを通り直線DCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線CD))`, `(Dを通りCDの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線DC))`, `(Dを通りDCの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分CE))`, `(Dを通り線分CEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分EC))`, `(Dを通り直線ECに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線CE))`, `(Dを通り線分CEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線EC))`, `(Dを通り直線ECに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線CE))`, `(Dを通りCEの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線EC))`, `(Dを通りECの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分CF))`, `(Dを通り線分CFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分FC))`, `(Dを通り直線FCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線CF))`, `(Dを通り線分CFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線FC))`, `(Dを通り直線FCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線CF))`, `(Dを通りCFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線FC))`, `(Dを通りFCの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分DE))`, `(Dを通り線分DEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分ED))`, `(Dを通り直線EDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線DE))`, `(Dを通り線分DEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線ED))`, `(Dを通り直線EDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線DE))`, `(Dを通りDEの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線ED))`, `(Dを通りEDの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分DF))`, `(Dを通り線分DFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分FD))`, `(Dを通り直線FDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線DF))`, `(Dを通り線分DFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線FD))`, `(Dを通り直線FDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線DF))`, `(Dを通りDFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線FD))`, `(Dを通りFDの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分EF))`, `(Dを通り線分EFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (線分FE))`, `(Dを通り直線FEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線EF))`, `(Dを通り線分EFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (直線FE))`, `(Dを通り直線FEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線EF))`, `(Dを通りEFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(D, (垂直二等分線FE))`, `(Dを通りFEの垂直二等分線に平行な直線)`);
          //Eを通る垂線
          descriptionStr = descriptionStr.replace(`Line(E, (線分AB))`, `(Eを通り線分ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分BA))`, `(Eを通り直線BAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線AB))`, `(Eを通り線分ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線BA))`, `(Eを通り直線BAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線AB))`, `(Eを通りABの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線BA))`, `(Eを通りBAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分AC))`, `(Eを通り線分ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分CA))`, `(Eを通り直線ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線AC))`, `(Eを通り線分ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線CA))`, `(Eを通り直線ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線AC))`, `(Eを通りACの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線CA))`, `(Eを通りCAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分AD))`, `(Eを通り線分ADに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分DA))`, `(Eを通り直線DAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線AD))`, `(Eを通り線分ADに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線DA))`, `(Eを通り直線DAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線AD))`, `(Eを通りADの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線DA))`, `(Eを通りDAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分AE))`, `(Eを通り線分AEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分EA))`, `(Eを通り直線EAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線AE))`, `(Eを通り線分AEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線EA))`, `(Eを通り直線EAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線AE))`, `(Eを通りAEの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線EA))`, `(Eを通りEAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分AF))`, `(Eを通り線分AFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分FA))`, `(Eを通り直線FAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線AF))`, `(Eを通り線分AFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線FA))`, `(Eを通り直線FAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線AF))`, `(Eを通りAFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線FA))`, `(Eを通りFAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分BC))`, `(Eを通り線分BCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分CB))`, `(Eを通り直線CBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線BC))`, `(Eを通り線分BCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線CB))`, `(Eを通り直線CBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線BC))`, `(Eを通りBCの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線CB))`, `(Eを通りCBの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分BD))`, `(Eを通り線分BDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分DB))`, `(Eを通り直線DBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線BD))`, `(Eを通り線分BDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線DB))`, `(Eを通り直線DBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線BD))`, `(Eを通りBDの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線DB))`, `(Eを通りDBの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分BE))`, `(Eを通り線分BEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分EB))`, `(Eを通り直線EBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線BE))`, `(Eを通り線分BEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線EB))`, `(Eを通り直線EBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線BE))`, `(Eを通りBEの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線EB))`, `(Eを通りEBの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分BF))`, `(Eを通り線分BFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分FB))`, `(Eを通り直線FBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線BF))`, `(Eを通り線分BFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線FB))`, `(Eを通り直線FBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線BF))`, `(Eを通りBFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線FB))`, `(Eを通りFBの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分CD))`, `(Eを通り線分CDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分DC))`, `(Eを通り直線DCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線CD))`, `(Eを通り線分CDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線DC))`, `(Eを通り直線DCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線CD))`, `(Eを通りCDの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線DC))`, `(Eを通りDCの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分CE))`, `(Eを通り線分CEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分EC))`, `(Eを通り直線ECに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線CE))`, `(Eを通り線分CEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線EC))`, `(Eを通り直線ECに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線CE))`, `(Eを通りCEの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線EC))`, `(Eを通りECの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分CF))`, `(Eを通り線分CFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分FC))`, `(Eを通り直線FCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線CF))`, `(Eを通り線分CFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線FC))`, `(Eを通り直線FCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線CF))`, `(Eを通りCFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線FC))`, `(Eを通りFCの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分DE))`, `(Eを通り線分DEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分ED))`, `(Eを通り直線EDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線DE))`, `(Eを通り線分DEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線ED))`, `(Eを通り直線EDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線DE))`, `(Eを通りDEの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線ED))`, `(Eを通りEDの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分DF))`, `(Eを通り線分DFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分FD))`, `(Eを通り直線FDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線DF))`, `(Eを通り線分DFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線FD))`, `(Eを通り直線FDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線DF))`, `(Eを通りDFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線FD))`, `(Eを通りFDの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分EF))`, `(Eを通り線分EFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (線分FE))`, `(Eを通り直線FEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線EF))`, `(Eを通り線分EFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (直線FE))`, `(Eを通り直線FEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線EF))`, `(Eを通りEFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(E, (垂直二等分線FE))`, `(Eを通りFEの垂直二等分線に平行な直線)`);
          //Fを通る垂線
          descriptionStr = descriptionStr.replace(`Line(F, (線分AB))`, `(Fを通り線分ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分BA))`, `(Fを通り直線BAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線AB))`, `(Fを通り線分ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線BA))`, `(Fを通り直線BAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線AB))`, `(Fを通りABの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線BA))`, `(Fを通りBAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分AC))`, `(Fを通り線分ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分CA))`, `(Fを通り直線ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線AC))`, `(Fを通り線分ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線CA))`, `(Fを通り直線ABに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線AC))`, `(Fを通りACの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線CA))`, `(Fを通りCAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分AD))`, `(Fを通り線分ADに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分DA))`, `(Fを通り直線DAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線AD))`, `(Fを通り線分ADに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線DA))`, `(Fを通り直線DAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線AD))`, `(Fを通りADの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線DA))`, `(Fを通りDAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分AE))`, `(Fを通り線分AEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分EA))`, `(Fを通り直線EAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線AE))`, `(Fを通り線分AEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線EA))`, `(Fを通り直線EAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線AE))`, `(Fを通りAEの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線EA))`, `(Fを通りEAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分AF))`, `(Fを通り線分AFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分FA))`, `(Fを通り直線FAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線AF))`, `(Fを通り線分AFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線FA))`, `(Fを通り直線FAに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線AF))`, `(Fを通りAFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線FA))`, `(Fを通りFAの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分BC))`, `(Fを通り線分BCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分CB))`, `(Fを通り直線CBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線BC))`, `(Fを通り線分BCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線CB))`, `(Fを通り直線CBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線BC))`, `(Fを通りBCの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線CB))`, `(Fを通りCBの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分BD))`, `(Fを通り線分BDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分DB))`, `(Fを通り直線DBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線BD))`, `(Fを通り線分BDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線DB))`, `(Fを通り直線DBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線BD))`, `(Fを通りBDの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線DB))`, `(Fを通りDBの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分BE))`, `(Fを通り線分BEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分EB))`, `(Fを通り直線EBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線BE))`, `(Fを通り線分BEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線EB))`, `(Fを通り直線EBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線BE))`, `(Fを通りBEの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線EB))`, `(Fを通りEBの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分BF))`, `(Fを通り線分BFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分FB))`, `(Fを通り直線FBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線BF))`, `(Fを通り線分BFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線FB))`, `(Fを通り直線FBに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線BF))`, `(Fを通りBFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線FB))`, `(Fを通りFBの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分CD))`, `(Fを通り線分CDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分DC))`, `(Fを通り直線DCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線CD))`, `(Fを通り線分CDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線DC))`, `(Fを通り直線DCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線CD))`, `(Fを通りCDの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線DC))`, `(Fを通りDCの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分CE))`, `(Fを通り線分CEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分EC))`, `(Fを通り直線ECに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線CE))`, `(Fを通り線分CEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線EC))`, `(Fを通り直線ECに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線CE))`, `(Fを通りCEの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線EC))`, `(Fを通りECの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分CF))`, `(Fを通り線分CFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分FC))`, `(Fを通り直線FCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線CF))`, `(Fを通り線分CFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線FC))`, `(Fを通り直線FCに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線CF))`, `(Fを通りCFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線FC))`, `(Fを通りFCの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分DE))`, `(Fを通り線分DEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分ED))`, `(Fを通り直線EDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線DE))`, `(Fを通り線分DEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線ED))`, `(Fを通り直線EDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線DE))`, `(Fを通りDEの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線ED))`, `(Fを通りEDの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分DF))`, `(Fを通り線分DFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分FD))`, `(Fを通り直線FDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線DF))`, `(Fを通り線分DFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線FD))`, `(Fを通り直線FDに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線DF))`, `(Fを通りDFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線FD))`, `(Fを通りFDの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分EF))`, `(Fを通り線分EFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (線分FE))`, `(Fを通り直線FEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線EF))`, `(Fを通り線分EFに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (直線FE))`, `(Fを通り直線FEに平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線EF))`, `(Fを通りEFの垂直二等分線に平行な直線)`);
          descriptionStr = descriptionStr.replace(`Line(F, (垂直二等分線FE))`, `(Fを通りFEの垂直二等分線に平行な直線)`);
```

</details>

↑を用いて置き換えることで，`PerpendicularLine(A, Segment(A,B))`は`PerpendicularLine(A,線分AB)`に変わります．
これをさらに
```JavaScript
descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分AB)`, `(Aを通り線分ABに垂直な直線)`);
descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 線分BA)`, `(Aを通り直線BAに垂直な直線)`);
descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線AB)`, `(Aを通り線分ABに垂直な直線)`);
descriptionStr = descriptionStr.replace(`PerpendicularLine(A, 直線BA)`, `(Aを通り直線BAに垂直な直線)`);
```
を用意しておくことで，`PerpendicularLine(A, Segment(A,B))`を`Aを通り線分ABに垂直な直線`に置き換えることができます．
もう一段階入れ子が必要になったら，ようやく`parse(string, funcs)`を使うことになります．
さらにもう一段階入れ子が必要になった場合は...対応できません．

以上のような紆余曲折を経て，図形に定義を追従させることができるようになりました．
![スクリーンショット 2022-06-26 16.36.06.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/549093/d08f5da3-fa70-0f1a-abab-7284f0c9fa95.jpeg)

## 開発を終えて
GeoGebraAPIはリファレンスこそ充実しているもののなかなか利用されていません．使い方次第で面白いことができそうです．普段触らないJavaScriptを書いたので疲れました．ゴリ押しした部分は正規表現をきちんと学んでいつかリベンジしたいです．

## 参考文献
[辻宏子,動的幾何環境GeoGebraにおける作図活動に関する考察―「点の自由度」の概念に焦点をあてた分類枠組みの提案と検証](https://www.jstage.jst.go.jp/article/jssej/43/2/43_104/_article/-char/ja/)
[辻宏子,コンピュータ環境下の作図活動によるfigural conceptsの育成](https://www.jstage.jst.go.jp/article/jssej/27/2/27_KJ00003723696/_article/-char/ja/)
[辻宏子，動的幾何環境における生徒の活動の分析
](https://www.jstage.jst.go.jp/article/jssep/27/0/27_271/_article/-char/ja/)