LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYjLUkjbWlHRiQ2OVEhRicvJSdmYW1pbHlHUTBUaW1lc35OZXd+Um9tYW5GJy8lJXNpemVHUSMxMkYnLyUlYm9sZEdRJmZhbHNlRicvJSdpdGFsaWNHUSV0cnVlRicvJSp1bmRlcmxpbmVHRjcvJSpzdWJzY3JpcHRHRjcvJSxzdXBlcnNjcmlwdEdGNy8lK2ZvcmVncm91bmRHUShbMCwwLDBdRicvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYnLyUnb3BhcXVlR0Y3LyUrZXhlY3V0YWJsZUdGOi8lKXJlYWRvbmx5R0Y3LyUpY29tcG9zZWRHRjcvJSpjb252ZXJ0ZWRHRjcvJStpbXNlbGVjdGVkR0Y3LyUscGxhY2Vob2xkZXJHRjcvJTBmb250X3N0eWxlX25hbWVHUSkyRH5JbnB1dEYnLyUqbWF0aGNvbG9yR0ZDLyUvbWF0aGJhY2tncm91bmRHRkYvJStmb250ZmFtaWx5R0YxLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy8lKW1hdGhzaXplR0Y0

Demo Math 113 23 May 2007

Defining and plotting functions

Example f(x)=x^2 + 1

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNiUtSSNtaUdGJTY5USJmRigvJSdmYW1pbHlHUTBUaW1lc35OZXd+Um9tYW5GKC8lJXNpemVHUSMxMkYoLyUlYm9sZEdRJmZhbHNlRigvJSdpdGFsaWNHUSV0cnVlRigvJSp1bmRlcmxpbmVHRjgvJSpzdWJzY3JpcHRHRjgvJSxzdXBlcnNjcmlwdEdGOC8lK2ZvcmVncm91bmRHUSpbMCwwLDI1NV1GKC8lK2JhY2tncm91bmRHUS5bMjU1LDI1NSwyNTVdRigvJSdvcGFxdWVHRjgvJStleGVjdXRhYmxlR0Y4LyUpcmVhZG9ubHlHRjsvJSljb21wb3NlZEdGOC8lKmNvbnZlcnRlZEdGOC8lK2ltc2VsZWN0ZWRHRjgvJSxwbGFjZWhvbGRlckdGOC8lMGZvbnRfc3R5bGVfbmFtZUdRKjJEfk91dHB1dEYoLyUqbWF0aGNvbG9yR0ZELyUvbWF0aGJhY2tncm91bmRHRkcvJStmb250ZmFtaWx5R0YyLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGKC8lKW1hdGhzaXplR0Y1LUkjbW9HRiU2M1EjOj1GKC8lJWZvcm1HUSZpbmZpeEYoLyUmZmVuY2VHRjgvJSpzZXBhcmF0b3JHRjgvJSdsc3BhY2VHUS90aGlja21hdGhzcGFjZUYoLyUncnNwYWNlR0ZbcC8lKXN0cmV0Y2h5R0Y4LyUqc3ltbWV0cmljR0Y4LyUobWF4c2l6ZUdRKWluZmluaXR5RigvJShtaW5zaXplR1EiMUYoLyUobGFyZ2VvcEdGOC8lLm1vdmFibGVsaW1pdHNHRjgvJSdhY2NlbnRHRjgvJTBmb250X3N0eWxlX25hbWVHRlgvJSVzaXplR0Y1LyUrZm9yZWdyb3VuZEdGRC8lK2JhY2tncm91bmRHRkctRiQ2JS1GLTY5USJ4RihGMEYzRjZGOUY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ25GaW5GXG8tRl9vNjNRJyZyYXJyO0YoL0Zjb1EhRihGZW9GZ28vRmpvUSQwZW1GKC9GXXBGYXJGXnBGYHBGYnBGZXBGaHBGanBGXHFGXnFGYHFGYnFGZHEtRiQ2Iy1JJW1zdXBHRiU2JUZocS1JI21uR0YlNjlRIjJGKEYwRjNGNi9GOkY4RjxGPkZARkJGRUZIRkpGTEZORlBGUkZURlZGWUZlbkZnbi9Gam5RJ25vcm1hbEYoRlxvLyUxc3VwZXJzY3JpcHRzaGlmdEdRIjBGKDcjLV9GKUksbXByaW50c2xhc2hHRig2JDcjPkkiZkdGKGYqNiNJInhHRihGKDYkSSlvcGVyYXRvckdGKEkmYXJyb3dHRihGKCokKUZcdCIiIyIiIkYoRihGKDcjRmpz

LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYjLUkjbWlHRiQ2OVEhRicvJSdmYW1pbHlHUTBUaW1lc35OZXd+Um9tYW5GJy8lJXNpemVHUSMxMkYnLyUlYm9sZEdRJmZhbHNlRicvJSdpdGFsaWNHUSV0cnVlRicvJSp1bmRlcmxpbmVHRjcvJSpzdWJzY3JpcHRHRjcvJSxzdXBlcnNjcmlwdEdGNy8lK2ZvcmVncm91bmRHUShbMCwwLDBdRicvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYnLyUnb3BhcXVlR0Y3LyUrZXhlY3V0YWJsZUdGNy8lKXJlYWRvbmx5R0Y3LyUpY29tcG9zZWRHRjcvJSpjb252ZXJ0ZWRHRjcvJStpbXNlbGVjdGVkR0Y3LyUscGxhY2Vob2xkZXJHRjcvJTBmb250X3N0eWxlX25hbWVHUSgyRH5NYXRoRicvJSptYXRoY29sb3JHRkMvJS9tYXRoYmFja2dyb3VuZEdGRi8lK2ZvbnRmYW1pbHlHRjEvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLyUpbWF0aHNpemVHRjQ=

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5USI0RigvJSdmYW1pbHlHUTBUaW1lc35OZXd+Um9tYW5GKC8lJXNpemVHUSMxMkYoLyUlYm9sZEdRJmZhbHNlRigvJSdpdGFsaWNHRjUvJSp1bmRlcmxpbmVHRjUvJSpzdWJzY3JpcHRHRjUvJSxzdXBlcnNjcmlwdEdGNS8lK2ZvcmVncm91bmRHUSpbMCwwLDI1NV1GKC8lK2JhY2tncm91bmRHUS5bMjU1LDI1NSwyNTVdRigvJSdvcGFxdWVHRjUvJStleGVjdXRhYmxlR0Y1LyUpcmVhZG9ubHlHUSV0cnVlRigvJSljb21wb3NlZEdGNS8lKmNvbnZlcnRlZEdGNS8lK2ltc2VsZWN0ZWRHRjUvJSxwbGFjZWhvbGRlckdGNS8lMGZvbnRfc3R5bGVfbmFtZUdRKjJEfk91dHB1dEYoLyUqbWF0aGNvbG9yR0ZALyUvbWF0aGJhY2tncm91bmRHRkMvJStmb250ZmFtaWx5R0YvLyUsbWF0aHZhcmlhbnRHUSdub3JtYWxGKC8lKW1hdGhzaXplR0YyNyMiIiU=

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5USUwLjI1RigvJSdmYW1pbHlHUTBUaW1lc35OZXd+Um9tYW5GKC8lJXNpemVHUSMxMkYoLyUlYm9sZEdRJmZhbHNlRigvJSdpdGFsaWNHRjUvJSp1bmRlcmxpbmVHRjUvJSpzdWJzY3JpcHRHRjUvJSxzdXBlcnNjcmlwdEdGNS8lK2ZvcmVncm91bmRHUSpbMCwwLDI1NV1GKC8lK2JhY2tncm91bmRHUS5bMjU1LDI1NSwyNTVdRigvJSdvcGFxdWVHRjUvJStleGVjdXRhYmxlR0Y1LyUpcmVhZG9ubHlHUSV0cnVlRigvJSljb21wb3NlZEdGNS8lKmNvbnZlcnRlZEdGNS8lK2ltc2VsZWN0ZWRHRjUvJSxwbGFjZWhvbGRlckdGNS8lMGZvbnRfc3R5bGVfbmFtZUdRKjJEfk91dHB1dEYoLyUqbWF0aGNvbG9yR0ZALyUvbWF0aGJhY2tncm91bmRHRkMvJStmb250ZmFtaWx5R0YvLyUsbWF0aHZhcmlhbnRHUSdub3JtYWxGKC8lKW1hdGhzaXplR0YyNyMkIiNEISIj

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5US0wLjI1MDAwMDAwMDBGKC8lJ2ZhbWlseUdRMFRpbWVzfk5ld35Sb21hbkYoLyUlc2l6ZUdRIzEyRigvJSVib2xkR1EmZmFsc2VGKC8lJ2l0YWxpY0dGNS8lKnVuZGVybGluZUdGNS8lKnN1YnNjcmlwdEdGNS8lLHN1cGVyc2NyaXB0R0Y1LyUrZm9yZWdyb3VuZEdRKlswLDAsMjU1XUYoLyUrYmFja2dyb3VuZEdRLlsyNTUsMjU1LDI1NV1GKC8lJ29wYXF1ZUdGNS8lK2V4ZWN1dGFibGVHRjUvJSlyZWFkb25seUdRJXRydWVGKC8lKWNvbXBvc2VkR0Y1LyUqY29udmVydGVkR0Y1LyUraW1zZWxlY3RlZEdGNS8lLHBsYWNlaG9sZGVyR0Y1LyUwZm9udF9zdHlsZV9uYW1lR1EqMkR+T3V0cHV0RigvJSptYXRoY29sb3JHRkAvJS9tYXRoYmFja2dyb3VuZEdGQy8lK2ZvbnRmYW1pbHlHRi8vJSxtYXRodmFyaWFudEdRJ25vcm1hbEYoLyUpbWF0aHNpemVHRjI3IyQiKysrKytEISM1

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5USM0LkYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjJCIiJSIiIQ==

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

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNiUtSSNtaUdGJTY5USFGKC8lJ2ZhbWlseUdRMFRpbWVzfk5ld35Sb21hbkYoLyUlc2l6ZUdRIzEyRigvJSVib2xkR1EmZmFsc2VGKC8lJ2l0YWxpY0dRJXRydWVGKC8lKnVuZGVybGluZUdGOC8lKnN1YnNjcmlwdEdGOC8lLHN1cGVyc2NyaXB0R0Y4LyUrZm9yZWdyb3VuZEdRKFswLDAsMF1GKC8lK2JhY2tncm91bmRHUS5bMjU1LDI1NSwyNTVdRigvJSdvcGFxdWVHRjgvJStleGVjdXRhYmxlR0Y7LyUpcmVhZG9ubHlHRjgvJSljb21wb3NlZEdGOC8lKmNvbnZlcnRlZEdGOC8lK2ltc2VsZWN0ZWRHRjgvJSxwbGFjZWhvbGRlckdGOC8lMGZvbnRfc3R5bGVfbmFtZUdRKTJEfklucHV0RigvJSptYXRoY29sb3JHRkQvJS9tYXRoYmFja2dyb3VuZEdGRy8lK2ZvbnRmYW1pbHlHRjIvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YoLyUpbWF0aHNpemVHRjUtRiQ2JS1GLTY5USVwbG90RihGMEYzRjZGOUY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ25GaW5GXG8tSSNtb0dGJTYzUTAmQXBwbHlGdW5jdGlvbjtGKC8lJWZvcm1HUSZpbmZpeEYoLyUmZmVuY2VHRjgvJSpzZXBhcmF0b3JHRjgvJSdsc3BhY2VHUSQwZW1GKC8lJ3JzcGFjZUdGYHAvJSlzdHJldGNoeUdGOC8lKnN5bW1ldHJpY0dGOC8lKG1heHNpemVHUSlpbmZpbml0eUYoLyUobWluc2l6ZUdRIjFGKC8lKGxhcmdlb3BHRjgvJS5tb3ZhYmxlbGltaXRzR0Y4LyUnYWNjZW50R0Y4LyUwZm9udF9zdHlsZV9uYW1lR0ZYLyUlc2l6ZUdGNS8lK2ZvcmVncm91bmRHRkQvJStiYWNrZ3JvdW5kR0ZHLUkobWZlbmNlZEdGJTYjLUYkNipGLC1GJDYlLUYtNjlRImZGKEYwRjNGNkY5RjxGPkZARkJGRUZIRkpGTEZORlBGUkZURlZGWUZlbkZnbkZpbkZcb0Zjby1GXHI2Iy1GJDYjLUYtNjlRInhGKEYwRjNGNkY5RjxGPkZARkJGRUZIRkpGTEZORlBGUkZURlZGWUZlbkZnbkZpbkZcby1GZG82M1EiLEYoRmdvRmpvL0ZdcEY7Rl5wL0ZicFEzdmVyeXRoaWNrbWF0aHNwYWNlRihGY3BGZXBGZ3BGanBGXXFGX3FGYXFGY3FGZXFGZ3FGaXFGaXItRmRvNjNRIj1GKEZnb0Zqb0ZccC9GX3BRL3RoaWNrbWF0aHNwYWNlRigvRmJwRmZzRmNwRmVwRmdwRmpwRl1xRl9xRmFxRmNxRmVxRmdxRmlxLUkjbW5HRiU2OVEiMEYoRjBGM0Y2L0Y6RjhGPEY+RkBGQkZFRkhGSkZMRk5GUEZSRlRGVkZZRmVuRmduL0ZqblEnbm9ybWFsRihGXG8tRmRvNjNRIy4uRigvRmhvUShwb3N0Zml4RihGam9GXHAvRl9wUTBtZWRpdW1tYXRoc3BhY2VGKEZhcEZjcEZlcEZncEZqcEZdcUZfcUZhcUZjcUZlcUZncUZpcS1GaXM2OVEiNUYoRjBGM0Y2Rlx0RjxGPkZARkJGRUZIRkpGTEZORlBGUkZURlZGWUZlbkZnbkZddEZcb0YsNyMtSSVwbG90RzYkJSpwcm90ZWN0ZWRHRio2JC1JImZHRig2I0kieEdGKC9GYnU7IiIhIiIm

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

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNistSSNtaUdGJTY5USJnRigvJSdmYW1pbHlHUTBUaW1lc35OZXd+Um9tYW5GKC8lJXNpemVHUSMxMkYoLyUlYm9sZEdRJmZhbHNlRigvJSdpdGFsaWNHUSV0cnVlRigvJSp1bmRlcmxpbmVHRjgvJSpzdWJzY3JpcHRHRjgvJSxzdXBlcnNjcmlwdEdGOC8lK2ZvcmVncm91bmRHUShbMCwwLDBdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y4LyUrZXhlY3V0YWJsZUdGOy8lKXJlYWRvbmx5R0Y4LyUpY29tcG9zZWRHRjgvJSpjb252ZXJ0ZWRHRjgvJStpbXNlbGVjdGVkR0Y4LyUscGxhY2Vob2xkZXJHRjgvJTBmb250X3N0eWxlX25hbWVHUSkyRH5JbnB1dEYoLyUqbWF0aGNvbG9yR0ZELyUvbWF0aGJhY2tncm91bmRHRkcvJStmb250ZmFtaWx5R0YyLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGKC8lKW1hdGhzaXplR0Y1LUkjbW9HRiU2M1EjOj1GKC8lJWZvcm1HUSZpbmZpeEYoLyUmZmVuY2VHRjgvJSpzZXBhcmF0b3JHRjgvJSdsc3BhY2VHUS90aGlja21hdGhzcGFjZUYoLyUncnNwYWNlR0ZbcC8lKXN0cmV0Y2h5R0Y4LyUqc3ltbWV0cmljR0Y4LyUobWF4c2l6ZUdRKWluZmluaXR5RigvJShtaW5zaXplR1EiMUYoLyUobGFyZ2VvcEdGOC8lLm1vdmFibGVsaW1pdHNHRjgvJSdhY2NlbnRHRjgvJTBmb250X3N0eWxlX25hbWVHRlgvJSVzaXplR0Y1LyUrZm9yZWdyb3VuZEdGRC8lK2JhY2tncm91bmRHRkctRi02OVEieEYoRjBGM0Y2RjlGPEY+RkBGQkZFRkhGSkZMRk5GUEZSRlRGVkZZRmVuRmduRmluRlxvLUZfbzYzUS0mUmlnaHRBcnJvdztGKEZib0Zlb0Znby9Gam9RMG1lZGl1bW1hdGhzcGFjZUYoL0ZdcEZdckZecEZgcEZicEZlcEZocEZqcEZccUZecUZgcUZicUZkcS1JJW1zdXBHRiU2JUZmcS1GJDYjLUkjbW5HRiU2OVEiM0YoRjBGM0Y2L0Y6RjhGPEY+RkBGQkZFRkhGSkZMRk5GUEZSRlRGVkZZRmVuRmduL0ZqblEnbm9ybWFsRihGXG8vJTFzdXBlcnNjcmlwdHNoaWZ0R1EiMEYoLUZfbzYzUSgmbWludXM7RihGYm9GZW8vRmhvRjsvRmpvUSQwZW1GKC9GXXBRM3Zlcnl0aGlja21hdGhzcGFjZUYoRl5wRmBwRmJwRmVwRmhwRmpwRlxxRl5xRmBxRmJxRmRxLUZlcjY5USI4RihGMEYzRjZGaHJGPEY+RkBGQkZFRkhGSkZMRk5GUEZSRlRGVkZZRmVuRmduRmlyRlxvLUZfbzYzUScmc2RvdDtGKEZib0Zlb0Zhc0Zic0Zkc0ZecEZgcEZicEZlcEZocEZqcEZccUZecUZgcUZicUZkcUZmcTcjPkkiZ0dGKGYqNiNJInhHRihGKDYkSSlvcGVyYXRvckdGKEkmYXJyb3dHRihGKCwmKiQpRmF0IiIkIiIiRml0KiYiIilGaXRGYXRGaXQhIiJGKEYoRig=

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNiUtSSNtaUdGJTY5USJnRigvJSdmYW1pbHlHUTBUaW1lc35OZXd+Um9tYW5GKC8lJXNpemVHUSMxMkYoLyUlYm9sZEdRJmZhbHNlRigvJSdpdGFsaWNHUSV0cnVlRigvJSp1bmRlcmxpbmVHRjgvJSpzdWJzY3JpcHRHRjgvJSxzdXBlcnNjcmlwdEdGOC8lK2ZvcmVncm91bmRHUSpbMCwwLDI1NV1GKC8lK2JhY2tncm91bmRHUS5bMjU1LDI1NSwyNTVdRigvJSdvcGFxdWVHRjgvJStleGVjdXRhYmxlR0Y4LyUpcmVhZG9ubHlHRjsvJSljb21wb3NlZEdGOC8lKmNvbnZlcnRlZEdGOC8lK2ltc2VsZWN0ZWRHRjgvJSxwbGFjZWhvbGRlckdGOC8lMGZvbnRfc3R5bGVfbmFtZUdRKjJEfk91dHB1dEYoLyUqbWF0aGNvbG9yR0ZELyUvbWF0aGJhY2tncm91bmRHRkcvJStmb250ZmFtaWx5R0YyLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGKC8lKW1hdGhzaXplR0Y1LUkjbW9HRiU2M1EjOj1GKC8lJWZvcm1HUSZpbmZpeEYoLyUmZmVuY2VHRjgvJSpzZXBhcmF0b3JHRjgvJSdsc3BhY2VHUS90aGlja21hdGhzcGFjZUYoLyUncnNwYWNlR0ZbcC8lKXN0cmV0Y2h5R0Y4LyUqc3ltbWV0cmljR0Y4LyUobWF4c2l6ZUdRKWluZmluaXR5RigvJShtaW5zaXplR1EiMUYoLyUobGFyZ2VvcEdGOC8lLm1vdmFibGVsaW1pdHNHRjgvJSdhY2NlbnRHRjgvJTBmb250X3N0eWxlX25hbWVHRlgvJSVzaXplR0Y1LyUrZm9yZWdyb3VuZEdGRC8lK2JhY2tncm91bmRHRkctRiQ2JS1GLTY5USJ4RihGMEYzRjZGOUY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ25GaW5GXG8tRl9vNjNRJyZyYXJyO0YoL0Zjb1EhRihGZW9GZ28vRmpvUSQwZW1GKC9GXXBGYXJGXnBGYHBGYnBGZXBGaHBGanBGXHFGXnFGYHFGYnFGZHEtRiQ2JS1GJDYjLUklbXN1cEdGJTYlRmhxLUkjbW5HRiU2OVEiM0YoRjBGM0Y2L0Y6RjhGPEY+RkBGQkZFRkhGSkZMRk5GUEZSRlRGVkZZRmVuRmduL0ZqblEnbm9ybWFsRihGXG8vJTFzdXBlcnNjcmlwdHNoaWZ0R1EiMEYoLUZfbzYzUSgmbWludXM7RihGYm9GZW9GZ28vRmpvUTBtZWRpdW1tYXRoc3BhY2VGKC9GXXBGaHNGXnBGYHBGYnBGZXBGaHBGanBGXHFGXnFGYHFGYnFGZHEtRiQ2JS1GW3M2OVEiOEYoRjBGM0Y2Rl5zRjxGPkZARkJGRUZIRkpGTEZORlBGUkZURlZGWUZlbkZnbkZfc0Zcby1GX282M1ExJkludmlzaWJsZVRpbWVzO0YoRmJvRmVvRmdvRmByRmJyRl5wRmBwRmJwRmVwRmhwRmpwRlxxRl5xRmBxRmJxRmRxRmhxNyMtX0YpSSxtcHJpbnRzbGFzaEdGKDYkNyM+SSJnR0YoZio2I0kieEdGKEYoNiRJKW9wZXJhdG9yR0YoSSZhcnJvd0dGKEYoLCYqJClGXHUiIiQiIiJGZHUqJiIiKUZkdUZcdUZkdSEiIkYoRihGKDcjRmp0

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

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNiUtSSNtaUdGJTY5USFGKC8lJ2ZhbWlseUdRMFRpbWVzfk5ld35Sb21hbkYoLyUlc2l6ZUdRIzEyRigvJSVib2xkR1EmZmFsc2VGKC8lJ2l0YWxpY0dRJXRydWVGKC8lKnVuZGVybGluZUdGOC8lKnN1YnNjcmlwdEdGOC8lLHN1cGVyc2NyaXB0R0Y4LyUrZm9yZWdyb3VuZEdRKFswLDAsMF1GKC8lK2JhY2tncm91bmRHUS5bMjU1LDI1NSwyNTVdRigvJSdvcGFxdWVHRjgvJStleGVjdXRhYmxlR0Y7LyUpcmVhZG9ubHlHRjgvJSljb21wb3NlZEdGOC8lKmNvbnZlcnRlZEdGOC8lK2ltc2VsZWN0ZWRHRjgvJSxwbGFjZWhvbGRlckdGOC8lMGZvbnRfc3R5bGVfbmFtZUdRKTJEfklucHV0RigvJSptYXRoY29sb3JHRkQvJS9tYXRoYmFja2dyb3VuZEdGRy8lK2ZvbnRmYW1pbHlHRjIvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YoLyUpbWF0aHNpemVHRjUtRiQ2JS1GLTY5USVwbG90RihGMEYzRjZGOUY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ25GaW5GXG8tSSNtb0dGJTYzUTAmQXBwbHlGdW5jdGlvbjtGKC8lJWZvcm1HUSZpbmZpeEYoLyUmZmVuY2VHRjgvJSpzZXBhcmF0b3JHRjgvJSdsc3BhY2VHUSQwZW1GKC8lJ3JzcGFjZUdGYHAvJSlzdHJldGNoeUdGOC8lKnN5bW1ldHJpY0dGOC8lKG1heHNpemVHUSlpbmZpbml0eUYoLyUobWluc2l6ZUdRIjFGKC8lKGxhcmdlb3BHRjgvJS5tb3ZhYmxlbGltaXRzR0Y4LyUnYWNjZW50R0Y4LyUwZm9udF9zdHlsZV9uYW1lR0ZYLyUlc2l6ZUdGNS8lK2ZvcmVncm91bmRHRkQvJStiYWNrZ3JvdW5kR0ZHLUkobWZlbmNlZEdGJTYjLUYkNipGLC1GJDYlLUYtNjlRImdGKEYwRjNGNkY5RjxGPkZARkJGRUZIRkpGTEZORlBGUkZURlZGWUZlbkZnbkZpbkZcb0Zjby1GXHI2Iy1GJDYjLUYtNjlRInhGKEYwRjNGNkY5RjxGPkZARkJGRUZIRkpGTEZORlBGUkZURlZGWUZlbkZnbkZpbkZcby1GZG82M1EiLEYoRmdvRmpvL0ZdcEY7Rl5wL0ZicFEzdmVyeXRoaWNrbWF0aHNwYWNlRihGY3BGZXBGZ3BGanBGXXFGX3FGYXFGY3FGZXFGZ3FGaXFGaXItRmRvNjNRIj1GKEZnb0Zqb0ZccC9GX3BRL3RoaWNrbWF0aHNwYWNlRigvRmJwRmZzRmNwRmVwRmdwRmpwRl1xRl9xRmFxRmNxRmVxRmdxRmlxLUkjbW5HRiU2OVErJnVtaW51czA7NEYoRjBGM0Y2L0Y6RjhGPEY+RkBGQkZFRkhGSkZMRk5GUEZSRlRGVkZZRmVuRmduL0ZqblEnbm9ybWFsRihGXG8tRmRvNjNRIy4uRigvRmhvUShwb3N0Zml4RihGam9GXHAvRl9wUTBtZWRpdW1tYXRoc3BhY2VGKEZhcEZjcEZlcEZncEZqcEZdcUZfcUZhcUZjcUZlcUZncUZpcS1GaXM2OVEiNEYoRjBGM0Y2Rlx0RjxGPkZARkJGRUZIRkpGTEZORlBGUkZURlZGWUZlbkZnbkZddEZcb0YsNyMtSSVwbG90RzYkJSpwcm90ZWN0ZWRHRio2JC1JImdHRig2I0kieEdGKC9GYnU7ISIlIiIl

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

Doing limits in MAPLE

Example #34, p. 83

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

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNiUtSSNtaUdGJTY5USZGbG9hdEYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR1EldHJ1ZUYoLyUqdW5kZXJsaW5lR0Y4LyUqc3Vic2NyaXB0R0Y4LyUsc3VwZXJzY3JpcHRHRjgvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y4LyUrZXhlY3V0YWJsZUdGOC8lKXJlYWRvbmx5R0Y7LyUpY29tcG9zZWRHRjgvJSpjb252ZXJ0ZWRHRjgvJStpbXNlbGVjdGVkR0Y4LyUscGxhY2Vob2xkZXJHRjgvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGRC8lL21hdGhiYWNrZ3JvdW5kR0ZHLyUrZm9udGZhbWlseUdGMi8lLG1hdGh2YXJpYW50R1EnaXRhbGljRigvJSltYXRoc2l6ZUdGNS1JI21vR0YlNjNRMCZBcHBseUZ1bmN0aW9uO0YoLyUlZm9ybUdRJmluZml4RigvJSZmZW5jZUdGOC8lKnNlcGFyYXRvckdGOC8lJ2xzcGFjZUdRJDBlbUYoLyUncnNwYWNlR0ZbcC8lKXN0cmV0Y2h5R0Y4LyUqc3ltbWV0cmljR0Y4LyUobWF4c2l6ZUdRKWluZmluaXR5RigvJShtaW5zaXplR1EiMUYoLyUobGFyZ2VvcEdGOC8lLm1vdmFibGVsaW1pdHNHRjgvJSdhY2NlbnRHRjgvJTBmb250X3N0eWxlX25hbWVHRlgvJSVzaXplR0Y1LyUrZm9yZWdyb3VuZEdGRC8lK2JhY2tncm91bmRHRkctRiQ2JS1GX282M1EiKEYoL0Zjb1EncHJlZml4RigvRmZvRjtGZ28vRmpvUS50aGlubWF0aHNwYWNlRigvRl1wRl9yL0ZfcEY7RmBwRmJwRmVwRmhwRmpwRlxxRl5xRmBxRmJxRmRxLUYkNiMtRi02OUZkcEYwRjNGNkY5RjxGPkZARkJGRUZIRkpGTEZORlBGUkZURlZGWUZlbkZnbkZpbkZcby1GX282M1EiKUYoL0Zjb1EocG9zdGZpeEYoRl1yRmdvRl5yL0ZdcFEydmVyeXRoaW5tYXRoc3BhY2VGKEZhckZgcEZicEZlcEZocEZqcEZccUZecUZgcUZicUZkcTcjJCIiIkkpaW5maW5pdHlHJSpwcm90ZWN0ZWRH

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5USw0LjUyMzcwMjUxM0YoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjJCIrOERxQlghIio=

NiQtSSZtZnJhY0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDYqLUklbXJvd0dGJTYjLUkjbW5HRiU2OVEiOEYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y7LyUqdW5kZXJsaW5lR0Y7LyUqc3Vic2NyaXB0R0Y7LyUsc3VwZXJzY3JpcHRHRjsvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y7LyUrZXhlY3V0YWJsZUdGOy8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjsvJSpjb252ZXJ0ZWRHRjsvJStpbXNlbGVjdGVkR0Y7LyUscGxhY2Vob2xkZXJHRjsvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGRi8lL21hdGhiYWNrZ3JvdW5kR0ZJLyUrZm9udGZhbWlseUdGNS8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGOC1GLTYjLUYtNiUtRi02Iy1JJm1zcXJ0R0YlNiUtRjA2OVEjNDFGKEYzRjZGOUY8Rj5GQEZCRkRGR0ZKRkxGTkZRRlNGVUZXRllGZm5GaG5Gam5GXG9GX28vJStmb3JlZ3JvdW5kR0ZGLyUrYmFja2dyb3VuZEdGSS1JI21vR0YlNjNRKCZtaW51cztGKC8lJWZvcm1HUSZpbmZpeEYoLyUmZmVuY2VHRjsvJSpzZXBhcmF0b3JHRjsvJSdsc3BhY2VHUTBtZWRpdW1tYXRoc3BhY2VGKC8lJ3JzcGFjZUdGXnEvJSlzdHJldGNoeUdGOy8lKnN5bW1ldHJpY0dGOy8lKG1heHNpemVHUSlpbmZpbml0eUYoLyUobWluc2l6ZUdRIjFGKC8lKGxhcmdlb3BHRjsvJS5tb3ZhYmxlbGltaXRzR0Y7LyUnYWNjZW50R0Y7LyUwZm9udF9zdHlsZV9uYW1lR0Zlbi8lJXNpemVHRjhGXXBGX3AtRjA2OVEiM0YoRjNGNkY5RjxGPkZARkJGREZHRkpGTEZORlFGU0ZVRldGWUZmbkZobkZqbkZcb0Zfby8lLmxpbmV0aGlja25lc3NHUSIxRigvJStkZW5vbWFsaWduR1EnY2VudGVyRigvJSludW1hbGlnbkdGXXMvJSliZXZlbGxlZEdGO0ZdcEZfcDcjLCQqJiIiKSIiIiwmKiQpIiNUI0ZmcyIiI0Zmc0ZmcyIiJCEiIkZedEZmcw==

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNiUtSSNtaUdGJTY5USZGbG9hdEYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR1EldHJ1ZUYoLyUqdW5kZXJsaW5lR0Y4LyUqc3Vic2NyaXB0R0Y4LyUsc3VwZXJzY3JpcHRHRjgvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y4LyUrZXhlY3V0YWJsZUdGOC8lKXJlYWRvbmx5R0Y7LyUpY29tcG9zZWRHRjgvJSpjb252ZXJ0ZWRHRjgvJStpbXNlbGVjdGVkR0Y4LyUscGxhY2Vob2xkZXJHRjgvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGRC8lL21hdGhiYWNrZ3JvdW5kR0ZHLyUrZm9udGZhbWlseUdGMi8lLG1hdGh2YXJpYW50R1EnaXRhbGljRigvJSltYXRoc2l6ZUdGNS1JI21vR0YlNjNRMCZBcHBseUZ1bmN0aW9uO0YoLyUlZm9ybUdRJmluZml4RigvJSZmZW5jZUdGOC8lKnNlcGFyYXRvckdGOC8lJ2xzcGFjZUdRJDBlbUYoLyUncnNwYWNlR0ZbcC8lKXN0cmV0Y2h5R0Y4LyUqc3ltbWV0cmljR0Y4LyUobWF4c2l6ZUdRKWluZmluaXR5RigvJShtaW5zaXplR1EiMUYoLyUobGFyZ2VvcEdGOC8lLm1vdmFibGVsaW1pdHNHRjgvJSdhY2NlbnRHRjgvJTBmb250X3N0eWxlX25hbWVHRlgvJSVzaXplR0Y1LyUrZm9yZWdyb3VuZEdGRC8lK2JhY2tncm91bmRHRkctRiQ2JS1GX282M1EiKEYoL0Zjb1EncHJlZml4RigvRmZvRjtGZ28vRmpvUS50aGlubWF0aHNwYWNlRigvRl1wRl9yL0ZfcEY7RmBwRmJwRmVwRmhwRmpwRlxxRl5xRmBxRmJxRmRxLUYkNiMtRi02OVEqdW5kZWZpbmVkRihGMEYzRjZGOUY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ25GaW5GXG8tRl9vNjNRIilGKC9GY29RKHBvc3RmaXhGKEZdckZnb0Zeci9GXXBRMnZlcnl0aGlubWF0aHNwYWNlRihGYXJGYHBGYnBGZXBGaHBGanBGXHFGXnFGYHFGYnFGZHE3IyQiIiJJKnVuZGVmaW5lZEclKnByb3RlY3RlZEc=

Want to find limit of f(x) as x-> -2

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5UTUmdW1pbnVzMDsxLjgxNjQ5NjU4MkYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjJCErI2UnXDs9ISIq

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5UTUmdW1pbnVzMDsxLjYyNjQ1MjExOEYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjJCErPUBYRTshIio=

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5UTUmdW1pbnVzMDsxLjUyMTYxMDI5MEYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjJCErIUg1O18iISIq

NiQtSSZtZnJhY0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDYqLUkjbW5HRiU2OVEiMUYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y4LyUqdW5kZXJsaW5lR0Y4LyUqc3Vic2NyaXB0R0Y4LyUsc3VwZXJzY3JpcHRHRjgvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y4LyUrZXhlY3V0YWJsZUdGOC8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjgvJSpjb252ZXJ0ZWRHRjgvJStpbXNlbGVjdGVkR0Y4LyUscGxhY2Vob2xkZXJHRjgvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQy8lL21hdGhiYWNrZ3JvdW5kR0ZGLyUrZm9udGZhbWlseUdGMi8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGNS1JJW1yb3dHRiU2Iy1GX282JS1GX282Iy1JJm1zcXJ0R0YlNiUtRi02OVEiNkYoRjBGM0Y2RjlGO0Y9Rj9GQUZERkdGSUZLRk5GUEZSRlRGVkZZRmVuRmduRmluRlxvLyUrZm9yZWdyb3VuZEdGQy8lK2JhY2tncm91bmRHRkYtSSNtb0dGJTYzUSgmbWludXM7RigvJSVmb3JtR1EmaW5maXhGKC8lJmZlbmNlR0Y4LyUqc2VwYXJhdG9yR0Y4LyUnbHNwYWNlR1EwbWVkaXVtbWF0aHNwYWNlRigvJSdyc3BhY2VHRlxxLyUpc3RyZXRjaHlHRjgvJSpzeW1tZXRyaWNHRjgvJShtYXhzaXplR1EpaW5maW5pdHlGKC8lKG1pbnNpemVHRi8vJShsYXJnZW9wR0Y4LyUubW92YWJsZWxpbWl0c0dGOC8lJ2FjY2VudEdGOC8lMGZvbnRfc3R5bGVfbmFtZUdGWC8lJXNpemVHRjVGW3BGXXAtRi02OVEiM0YoRjBGM0Y2RjlGO0Y9Rj9GQUZERkdGSUZLRk5GUEZSRlRGVkZZRmVuRmduRmluRlxvLyUubGluZXRoaWNrbmVzc0dRIjFGKC8lK2Rlbm9tYWxpZ25HUSdjZW50ZXJGKC8lKW51bWFsaWduR0Zqci8lKWJldmVsbGVkR0Y4RltwRl1wNyMqJCwmKiQpIiInIyIiIiIiI0Zmc0ZmcyIiJCEiIkZpcw==

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5UTUmdW1pbnVzMDsxLjUxMDYwNzc5MEYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjJCErIXoyMV4iISIq

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5UTUmdW1pbnVzMDsxLjUwMjA5MDgzNUYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjJCErTjM0LTohIio=

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5UTUmdW1pbnVzMDsxLjUwMTA0MzUyNUYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjJCErRE4vLDohIio=

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5UTUmdW1pbnVzMDsxLjM0ODMzMTQ3N0YoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjJCEreDlMWzghIio=

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5UTUmdW1pbnVzMDsxLjQxMjAyMjY2MEYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjJCErZ0UtNzkhIio=

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5UTUmdW1pbnVzMDsxLjQ3OTg5NTY5MUYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjJCErInAmKil6OSEiKg==

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5UTUmdW1pbnVzMDsxLjQ4OTc2ODQ3OUYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjJCEreiVvKCpbIiEiKg==

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5UTUmdW1pbnVzMDsxLjQ5NzkyNDI1MUYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjJCErXlUjelwiISIq

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5UTUmdW1pbnVzMDsxLjQ5ODk2MDAyMkYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjJCErQSsnKilcIiEiKg==

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNiUtSSNtaUdGJTY5USFGKC8lJ2ZhbWlseUdRMFRpbWVzfk5ld35Sb21hbkYoLyUlc2l6ZUdRIzEyRigvJSVib2xkR1EmZmFsc2VGKC8lJ2l0YWxpY0dRJXRydWVGKC8lKnVuZGVybGluZUdGOC8lKnN1YnNjcmlwdEdGOC8lLHN1cGVyc2NyaXB0R0Y4LyUrZm9yZWdyb3VuZEdRKFswLDAsMF1GKC8lK2JhY2tncm91bmRHUS5bMjU1LDI1NSwyNTVdRigvJSdvcGFxdWVHRjgvJStleGVjdXRhYmxlR0Y7LyUpcmVhZG9ubHlHRjgvJSljb21wb3NlZEdGOC8lKmNvbnZlcnRlZEdGOC8lK2ltc2VsZWN0ZWRHRjgvJSxwbGFjZWhvbGRlckdGOC8lMGZvbnRfc3R5bGVfbmFtZUdRKTJEfklucHV0RigvJSptYXRoY29sb3JHRkQvJS9tYXRoYmFja2dyb3VuZEdGRy8lK2ZvbnRmYW1pbHlHRjIvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YoLyUpbWF0aHNpemVHRjUtRiQ2JS1GLTY5USVwbG90RihGMEYzRjZGOUY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ25GaW5GXG8tSSNtb0dGJTYzUTAmQXBwbHlGdW5jdGlvbjtGKC8lJWZvcm1HUSZpbmZpeEYoLyUmZmVuY2VHRjgvJSpzZXBhcmF0b3JHRjgvJSdsc3BhY2VHUSQwZW1GKC8lJ3JzcGFjZUdGYHAvJSlzdHJldGNoeUdGOC8lKnN5bW1ldHJpY0dGOC8lKG1heHNpemVHUSlpbmZpbml0eUYoLyUobWluc2l6ZUdRIjFGKC8lKGxhcmdlb3BHRjgvJS5tb3ZhYmxlbGltaXRzR0Y4LyUnYWNjZW50R0Y4LyUwZm9udF9zdHlsZV9uYW1lR0ZYLyUlc2l6ZUdGNS8lK2ZvcmVncm91bmRHRkQvJStiYWNrZ3JvdW5kR0ZHLUkobWZlbmNlZEdGJTYjLUYkNipGLC1GJDYlLUYtNjlRImZGKEYwRjNGNkY5RjxGPkZARkJGRUZIRkpGTEZORlBGUkZURlZGWUZlbkZnbkZpbkZcb0Zjby1GXHI2Iy1GJDYjLUYtNjlRInhGKEYwRjNGNkY5RjxGPkZARkJGRUZIRkpGTEZORlBGUkZURlZGWUZlbkZnbkZpbkZcby1GZG82M1EiLEYoRmdvRmpvL0ZdcEY7Rl5wL0ZicFEzdmVyeXRoaWNrbWF0aHNwYWNlRihGY3BGZXBGZ3BGanBGXXFGX3FGYXFGY3FGZXFGZ3FGaXFGaXItRmRvNjNRIj1GKEZnb0Zqb0ZccC9GX3BRL3RoaWNrbWF0aHNwYWNlRigvRmJwRmZzRmNwRmVwRmdwRmpwRl1xRl9xRmFxRmNxRmVxRmdxRmlxLUkjbW5HRiU2OVEtJnVtaW51czA7Mi41RihGMEYzRjYvRjpGOEY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ24vRmpuUSdub3JtYWxGKEZcby1GZG82M1EjLi5GKC9GaG9RKHBvc3RmaXhGKEZqb0ZccC9GX3BRMG1lZGl1bW1hdGhzcGFjZUYoRmFwRmNwRmVwRmdwRmpwRl1xRl9xRmFxRmNxRmVxRmdxRmlxLUZpczY5US0mdW1pbnVzMDsxLjVGKEYwRjNGNkZcdEY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ25GXXRGXG9GLDcjLUklcGxvdEc2JCUqcHJvdGVjdGVkR0YqNiQtSSJmR0YoNiNJInhHRigvRmJ1OyQhI0QhIiIkISM6Rmd1

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

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNiUtSSNtaUdGJTY5USFGKC8lJ2ZhbWlseUdRMFRpbWVzfk5ld35Sb21hbkYoLyUlc2l6ZUdRIzEyRigvJSVib2xkR1EmZmFsc2VGKC8lJ2l0YWxpY0dRJXRydWVGKC8lKnVuZGVybGluZUdGOC8lKnN1YnNjcmlwdEdGOC8lLHN1cGVyc2NyaXB0R0Y4LyUrZm9yZWdyb3VuZEdRKFswLDAsMF1GKC8lK2JhY2tncm91bmRHUS5bMjU1LDI1NSwyNTVdRigvJSdvcGFxdWVHRjgvJStleGVjdXRhYmxlR0Y7LyUpcmVhZG9ubHlHRjgvJSljb21wb3NlZEdGOC8lKmNvbnZlcnRlZEdGOC8lK2ltc2VsZWN0ZWRHRjgvJSxwbGFjZWhvbGRlckdGOC8lMGZvbnRfc3R5bGVfbmFtZUdRKTJEfklucHV0RigvJSptYXRoY29sb3JHRkQvJS9tYXRoYmFja2dyb3VuZEdGRy8lK2ZvbnRmYW1pbHlHRjIvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YoLyUpbWF0aHNpemVHRjUtRiQ2JS1GLTY5USZsaW1pdEYoRjBGM0Y2RjlGPEY+RkBGQkZFRkhGSkZMRk5GUEZSRlRGVkZZRmVuRmduRmluRlxvLUkjbW9HRiU2M1EwJkFwcGx5RnVuY3Rpb247RigvJSVmb3JtR1EmaW5maXhGKC8lJmZlbmNlR0Y4LyUqc2VwYXJhdG9yR0Y4LyUnbHNwYWNlR1EkMGVtRigvJSdyc3BhY2VHRmBwLyUpc3RyZXRjaHlHRjgvJSpzeW1tZXRyaWNHRjgvJShtYXhzaXplR1EpaW5maW5pdHlGKC8lKG1pbnNpemVHUSIxRigvJShsYXJnZW9wR0Y4LyUubW92YWJsZWxpbWl0c0dGOC8lJ2FjY2VudEdGOC8lMGZvbnRfc3R5bGVfbmFtZUdGWC8lJXNpemVHRjUvJStmb3JlZ3JvdW5kR0ZELyUrYmFja2dyb3VuZEdGRy1JKG1mZW5jZWRHRiU2Iy1GJDYoRiwtRiQ2JS1GLTY5USJmRihGMEYzRjZGOUY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ25GaW5GXG9GY28tRlxyNiMtRiQ2Iy1GLTY5USJ4RihGMEYzRjZGOUY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ25GaW5GXG8tRmRvNjNRIixGKEZnb0Zqby9GXXBGO0ZecC9GYnBRM3Zlcnl0aGlja21hdGhzcGFjZUYoRmNwRmVwRmdwRmpwRl1xRl9xRmFxRmNxRmVxRmdxRmlxRmlyLUZkbzYzUSI9RihGZ29Gam9GXHAvRl9wUS90aGlja21hdGhzcGFjZUYoL0ZicEZmc0ZjcEZlcEZncEZqcEZdcUZfcUZhcUZjcUZlcUZncUZpcS1JI21uR0YlNjlRLCZ1bWludXMwOzIuRihGMEYzRjYvRjpGOEY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ24vRmpuUSdub3JtYWxGKEZcb0YsNyMtSSZsaW1pdEdGKDYkLUkiZkdGKDYjSSJ4R0YoL0ZmdCQhIiMiIiE=

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5UTUmdW1pbnVzMDsxLjUwMDAwMDAwMEYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjJCErKysrKzohIio=

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNiUtSSNtaUdGJTY5USFGKC8lJ2ZhbWlseUdRMFRpbWVzfk5ld35Sb21hbkYoLyUlc2l6ZUdRIzEyRigvJSVib2xkR1EmZmFsc2VGKC8lJ2l0YWxpY0dRJXRydWVGKC8lKnVuZGVybGluZUdGOC8lKnN1YnNjcmlwdEdGOC8lLHN1cGVyc2NyaXB0R0Y4LyUrZm9yZWdyb3VuZEdRKFswLDAsMF1GKC8lK2JhY2tncm91bmRHUS5bMjU1LDI1NSwyNTVdRigvJSdvcGFxdWVHRjgvJStleGVjdXRhYmxlR0Y7LyUpcmVhZG9ubHlHRjgvJSljb21wb3NlZEdGOC8lKmNvbnZlcnRlZEdGOC8lK2ltc2VsZWN0ZWRHRjgvJSxwbGFjZWhvbGRlckdGOC8lMGZvbnRfc3R5bGVfbmFtZUdRKTJEfklucHV0RigvJSptYXRoY29sb3JHRkQvJS9tYXRoYmFja2dyb3VuZEdGRy8lK2ZvbnRmYW1pbHlHRjIvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YoLyUpbWF0aHNpemVHRjUtRiQ2JS1GLTY5USZsaW1pdEYoRjBGM0Y2RjlGPEY+RkBGQkZFRkhGSkZMRk5GUEZSRlRGVkZZRmVuRmduRmluRlxvLUkjbW9HRiU2M1EwJkFwcGx5RnVuY3Rpb247RigvJSVmb3JtR1EmaW5maXhGKC8lJmZlbmNlR0Y4LyUqc2VwYXJhdG9yR0Y4LyUnbHNwYWNlR1EkMGVtRigvJSdyc3BhY2VHRmBwLyUpc3RyZXRjaHlHRjgvJSpzeW1tZXRyaWNHRjgvJShtYXhzaXplR1EpaW5maW5pdHlGKC8lKG1pbnNpemVHUSIxRigvJShsYXJnZW9wR0Y4LyUubW92YWJsZWxpbWl0c0dGOC8lJ2FjY2VudEdGOC8lMGZvbnRfc3R5bGVfbmFtZUdGWC8lJXNpemVHRjUvJStmb3JlZ3JvdW5kR0ZELyUrYmFja2dyb3VuZEdGRy1JKG1mZW5jZWRHRiU2Iy1GJDYoRiwtRiQ2JS1GLTY5USJmRihGMEYzRjZGOUY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ25GaW5GXG9GY28tRlxyNiMtRiQ2Iy1GLTY5USJ4RihGMEYzRjZGOUY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ25GaW5GXG8tRmRvNjNRIixGKEZnb0Zqby9GXXBGO0ZecC9GYnBRM3Zlcnl0aGlja21hdGhzcGFjZUYoRmNwRmVwRmdwRmpwRl1xRl9xRmFxRmNxRmVxRmdxRmlxRmlyLUZkbzYzUSI9RihGZ29Gam9GXHAvRl9wUS90aGlja21hdGhzcGFjZUYoL0ZicEZmc0ZjcEZlcEZncEZqcEZdcUZfcUZhcUZjcUZlcUZncUZpcS1JI21uR0YlNjlRKyZ1bWludXMwOzJGKEYwRjNGNi9GOkY4RjxGPkZARkJGRUZIRkpGTEZORlBGUkZURlZGWUZlbkZnbi9Gam5RJ25vcm1hbEYoRlxvRiw3Iy1JJmxpbWl0RzYkJSpwcm90ZWN0ZWRHRio2JC1JImZHRig2I0kieEdGKC9GaHQhIiM=

NiQtSSZtZnJhY0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDYqLUkjbW5HRiU2OVEpJm1pbnVzOzNGKC8lJ2ZhbWlseUdRMFRpbWVzfk5ld35Sb21hbkYoLyUlc2l6ZUdRIzEyRigvJSVib2xkR1EmZmFsc2VGKC8lJ2l0YWxpY0dGOC8lKnVuZGVybGluZUdGOC8lKnN1YnNjcmlwdEdGOC8lLHN1cGVyc2NyaXB0R0Y4LyUrZm9yZWdyb3VuZEdRKlswLDAsMjU1XUYoLyUrYmFja2dyb3VuZEdRLlsyNTUsMjU1LDI1NV1GKC8lJ29wYXF1ZUdGOC8lK2V4ZWN1dGFibGVHRjgvJSlyZWFkb25seUdRJXRydWVGKC8lKWNvbXBvc2VkR0Y4LyUqY29udmVydGVkR0Y4LyUraW1zZWxlY3RlZEdGOC8lLHBsYWNlaG9sZGVyR0Y4LyUwZm9udF9zdHlsZV9uYW1lR1EqMkR+T3V0cHV0RigvJSptYXRoY29sb3JHRkMvJS9tYXRoYmFja2dyb3VuZEdGRi8lK2ZvbnRmYW1pbHlHRjIvJSxtYXRodmFyaWFudEdRJ25vcm1hbEYoLyUpbWF0aHNpemVHRjUtRi02OVEiMkYoRjBGM0Y2RjlGO0Y9Rj9GQUZERkdGSUZLRk5GUEZSRlRGVkZZRmVuRmduRmluRlxvLyUubGluZXRoaWNrbmVzc0dRIjFGKC8lK2Rlbm9tYWxpZ25HUSdjZW50ZXJGKC8lKW51bWFsaWduR0Zmby8lKWJldmVsbGVkR0Y4LyUrZm9yZWdyb3VuZEdGQy8lK2JhY2tncm91bmRHRkY3IyMhIiQiIiM=

Using MAPLE for limits at infinity.

Example #60, p. 108

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

NiQtSSZtZnJhY0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDYqLUkjbW5HRiU2OVExJm1pbnVzOzEwMDAwMDAwMEYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y4LyUqdW5kZXJsaW5lR0Y4LyUqc3Vic2NyaXB0R0Y4LyUsc3VwZXJzY3JpcHRHRjgvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y4LyUrZXhlY3V0YWJsZUdGOC8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjgvJSpjb252ZXJ0ZWRHRjgvJStpbXNlbGVjdGVkR0Y4LyUscGxhY2Vob2xkZXJHRjgvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQy8lL21hdGhiYWNrZ3JvdW5kR0ZGLyUrZm9udGZhbWlseUdGMi8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGNS1GLTY5USk5MzA3MDAwOUYoRjBGM0Y2RjlGO0Y9Rj9GQUZERkdGSUZLRk5GUEZSRlRGVkZZRmVuRmduRmluRlxvLyUubGluZXRoaWNrbmVzc0dRIjFGKC8lK2Rlbm9tYWxpZ25HUSdjZW50ZXJGKC8lKW51bWFsaWduR0Zmby8lKWJldmVsbGVkR0Y4LyUrZm9yZWdyb3VuZEdGQy8lK2JhY2tncm91bmRHRkY3IyMhKisrKysiIik0KzIkKg==

NiQtSSZtZnJhY0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDYqLUkjbW5HRiU2OVEyJm1pbnVzOzE2MDAwMDAwMDBGKC8lJ2ZhbWlseUdRMFRpbWVzfk5ld35Sb21hbkYoLyUlc2l6ZUdRIzEyRigvJSVib2xkR1EmZmFsc2VGKC8lJ2l0YWxpY0dGOC8lKnVuZGVybGluZUdGOC8lKnN1YnNjcmlwdEdGOC8lLHN1cGVyc2NyaXB0R0Y4LyUrZm9yZWdyb3VuZEdRKlswLDAsMjU1XUYoLyUrYmFja2dyb3VuZEdRLlsyNTUsMjU1LDI1NV1GKC8lJ29wYXF1ZUdGOC8lK2V4ZWN1dGFibGVHRjgvJSlyZWFkb25seUdRJXRydWVGKC8lKWNvbXBvc2VkR0Y4LyUqY29udmVydGVkR0Y4LyUraW1zZWxlY3RlZEdGOC8lLHBsYWNlaG9sZGVyR0Y4LyUwZm9udF9zdHlsZV9uYW1lR1EqMkR+T3V0cHV0RigvJSptYXRoY29sb3JHRkMvJS9tYXRoYmFja2dyb3VuZEdGRi8lK2ZvbnRmYW1pbHlHRjIvJSxtYXRodmFyaWFudEdRJ25vcm1hbEYoLyUpbWF0aHNpemVHRjUtRi02OVErMTU0NDI4MDAwOUYoRjBGM0Y2RjlGO0Y9Rj9GQUZERkdGSUZLRk5GUEZSRlRGVkZZRmVuRmduRmluRlxvLyUubGluZXRoaWNrbmVzc0dRIjFGKC8lK2Rlbm9tYWxpZ25HUSdjZW50ZXJGKC8lKW51bWFsaWduR0Zmby8lKWJldmVsbGVkR0Y4LyUrZm9yZWdyb3VuZEdGQy8lK2JhY2tncm91bmRHRkY3IyMhKysrKys7Iis0K0dXOg==

NiQtSSZtZnJhY0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDYqLUkjbW5HRiU2OVEzJm1pbnVzOzYyNTAwMDAwMDAwRigvJSdmYW1pbHlHUTBUaW1lc35OZXd+Um9tYW5GKC8lJXNpemVHUSMxMkYoLyUlYm9sZEdRJmZhbHNlRigvJSdpdGFsaWNHRjgvJSp1bmRlcmxpbmVHRjgvJSpzdWJzY3JpcHRHRjgvJSxzdXBlcnNjcmlwdEdGOC8lK2ZvcmVncm91bmRHUSpbMCwwLDI1NV1GKC8lK2JhY2tncm91bmRHUS5bMjU1LDI1NSwyNTVdRigvJSdvcGFxdWVHRjgvJStleGVjdXRhYmxlR0Y4LyUpcmVhZG9ubHlHUSV0cnVlRigvJSljb21wb3NlZEdGOC8lKmNvbnZlcnRlZEdGOC8lK2ltc2VsZWN0ZWRHRjgvJSxwbGFjZWhvbGRlckdGOC8lMGZvbnRfc3R5bGVfbmFtZUdRKjJEfk91dHB1dEYoLyUqbWF0aGNvbG9yR0ZDLyUvbWF0aGJhY2tncm91bmRHRkYvJStmb250ZmFtaWx5R0YyLyUsbWF0aHZhcmlhbnRHUSdub3JtYWxGKC8lKW1hdGhzaXplR0Y1LUYtNjlRLDYxNjI2NzUwMDA5RihGMEYzRjZGOUY7Rj1GP0ZBRkRGR0ZJRktGTkZQRlJGVEZWRllGZW5GZ25GaW5GXG8vJS5saW5ldGhpY2tuZXNzR1EiMUYoLyUrZGVub21hbGlnbkdRJ2NlbnRlckYoLyUpbnVtYWxpZ25HRmZvLyUpYmV2ZWxsZWRHRjgvJStmb3JlZ3JvdW5kR0ZDLyUrYmFja2dyb3VuZEdGRjcjIyEsKysrK0QnIiw0K3ZFOyc=

NiQtSSZtZnJhY0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDYqLUkjbW5HRiU2OVE1Jm1pbnVzOzEwMDAwMDAwMDAwMDBGKC8lJ2ZhbWlseUdRMFRpbWVzfk5ld35Sb21hbkYoLyUlc2l6ZUdRIzEyRigvJSVib2xkR1EmZmFsc2VGKC8lJ2l0YWxpY0dGOC8lKnVuZGVybGluZUdGOC8lKnN1YnNjcmlwdEdGOC8lLHN1cGVyc2NyaXB0R0Y4LyUrZm9yZWdyb3VuZEdRKlswLDAsMjU1XUYoLyUrYmFja2dyb3VuZEdRLlsyNTUsMjU1LDI1NV1GKC8lJ29wYXF1ZUdGOC8lK2V4ZWN1dGFibGVHRjgvJSlyZWFkb25seUdRJXRydWVGKC8lKWNvbXBvc2VkR0Y4LyUqY29udmVydGVkR0Y4LyUraW1zZWxlY3RlZEdGOC8lLHBsYWNlaG9sZGVyR0Y4LyUwZm9udF9zdHlsZV9uYW1lR1EqMkR+T3V0cHV0RigvJSptYXRoY29sb3JHRkMvJS9tYXRoYmFja2dyb3VuZEdGRi8lK2ZvbnRmYW1pbHlHRjIvJSxtYXRodmFyaWFudEdRJ25vcm1hbEYoLyUpbWF0aHNpemVHRjUtRi02OVEtOTkzMDA3MDAwMDA5RihGMEYzRjZGOUY7Rj1GP0ZBRkRGR0ZJRktGTkZQRlJGVEZWRllGZW5GZ25GaW5GXG8vJS5saW5ldGhpY2tuZXNzR1EiMUYoLyUrZGVub21hbGlnbkdRJ2NlbnRlckYoLyUpbnVtYWxpZ25HRmZvLyUpYmV2ZWxsZWRHRjgvJStmb3JlZ3JvdW5kR0ZDLyUrYmFja2dyb3VuZEdGRjcjIyEuKysrKysrIiItNCsrMkkqKg==

NiQtSSZtZnJhY0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDYqLUkjbW5HRiU2OVE5Jm1pbnVzOzEwMDAwMDAwMDAwMDAwMDAwRigvJSdmYW1pbHlHUTBUaW1lc35OZXd+Um9tYW5GKC8lJXNpemVHUSMxMkYoLyUlYm9sZEdRJmZhbHNlRigvJSdpdGFsaWNHRjgvJSp1bmRlcmxpbmVHRjgvJSpzdWJzY3JpcHRHRjgvJSxzdXBlcnNjcmlwdEdGOC8lK2ZvcmVncm91bmRHUSpbMCwwLDI1NV1GKC8lK2JhY2tncm91bmRHUS5bMjU1LDI1NSwyNTVdRigvJSdvcGFxdWVHRjgvJStleGVjdXRhYmxlR0Y4LyUpcmVhZG9ubHlHUSV0cnVlRigvJSljb21wb3NlZEdGOC8lKmNvbnZlcnRlZEdGOC8lK2ltc2VsZWN0ZWRHRjgvJSxwbGFjZWhvbGRlckdGOC8lMGZvbnRfc3R5bGVfbmFtZUdRKjJEfk91dHB1dEYoLyUqbWF0aGNvbG9yR0ZDLyUvbWF0aGJhY2tncm91bmRHRkYvJStmb250ZmFtaWx5R0YyLyUsbWF0aHZhcmlhbnRHUSdub3JtYWxGKC8lKW1hdGhzaXplR0Y1LUYtNjlRMTk5OTMwMDA3MDAwMDAwMDlGKEYwRjNGNkY5RjtGPUY/RkFGREZHRklGS0ZORlBGUkZURlZGWUZlbkZnbkZpbkZcby8lLmxpbmV0aGlja25lc3NHUSIxRigvJStkZW5vbWFsaWduR1EnY2VudGVyRigvJSludW1hbGlnbkdGZm8vJSliZXZlbGxlZEdGOC8lK2ZvcmVncm91bmRHRkMvJStiYWNrZ3JvdW5kR0ZGNyMjITIrKysrKysrKyIiMTQrKysyKyQqKio=

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5UTUmdW1pbnVzMDsxLjAxNDE2OTk4M0YoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjJCErJCkqcFQsIiEiKg==

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5UTUmdW1pbnVzMDsxLjAwNzA0MjI0NkYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjJCErWUEvMjUhIio=

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5UTUmdW1pbnVzMDsxLjAwMDcwMDQyMEYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjJCErPy9xKzUhIio=

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNiUtSSNtaUdGJTY5USFGKC8lJ2ZhbWlseUdRMFRpbWVzfk5ld35Sb21hbkYoLyUlc2l6ZUdRIzEyRigvJSVib2xkR1EmZmFsc2VGKC8lJ2l0YWxpY0dRJXRydWVGKC8lKnVuZGVybGluZUdGOC8lKnN1YnNjcmlwdEdGOC8lLHN1cGVyc2NyaXB0R0Y4LyUrZm9yZWdyb3VuZEdRKFswLDAsMF1GKC8lK2JhY2tncm91bmRHUS5bMjU1LDI1NSwyNTVdRigvJSdvcGFxdWVHRjgvJStleGVjdXRhYmxlR0Y7LyUpcmVhZG9ubHlHRjgvJSljb21wb3NlZEdGOC8lKmNvbnZlcnRlZEdGOC8lK2ltc2VsZWN0ZWRHRjgvJSxwbGFjZWhvbGRlckdGOC8lMGZvbnRfc3R5bGVfbmFtZUdRKTJEfklucHV0RigvJSptYXRoY29sb3JHRkQvJS9tYXRoYmFja2dyb3VuZEdGRy8lK2ZvbnRmYW1pbHlHRjIvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YoLyUpbWF0aHNpemVHRjUtRiQ2JS1GLTY5USZsaW1pdEYoRjBGM0Y2RjlGPEY+RkBGQkZFRkhGSkZMRk5GUEZSRlRGVkZZRmVuRmduRmluRlxvLUkjbW9HRiU2M1EwJkFwcGx5RnVuY3Rpb247RigvJSVmb3JtR1EmaW5maXhGKC8lJmZlbmNlR0Y4LyUqc2VwYXJhdG9yR0Y4LyUnbHNwYWNlR1EkMGVtRigvJSdyc3BhY2VHRmBwLyUpc3RyZXRjaHlHRjgvJSpzeW1tZXRyaWNHRjgvJShtYXhzaXplR1EpaW5maW5pdHlGKC8lKG1pbnNpemVHUSIxRigvJShsYXJnZW9wR0Y4LyUubW92YWJsZWxpbWl0c0dGOC8lJ2FjY2VudEdGOC8lMGZvbnRfc3R5bGVfbmFtZUdGWC8lJXNpemVHRjUvJStmb3JlZ3JvdW5kR0ZELyUrYmFja2dyb3VuZEdGRy1JKG1mZW5jZWRHRiU2Iy1GJDYoRiwtRiQ2JS1GLTY5USJoRihGMEYzRjZGOUY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ25GaW5GXG9GY28tRlxyNiMtRiQ2Iy1GLTY5USJ4RihGMEYzRjZGOUY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ25GaW5GXG8tRmRvNjNRIixGKEZnb0Zqby9GXXBGO0ZecC9GYnBRM3Zlcnl0aGlja21hdGhzcGFjZUYoRmNwRmVwRmdwRmpwRl1xRl9xRmFxRmNxRmVxRmdxRmlxRmlyLUZkbzYzUSI9RihGZ29Gam9GXHAvRl9wUS90aGlja21hdGhzcGFjZUYoL0ZicEZmc0ZjcEZlcEZncEZqcEZdcUZfcUZhcUZjcUZlcUZncUZpcS1GLTY5RmlwRjBGM0Y2RjlGPEY+RkBGQkZFRkhGSkZMRk5GUEZSRlRGVkZZRmVuRmduRmluRlxvRiw3Iy1JJmxpbWl0RzYkJSpwcm90ZWN0ZWRHRio2JC1JImhHRig2I0kieEdGKC9GY3RJKWluZmluaXR5R0ZedA==

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5USkmbWludXM7MUYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjISIi

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNiMtSSNtaUdGJTY5USFGKC8lJ2ZhbWlseUdRMFRpbWVzfk5ld35Sb21hbkYoLyUlc2l6ZUdRIzEyRigvJSVib2xkR1EmZmFsc2VGKC8lJ2l0YWxpY0dRJXRydWVGKC8lKnVuZGVybGluZUdGOC8lKnN1YnNjcmlwdEdGOC8lLHN1cGVyc2NyaXB0R0Y4LyUrZm9yZWdyb3VuZEdRKFswLDAsMF1GKC8lK2JhY2tncm91bmRHUS5bMjU1LDI1NSwyNTVdRigvJSdvcGFxdWVHRjgvJStleGVjdXRhYmxlR0Y7LyUpcmVhZG9ubHlHRjgvJSljb21wb3NlZEdGOC8lKmNvbnZlcnRlZEdGOC8lK2ltc2VsZWN0ZWRHRjgvJSxwbGFjZWhvbGRlckdGOC8lMGZvbnRfc3R5bGVfbmFtZUdRKTJEfklucHV0RigvJSptYXRoY29sb3JHRkQvJS9tYXRoYmFja2dyb3VuZEdGRy8lK2ZvbnRmYW1pbHlHRjIvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YoLyUpbWF0aHNpemVHRjU3Iy1JJXBsb3RHRig2JC1JImZHRig2I0kieEdGKEZlbw==

Tangent lines and secant lines.

Example just done in class: f(x)=(x-1)/(x+1) at the point x=0.

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNigtSSNtaUdGJTY5USJmRigvJSdmYW1pbHlHUTBUaW1lc35OZXd+Um9tYW5GKC8lJXNpemVHUSMxMkYoLyUlYm9sZEdRJmZhbHNlRigvJSdpdGFsaWNHUSV0cnVlRigvJSp1bmRlcmxpbmVHRjgvJSpzdWJzY3JpcHRHRjgvJSxzdXBlcnNjcmlwdEdGOC8lK2ZvcmVncm91bmRHUShbMCwwLDBdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y4LyUrZXhlY3V0YWJsZUdGOy8lKXJlYWRvbmx5R0Y4LyUpY29tcG9zZWRHRjgvJSpjb252ZXJ0ZWRHRjgvJStpbXNlbGVjdGVkR0Y4LyUscGxhY2Vob2xkZXJHRjgvJTBmb250X3N0eWxlX25hbWVHUSkyRH5JbnB1dEYoLyUqbWF0aGNvbG9yR0ZELyUvbWF0aGJhY2tncm91bmRHRkcvJStmb250ZmFtaWx5R0YyLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGKC8lKW1hdGhzaXplR0Y1LUkjbW9HRiU2M1EjOj1GKC8lJWZvcm1HUSZpbmZpeEYoLyUmZmVuY2VHRjgvJSpzZXBhcmF0b3JHRjgvJSdsc3BhY2VHUS90aGlja21hdGhzcGFjZUYoLyUncnNwYWNlR0ZbcC8lKXN0cmV0Y2h5R0Y4LyUqc3ltbWV0cmljR0Y4LyUobWF4c2l6ZUdRKWluZmluaXR5RigvJShtaW5zaXplR1EiMUYoLyUobGFyZ2VvcEdGOC8lLm1vdmFibGVsaW1pdHNHRjgvJSdhY2NlbnRHRjgvJTBmb250X3N0eWxlX25hbWVHRlgvJSVzaXplR0Y1LyUrZm9yZWdyb3VuZEdGRC8lK2JhY2tncm91bmRHRkctRi02OVEieEYoRjBGM0Y2RjlGPEY+RkBGQkZFRkhGSkZMRk5GUEZSRlRGVkZZRmVuRmduRmluRlxvLUZfbzYzUS0mUmlnaHRBcnJvdztGKEZib0Zlb0Znby9Gam9RMG1lZGl1bW1hdGhzcGFjZUYoL0ZdcEZdckZecEZgcEZicEZlcEZocEZqcEZccUZecUZgcUZicUZkcS1JJm1mcmFjR0YlNiotRiQ2JS1GLTY5USFGKEYwRjNGNkY5RjxGPkZARkJGRUZIRkpGTEZORlBGUkZURlZGWUZlbkZnbkZpbkZcby1JKG1mZW5jZWRHRiU2Iy1GJDYlRmZxLUZfbzYzUSgmbWludXM7RihGYm9GZW9GZ29GXHJGXnJGXnBGYHBGYnBGZXBGaHBGanBGXHFGXnFGYHFGYnFGZHEtSSNtbkdGJTY5RmdwRjBGM0Y2L0Y6RjhGPEY+RkBGQkZFRkhGSkZMRk5GUEZSRlRGVkZZRmVuRmduL0ZqblEnbm9ybWFsRihGXG9GZHItRiQ2JUZkci1GaHI2Iy1GJDYlRmZxLUZfbzYzUScmcGx1cztGKEZib0Zlb0Znb0ZcckZeckZecEZgcEZicEZlcEZocEZqcEZccUZecUZgcUZicUZkcUZfc0Zkci8lLmxpbmV0aGlja25lc3NHUSIxRigvJStkZW5vbWFsaWduR1EnY2VudGVyRigvJSludW1hbGlnbkdGY3QvJSliZXZlbGxlZEdGOEZicUZkcUZkcjcjPkkiZkdGKGYqNiNJInhHRihGKDYkSSlvcGVyYXRvckdGKEkmYXJyb3dHRihGKComLCZGXXUiIiJGY3UhIiJGY3UsJkZddUZjdUZjdUZjdUZkdUYoRihGKA==

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNiUtSSNtaUdGJTY5USJmRigvJSdmYW1pbHlHUTBUaW1lc35OZXd+Um9tYW5GKC8lJXNpemVHUSMxMkYoLyUlYm9sZEdRJmZhbHNlRigvJSdpdGFsaWNHUSV0cnVlRigvJSp1bmRlcmxpbmVHRjgvJSpzdWJzY3JpcHRHRjgvJSxzdXBlcnNjcmlwdEdGOC8lK2ZvcmVncm91bmRHUSpbMCwwLDI1NV1GKC8lK2JhY2tncm91bmRHUS5bMjU1LDI1NSwyNTVdRigvJSdvcGFxdWVHRjgvJStleGVjdXRhYmxlR0Y4LyUpcmVhZG9ubHlHRjsvJSljb21wb3NlZEdGOC8lKmNvbnZlcnRlZEdGOC8lK2ltc2VsZWN0ZWRHRjgvJSxwbGFjZWhvbGRlckdGOC8lMGZvbnRfc3R5bGVfbmFtZUdRKjJEfk91dHB1dEYoLyUqbWF0aGNvbG9yR0ZELyUvbWF0aGJhY2tncm91bmRHRkcvJStmb250ZmFtaWx5R0YyLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGKC8lKW1hdGhzaXplR0Y1LUkjbW9HRiU2M1EjOj1GKC8lJWZvcm1HUSZpbmZpeEYoLyUmZmVuY2VHRjgvJSpzZXBhcmF0b3JHRjgvJSdsc3BhY2VHUS90aGlja21hdGhzcGFjZUYoLyUncnNwYWNlR0ZbcC8lKXN0cmV0Y2h5R0Y4LyUqc3ltbWV0cmljR0Y4LyUobWF4c2l6ZUdRKWluZmluaXR5RigvJShtaW5zaXplR1EiMUYoLyUobGFyZ2VvcEdGOC8lLm1vdmFibGVsaW1pdHNHRjgvJSdhY2NlbnRHRjgvJTBmb250X3N0eWxlX25hbWVHRlgvJSVzaXplR0Y1LyUrZm9yZWdyb3VuZEdGRC8lK2JhY2tncm91bmRHRkctRiQ2JS1GLTY5USJ4RihGMEYzRjZGOUY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ25GaW5GXG8tRl9vNjNRJyZyYXJyO0YoL0Zjb1EhRihGZW9GZ28vRmpvUSQwZW1GKC9GXXBGYXJGXnBGYHBGYnBGZXBGaHBGanBGXHFGXnFGYHFGYnFGZHEtSSZtZnJhY0dGJTYqLUYkNiMtRiQ2JUZocS1GX282M1EoJm1pbnVzO0YoRmJvRmVvRmdvL0Zqb1EwbWVkaXVtbWF0aHNwYWNlRigvRl1wRl5zRl5wRmBwRmJwRmVwRmhwRmpwRlxxRl5xRmBxRmJxRmRxLUkjbW5HRiU2OUZncEYwRjNGNi9GOkY4RjxGPkZARkJGRUZIRkpGTEZORlBGUkZURlZGWUZlbkZnbi9Gam5RJ25vcm1hbEYoRlxvLUYkNiMtRiQ2JUZocS1GX282M1EiK0YoRmJvRmVvRmdvRl1zRl9zRl5wRmBwRmJwRmVwRmhwRmpwRlxxRl5xRmBxRmJxRmRxRmBzLyUubGluZXRoaWNrbmVzc0dRIjFGKC8lK2Rlbm9tYWxpZ25HUSdjZW50ZXJGKC8lKW51bWFsaWduR0ZidC8lKWJldmVsbGVkR0Y4RmJxRmRxNyMtX0YpSSxtcHJpbnRzbGFzaEdGKDYkNyM+SSJmR0YoZio2I0kieEdGKEYoNiRJKW9wZXJhdG9yR0YoSSZhcnJvd0dGKEYoKiYsJkZhdSIiIkZndSEiIkZndSwmRmF1Rmd1Rmd1Rmd1Rmh1RihGKEYoNyNGX3U=

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

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNistSSNtaUdGJTY5USJURigvJSdmYW1pbHlHUTBUaW1lc35OZXd+Um9tYW5GKC8lJXNpemVHUSMxMkYoLyUlYm9sZEdRJmZhbHNlRigvJSdpdGFsaWNHUSV0cnVlRigvJSp1bmRlcmxpbmVHRjgvJSpzdWJzY3JpcHRHRjgvJSxzdXBlcnNjcmlwdEdGOC8lK2ZvcmVncm91bmRHUShbMCwwLDBdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y4LyUrZXhlY3V0YWJsZUdGOy8lKXJlYWRvbmx5R0Y4LyUpY29tcG9zZWRHRjgvJSpjb252ZXJ0ZWRHRjgvJStpbXNlbGVjdGVkR0Y4LyUscGxhY2Vob2xkZXJHRjgvJTBmb250X3N0eWxlX25hbWVHUSkyRH5JbnB1dEYoLyUqbWF0aGNvbG9yR0ZELyUvbWF0aGJhY2tncm91bmRHRkcvJStmb250ZmFtaWx5R0YyLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGKC8lKW1hdGhzaXplR0Y1LUkjbW9HRiU2M1EjOj1GKC8lJWZvcm1HUSZpbmZpeEYoLyUmZmVuY2VHRjgvJSpzZXBhcmF0b3JHRjgvJSdsc3BhY2VHUS90aGlja21hdGhzcGFjZUYoLyUncnNwYWNlR0ZbcC8lKXN0cmV0Y2h5R0Y4LyUqc3ltbWV0cmljR0Y4LyUobWF4c2l6ZUdRKWluZmluaXR5RigvJShtaW5zaXplR1EiMUYoLyUobGFyZ2VvcEdGOC8lLm1vdmFibGVsaW1pdHNHRjgvJSdhY2NlbnRHRjgvJTBmb250X3N0eWxlX25hbWVHRlgvJSVzaXplR0Y1LyUrZm9yZWdyb3VuZEdGRC8lK2JhY2tncm91bmRHRkctRi02OVEieEYoRjBGM0Y2RjlGPEY+RkBGQkZFRkhGSkZMRk5GUEZSRlRGVkZZRmVuRmduRmluRlxvLUZfbzYzUS0mUmlnaHRBcnJvdztGKEZib0Zlb0Znby9Gam9RMG1lZGl1bW1hdGhzcGFjZUYoL0ZdcEZdckZecEZgcEZicEZlcEZocEZqcEZccUZecUZgcUZicUZkcS1JI21uR0YlNjlRIjJGKEYwRjNGNi9GOkY4RjxGPkZARkJGRUZIRkpGTEZORlBGUkZURlZGWUZlbkZnbi9Gam5RJ25vcm1hbEYoRlxvLUZfbzYzUScmc2RvdDtGKEZib0Zlby9GaG9GOy9Gam9RJDBlbUYoL0ZdcFEzdmVyeXRoaWNrbWF0aHNwYWNlRihGXnBGYHBGYnBGZXBGaHBGanBGXHFGXnFGYHFGYnFGZHFGZnEtRl9vNjNRKCZtaW51cztGKEZib0Zlb0ZpckZqckZcc0ZecEZgcEZicEZlcEZocEZqcEZccUZecUZgcUZicUZkcS1GYHI2OUZncEYwRjNGNkZjckY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ25GZHJGXG83Iz5JIlRHRihmKjYjSSJ4R0YoRig2JEkpb3BlcmF0b3JHRihJJmFycm93R0YoRigsJiomIiIjIiIiRmhzRl90Rl90Rl90ISIiRihGKEYo

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNiUtSSNtaUdGJTY5USJURigvJSdmYW1pbHlHUTBUaW1lc35OZXd+Um9tYW5GKC8lJXNpemVHUSMxMkYoLyUlYm9sZEdRJmZhbHNlRigvJSdpdGFsaWNHUSV0cnVlRigvJSp1bmRlcmxpbmVHRjgvJSpzdWJzY3JpcHRHRjgvJSxzdXBlcnNjcmlwdEdGOC8lK2ZvcmVncm91bmRHUSpbMCwwLDI1NV1GKC8lK2JhY2tncm91bmRHUS5bMjU1LDI1NSwyNTVdRigvJSdvcGFxdWVHRjgvJStleGVjdXRhYmxlR0Y4LyUpcmVhZG9ubHlHRjsvJSljb21wb3NlZEdGOC8lKmNvbnZlcnRlZEdGOC8lK2ltc2VsZWN0ZWRHRjgvJSxwbGFjZWhvbGRlckdGOC8lMGZvbnRfc3R5bGVfbmFtZUdRKjJEfk91dHB1dEYoLyUqbWF0aGNvbG9yR0ZELyUvbWF0aGJhY2tncm91bmRHRkcvJStmb250ZmFtaWx5R0YyLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGKC8lKW1hdGhzaXplR0Y1LUkjbW9HRiU2M1EjOj1GKC8lJWZvcm1HUSZpbmZpeEYoLyUmZmVuY2VHRjgvJSpzZXBhcmF0b3JHRjgvJSdsc3BhY2VHUS90aGlja21hdGhzcGFjZUYoLyUncnNwYWNlR0ZbcC8lKXN0cmV0Y2h5R0Y4LyUqc3ltbWV0cmljR0Y4LyUobWF4c2l6ZUdRKWluZmluaXR5RigvJShtaW5zaXplR1EiMUYoLyUobGFyZ2VvcEdGOC8lLm1vdmFibGVsaW1pdHNHRjgvJSdhY2NlbnRHRjgvJTBmb250X3N0eWxlX25hbWVHRlgvJSVzaXplR0Y1LyUrZm9yZWdyb3VuZEdGRC8lK2JhY2tncm91bmRHRkctRiQ2JS1GLTY5USJ4RihGMEYzRjZGOUY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ25GaW5GXG8tRl9vNjNRJyZyYXJyO0YoL0Zjb1EhRihGZW9GZ28vRmpvUSQwZW1GKC9GXXBGYXJGXnBGYHBGYnBGZXBGaHBGanBGXHFGXnFGYHFGYnFGZHEtRiQ2JS1GJDYlLUkjbW5HRiU2OVEiMkYoRjBGM0Y2L0Y6RjhGPEY+RkBGQkZFRkhGSkZMRk5GUEZSRlRGVkZZRmVuRmduL0ZqblEnbm9ybWFsRihGXG8tRl9vNjNRMSZJbnZpc2libGVUaW1lcztGKEZib0Zlb0Znb0ZgckZickZecEZgcEZicEZlcEZocEZqcEZccUZecUZgcUZicUZkcUZocS1GX282M1EoJm1pbnVzO0YoRmJvRmVvRmdvL0Zqb1EwbWVkaXVtbWF0aHNwYWNlRigvRl1wRmVzRl5wRmBwRmJwRmVwRmhwRmpwRlxxRl5xRmBxRmJxRmRxLUZocjY5RmdwRjBGM0Y2RltzRjxGPkZARkJGRUZIRkpGTEZORlBGUkZURlZGWUZlbkZnbkZcc0ZcbzcjLV9GKUksbXByaW50c2xhc2hHRig2JDcjPkkiVEdGKGYqNiNJInhHRihGKDYkSSlvcGVyYXRvckdGKEkmYXJyb3dHRihGKCwmKiYiIiMiIiJGY3RGanRGanRGanQhIiJGKEYoRig3I0ZhdA==

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

Example: g(x)=sqrt(x^2-2x) at x=3

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

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNiUtSSNtaUdGJTY5USJnRigvJSdmYW1pbHlHUTBUaW1lc35OZXd+Um9tYW5GKC8lJXNpemVHUSMxMkYoLyUlYm9sZEdRJmZhbHNlRigvJSdpdGFsaWNHUSV0cnVlRigvJSp1bmRlcmxpbmVHRjgvJSpzdWJzY3JpcHRHRjgvJSxzdXBlcnNjcmlwdEdGOC8lK2ZvcmVncm91bmRHUSpbMCwwLDI1NV1GKC8lK2JhY2tncm91bmRHUS5bMjU1LDI1NSwyNTVdRigvJSdvcGFxdWVHRjgvJStleGVjdXRhYmxlR0Y4LyUpcmVhZG9ubHlHRjsvJSljb21wb3NlZEdGOC8lKmNvbnZlcnRlZEdGOC8lK2ltc2VsZWN0ZWRHRjgvJSxwbGFjZWhvbGRlckdGOC8lMGZvbnRfc3R5bGVfbmFtZUdRKjJEfk91dHB1dEYoLyUqbWF0aGNvbG9yR0ZELyUvbWF0aGJhY2tncm91bmRHRkcvJStmb250ZmFtaWx5R0YyLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGKC8lKW1hdGhzaXplR0Y1LUkjbW9HRiU2M1EjOj1GKC8lJWZvcm1HUSZpbmZpeEYoLyUmZmVuY2VHRjgvJSpzZXBhcmF0b3JHRjgvJSdsc3BhY2VHUS90aGlja21hdGhzcGFjZUYoLyUncnNwYWNlR0ZbcC8lKXN0cmV0Y2h5R0Y4LyUqc3ltbWV0cmljR0Y4LyUobWF4c2l6ZUdRKWluZmluaXR5RigvJShtaW5zaXplR1EiMUYoLyUobGFyZ2VvcEdGOC8lLm1vdmFibGVsaW1pdHNHRjgvJSdhY2NlbnRHRjgvJTBmb250X3N0eWxlX25hbWVHRlgvJSVzaXplR0Y1LyUrZm9yZWdyb3VuZEdGRC8lK2JhY2tncm91bmRHRkctRiQ2JS1GLTY5USJ4RihGMEYzRjZGOUY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ25GaW5GXG8tRl9vNjNRJyZyYXJyO0YoL0Zjb1EhRihGZW9GZ28vRmpvUSQwZW1GKC9GXXBGYXJGXnBGYHBGYnBGZXBGaHBGanBGXHFGXnFGYHFGYnFGZHEtSSZtc3FydEdGJTYlLUYkNiUtRiQ2Iy1JJW1zdXBHRiU2JUZocS1JI21uR0YlNjlRIjJGKEYwRjNGNi9GOkY4RjxGPkZARkJGRUZIRkpGTEZORlBGUkZURlZGWUZlbkZnbi9Gam5RJ25vcm1hbEYoRlxvLyUxc3VwZXJzY3JpcHRzaGlmdEdRIjBGKC1GX282M1EoJm1pbnVzO0YoRmJvRmVvRmdvL0Zqb1EwbWVkaXVtbWF0aHNwYWNlRigvRl1wRlt0Rl5wRmBwRmJwRmVwRmhwRmpwRlxxRl5xRmBxRmJxRmRxLUYkNiVGXXMtRl9vNjNRMSZJbnZpc2libGVUaW1lcztGKEZib0Zlb0Znb0ZgckZickZecEZgcEZicEZlcEZocEZqcEZccUZecUZgcUZicUZkcUZocUZicUZkcTcjLV9GKUksbXByaW50c2xhc2hHRig2JDcjPkkiZ0dGKGYqNiNJInhHRihGKDYkSSlvcGVyYXRvckdGKEkmYXJyb3dHRihGKC1JJXNxcnRHNiQlKnByb3RlY3RlZEdGKjYjLCYqJClGXHUiIiMiIiJGaXUqJkZodUZpdUZcdUZpdSEiIkYoRihGKDcjRmp0

We need to set up the difference quotient: (g(3+h)-g(3))/h.

We can define a function of h that gives this difference quotient. Call it Q(h).

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

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5USwxLjA5NjM3NjMxN0YoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjJCIrPGpQJzQiISIq

NiUtSSdDVVJWRVNHNiI2JDdWNyQkISM1IiIhJCIzQ0suLDpeVyY0IiEjOzckJCEzRSsrKzxwMGsmKiEjPCQiMzFSZi42P21eNUYuNyQkITNVKioqKio0PFhaPSpGMiQiMyVvLCdvQ0xiODVGLjckJCEzISkqKioqKj5XcCJlKClGMiQiM2csYSlvMyZ6MSgqRjI3JCQhM1MrKysjNG0oRyQpRjIkIjNrb04ydU4sdiMqRjI3JCQhMy8rKytAT1MsekYyJCIzYWZkRltWMFgpKUYyNyQkITMiKioqKioqUiFSPTB2RjIkIjM9WiNlN2siPlklKUYyNyQkITNzKioqKipwTEBcNChGMiQiMyRwN19pdTtILilGMjckJCEzayoqKioqUj9GMW4nRjIkIjNJUWEqcDlrXmcoRjI3JCQhM0ErKysoeSRwWmlGMiQiMzFBJSo0S1tQeXJGMjckJCEzOysrKyR5YUUiZUYyJCIzQWJCKHBJaSlRbkYyNyQkITNNKysrIj5zJUhhRjIkIjN5bV8jUkFIN04nRjI3JCQhM1ErKytdJCo0KSpcRjIkIjNOWERYakA6OWZGMjckJCEzbyoqKioqKlxfJlxjJUYyJCIzXT1XVi4rUHVhRjI3JCQhMyUpKioqKioqXDFhWlRGMiQiMzM1Vk0+RlpcXUYyNyQkITMxKysrLyMpW29QRjIkIjNPejZwaVVYaVlGMjckJCEzLisrKyQ9ZXhKJEYyJCIzVVkhMzBRaC4/JUYyNyQkITM9KysrTDIkZiRIRjIkIjN0KnA4JVtweDFRRjI3JCQhMyEpKioqKipwanU8XCNGMiQiM1lmUFM5el5YTEYyNyQkITMhKSoqKioqSEJAJyk0I0YyJCIza04oPm5aQkckSEYyNyQkITMnKioqKioqcGpwc20iRjIkIjN5Yy9PJ2U7RlojRjI3JCQhMy8rKys3NF9jN0YyJCIzKSkqM3FoQVRHLSNGMjckJCEzXSoqKioqKnpxWnojKSEjPSQiM2VqPiZbL2gsYCJGMjckJCEzdCoqKioqKio+UFFNJUZmciQiM2ckKXpPOnJLRzVGMjckJCEzJyoqKioqKlxieDdBI0ZmciQiM0EoPkVjYVNjLShGZnI3JCQhM2MqKioqKioqKjR6cikqISM/JCIzYUgsOGk/ZTM5RmZyNyRJKnVuZGVmaW5lZEclKnByb3RlY3RlZEdGanM3JCQiMyYqKioqKip6ZS04LCNGMiQiMzttRj1mVHUyOkZmcjckJCIzQCsrK3doUkM/RjIkIjNfQ08wSS9MQUFGZnI3JCQiMyUqKioqKipITiRlXT9GMiQiM3V2ekwyRGs/S0ZmcjckJCIzNysrK0kweHc/RjIkIjNTRFJjRiVHSCpSRmZyNyQkIjMxKysrWCtaekFGMiQiMyMzKztzMyw6KXpGZnI3JCQiMysrKytnJnBAWyNGMiQiM2dzKEdmcSYqUjQiRjI3JCQiM0ArKys/R0IyRkYyJCIzJXAlb3ghZTFQUSJGMjckJCIzKCoqKioqKip6Z0hLSEYyJCIzR1FRRGk1VGA7RjI3JCQiMz8rKytxWnZPTEYyJCIzb2RAbj44KD42I0YyNyQkIjMxKysrXTJnb1BGMiQiMyNIJlJSLF9wImUjRjI3JCQiM0srKysrdSIqZlRGMiQiMzNTTDNrPl4oKkhGMjckJCIzbSoqKioqKlwpSHhlJUYyJCIzRXc7blknW2JXJEYyNyQkIjM9KysrSSFvLSpcRjIkIjNNImZYTlJKSCdRRjI3JCQiM04rKys1ay42YUYyJCIzTVVDN20jKj0nSCVGMjckJCIzSisrKz9XVEFlRjIkIjNNbFdDJnAjZjxaRjI3JCQiM3cqKioqKipmISozYGlGMiQiM1EiNC5xbUdxOiZGMjckJCIzeSoqKioqKkgqenltJ0YyJCIzaylRd1I2bSp5YkYyNyQkIjMrKysrNU4xIzQoRjIkIjMyKT4sXzJIJTRnRjI3JCQiM3YqKioqKipIWXQ3dkYyJCIzJm9XKHBbU11Oa0YyNyQkIjNNKysrK3hHKip5RjIkIjNwZyFvVHhKayNvRjI3JCQiM0MqKioqKipSNktVJClGMiQiMztyOjZBUyFSRihGMjckJCIzSysrK0liZFEoKUYyJCIzP1gmUTg6I3B0d0YyNyQkIjNHKysrZ2AxaCIqRjIkIjN5PTdAUHJjKjQpRjI3JCQiM2srKytTP1dsJipGMiQiMyJSeC91bG5vXSlGMjckJCIjNUYrJCIzQWYiKioqND5GVyopRjItSSdDT0xPVVJHRiU2JkkkUkdCR0YlJEZmW2whIiIkRitGK0ZfXGwtSStBWEVTTEFCRUxTRzYkRlt0SShfc3lzbGliR0YlNiRRInhGJVEhRiUtSSVWSUVXR0ZiXGw2JDtGKUZlW2xJKERFRkFVTFRHRiU=

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNiUtSSNtaUdGJTY5USFGKC8lJ2ZhbWlseUdRMFRpbWVzfk5ld35Sb21hbkYoLyUlc2l6ZUdRIzEyRigvJSVib2xkR1EmZmFsc2VGKC8lJ2l0YWxpY0dRJXRydWVGKC8lKnVuZGVybGluZUdGOC8lKnN1YnNjcmlwdEdGOC8lLHN1cGVyc2NyaXB0R0Y4LyUrZm9yZWdyb3VuZEdRKFswLDAsMF1GKC8lK2JhY2tncm91bmRHUS5bMjU1LDI1NSwyNTVdRigvJSdvcGFxdWVHRjgvJStleGVjdXRhYmxlR0Y7LyUpcmVhZG9ubHlHRjgvJSljb21wb3NlZEdGOC8lKmNvbnZlcnRlZEdGOC8lK2ltc2VsZWN0ZWRHRjgvJSxwbGFjZWhvbGRlckdGOC8lMGZvbnRfc3R5bGVfbmFtZUdRKTJEfklucHV0RigvJSptYXRoY29sb3JHRkQvJS9tYXRoYmFja2dyb3VuZEdGRy8lK2ZvbnRmYW1pbHlHRjIvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YoLyUpbWF0aHNpemVHRjUtRiQ2JS1GLTY5USVwbG90RihGMEYzRjZGOUY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ25GaW5GXG8tSSNtb0dGJTYzUTAmQXBwbHlGdW5jdGlvbjtGKC8lJWZvcm1HUSZpbmZpeEYoLyUmZmVuY2VHRjgvJSpzZXBhcmF0b3JHRjgvJSdsc3BhY2VHUSQwZW1GKC8lJ3JzcGFjZUdGYHAvJSlzdHJldGNoeUdGOC8lKnN5bW1ldHJpY0dGOC8lKG1heHNpemVHUSlpbmZpbml0eUYoLyUobWluc2l6ZUdRIjFGKC8lKGxhcmdlb3BHRjgvJS5tb3ZhYmxlbGltaXRzR0Y4LyUnYWNjZW50R0Y4LyUwZm9udF9zdHlsZV9uYW1lR0ZYLyUlc2l6ZUdGNS8lK2ZvcmVncm91bmRHRkQvJStiYWNrZ3JvdW5kR0ZHLUkobWZlbmNlZEdGJTYjLUYkNipGLC1GJDYlLUYtNjlRImdGKEYwRjNGNkY5RjxGPkZARkJGRUZIRkpGTEZORlBGUkZURlZGWUZlbkZnbkZpbkZcb0Zjby1GXHI2Iy1GJDYjLUYtNjlRInhGKEYwRjNGNkY5RjxGPkZARkJGRUZIRkpGTEZORlBGUkZURlZGWUZlbkZnbkZpbkZcby1GZG82M1EiLEYoRmdvRmpvL0ZdcEY7Rl5wL0ZicFEzdmVyeXRoaWNrbWF0aHNwYWNlRihGY3BGZXBGZ3BGanBGXXFGX3FGYXFGY3FGZXFGZ3FGaXFGaXItRmRvNjNRIj1GKEZnb0Zqb0ZccC9GX3BRL3RoaWNrbWF0aHNwYWNlRigvRmJwRmZzRmNwRmVwRmdwRmpwRl1xRl9xRmFxRmNxRmVxRmdxRmlxLUkjbW5HRiU2OVEiMkYoRjBGM0Y2L0Y6RjhGPEY+RkBGQkZFRkhGSkZMRk5GUEZSRlRGVkZZRmVuRmduL0ZqblEnbm9ybWFsRihGXG8tRmRvNjNRIy4uRigvRmhvUShwb3N0Zml4RihGam9GXHAvRl9wUTBtZWRpdW1tYXRoc3BhY2VGKEZhcEZjcEZlcEZncEZqcEZdcUZfcUZhcUZjcUZlcUZncUZpcS1GaXM2OVEiNUYoRjBGM0Y2Rlx0RjxGPkZARkJGRUZIRkpGTEZORlBGUkZURlZGWUZlbkZnbkZddEZcb0YsNyMtSSVwbG90RzYkJSpwcm90ZWN0ZWRHRio2JC1JImdHRig2I0kieEdGKC9GYnU7IiIjIiIm

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

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNiwtSSNtaUdGJTY5USNTMUYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR1EldHJ1ZUYoLyUqdW5kZXJsaW5lR0Y4LyUqc3Vic2NyaXB0R0Y4LyUsc3VwZXJzY3JpcHRHRjgvJStmb3JlZ3JvdW5kR1EoWzAsMCwwXUYoLyUrYmFja2dyb3VuZEdRLlsyNTUsMjU1LDI1NV1GKC8lJ29wYXF1ZUdGOC8lK2V4ZWN1dGFibGVHRjsvJSlyZWFkb25seUdGOC8lKWNvbXBvc2VkR0Y4LyUqY29udmVydGVkR0Y4LyUraW1zZWxlY3RlZEdGOC8lLHBsYWNlaG9sZGVyR0Y4LyUwZm9udF9zdHlsZV9uYW1lR1EpMkR+SW5wdXRGKC8lKm1hdGhjb2xvckdGRC8lL21hdGhiYWNrZ3JvdW5kR0ZHLyUrZm9udGZhbWlseUdGMi8lLG1hdGh2YXJpYW50R1EnaXRhbGljRigvJSltYXRoc2l6ZUdGNS1JI21vR0YlNjNRIzo9RigvJSVmb3JtR1EmaW5maXhGKC8lJmZlbmNlR0Y4LyUqc2VwYXJhdG9yR0Y4LyUnbHNwYWNlR1EvdGhpY2ttYXRoc3BhY2VGKC8lJ3JzcGFjZUdGW3AvJSlzdHJldGNoeUdGOC8lKnN5bW1ldHJpY0dGOC8lKG1heHNpemVHUSlpbmZpbml0eUYoLyUobWluc2l6ZUdRIjFGKC8lKGxhcmdlb3BHRjgvJS5tb3ZhYmxlbGltaXRzR0Y4LyUnYWNjZW50R0Y4LyUwZm9udF9zdHlsZV9uYW1lR0ZYLyUlc2l6ZUdGNS8lK2ZvcmVncm91bmRHRkQvJStiYWNrZ3JvdW5kR0ZHLUYtNjlRInhGKEYwRjNGNkY5RjxGPkZARkJGRUZIRkpGTEZORlBGUkZURlZGWUZlbkZnbkZpbkZcby1GX282M1EtJlJpZ2h0QXJyb3c7RihGYm9GZW9GZ28vRmpvUTBtZWRpdW1tYXRoc3BhY2VGKC9GXXBGXXJGXnBGYHBGYnBGZXBGaHBGanBGXHFGXnFGYHFGYnFGZHEtRiQ2JS1GLTY5USJnRihGMEYzRjZGOUY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ25GaW5GXG8tRl9vNjNRMCZBcHBseUZ1bmN0aW9uO0YoRmJvRmVvRmdvL0Zqb1EkMGVtRigvRl1wRmhyRl5wRmBwRmJwRmVwRmhwRmpwRlxxRl5xRmBxRmJxRmRxLUkobWZlbmNlZEdGJTYjLUYkNiMtSSNtbkdGJTY5USMzLkYoRjBGM0Y2L0Y6RjhGPEY+RkBGQkZFRkhGSkZMRk5GUEZSRlRGVkZZRmVuRmduL0ZqblEnbm9ybWFsRihGXG8tRl9vNjNRJyZwbHVzO0YoRmJvRmVvRmdvRlxyRl5yRl5wRmBwRmJwRmVwRmhwRmpwRlxxRl5xRmBxRmJxRmRxLUYkNiUtRi02OVEiUUYoRjBGM0Y2RjlGPEY+RkBGQkZFRkhGSkZMRk5GUEZSRlRGVkZZRmVuRmduRmluRlxvRmRyLUZbczYjLUYkNiMtRmBzNjlRIzEuRihGMEYzRjZGY3NGPEY+RkBGQkZFRkhGSkZMRk5GUEZSRlRGVkZZRmVuRmduRmRzRlxvLUZfbzYzUScmc2RvdDtGKEZib0Zlby9GaG9GO0Znci9GXXBRM3Zlcnl0aGlja21hdGhzcGFjZUYoRl5wRmBwRmJwRmVwRmhwRmpwRlxxRl5xRmBxRmJxRmRxLUZbczYjLUYkNiVGZnEtRl9vNjNRKCZtaW51cztGKEZib0Zlb0ZodEZnckZpdEZecEZgcEZicEZlcEZocEZqcEZccUZecUZgcUZicUZkcUZfcy1GLTY5USFGKEYwRjNGNkY5RjxGPkZARkJGRUZIRkpGTEZORlBGUkZURlZGWUZlbkZnbkZpbkZcbzcjPkkjUzFHRihmKjYjSSJ4R0YoRig2JEkpb3BlcmF0b3JHRihJJmFycm93R0YoRigsJi1JImdHRig2IyQiIiQiIiEiIiIqJi1JIlFHRig2IyRGZXZGZHZGZXYsJkZqdUZldkZidiEiIkZldkZldkYoRihGKA==

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

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5USwyLjgyODQyNzEyNUYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjJCIrRHJVR0chIio=

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

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5USwxLjE0NTY3NzIzMEYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjJCIrSXNuWDYhIio=

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

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5USwxLjE1MDA0NDE4MEYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjJCIrIT1XKzoiISIq

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNiUtSSNtaUdGJTY5USFGKC8lJ2ZhbWlseUdRMFRpbWVzfk5ld35Sb21hbkYoLyUlc2l6ZUdRIzEyRigvJSVib2xkR1EmZmFsc2VGKC8lJ2l0YWxpY0dRJXRydWVGKC8lKnVuZGVybGluZUdGOC8lKnN1YnNjcmlwdEdGOC8lLHN1cGVyc2NyaXB0R0Y4LyUrZm9yZWdyb3VuZEdRKFswLDAsMF1GKC8lK2JhY2tncm91bmRHUS5bMjU1LDI1NSwyNTVdRigvJSdvcGFxdWVHRjgvJStleGVjdXRhYmxlR0Y7LyUpcmVhZG9ubHlHRjgvJSljb21wb3NlZEdGOC8lKmNvbnZlcnRlZEdGOC8lK2ltc2VsZWN0ZWRHRjgvJSxwbGFjZWhvbGRlckdGOC8lMGZvbnRfc3R5bGVfbmFtZUdRKTJEfklucHV0RigvJSptYXRoY29sb3JHRkQvJS9tYXRoYmFja2dyb3VuZEdGRy8lK2ZvbnRmYW1pbHlHRjIvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YoLyUpbWF0aHNpemVHRjUtRiQ2JS1GLTY5USZsaW1pdEYoRjBGM0Y2RjlGPEY+RkBGQkZFRkhGSkZMRk5GUEZSRlRGVkZZRmVuRmduRmluRlxvLUkjbW9HRiU2M1EwJkFwcGx5RnVuY3Rpb247RigvJSVmb3JtR1EmaW5maXhGKC8lJmZlbmNlR0Y4LyUqc2VwYXJhdG9yR0Y4LyUnbHNwYWNlR1EkMGVtRigvJSdyc3BhY2VHRmBwLyUpc3RyZXRjaHlHRjgvJSpzeW1tZXRyaWNHRjgvJShtYXhzaXplR1EpaW5maW5pdHlGKC8lKG1pbnNpemVHUSIxRigvJShsYXJnZW9wR0Y4LyUubW92YWJsZWxpbWl0c0dGOC8lJ2FjY2VudEdGOC8lMGZvbnRfc3R5bGVfbmFtZUdGWC8lJXNpemVHRjUvJStmb3JlZ3JvdW5kR0ZELyUrYmFja2dyb3VuZEdGRy1JKG1mZW5jZWRHRiU2Iy1GJDYoRiwtRiQ2JS1GLTY5USJRRihGMEYzRjZGOUY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ25GaW5GXG9GY28tRlxyNiMtRiQ2Iy1GLTY5USJoRihGMEYzRjZGOUY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ25GaW5GXG8tRmRvNjNRIixGKEZnb0Zqby9GXXBGO0ZecC9GYnBRM3Zlcnl0aGlja21hdGhzcGFjZUYoRmNwRmVwRmdwRmpwRl1xRl9xRmFxRmNxRmVxRmdxRmlxRmlyLUZkbzYzUSI9RihGZ29Gam9GXHAvRl9wUS90aGlja21hdGhzcGFjZUYoL0ZicEZmc0ZjcEZlcEZncEZqcEZdcUZfcUZhcUZjcUZlcUZncUZpcS1JI21uR0YlNjlRIjBGKEYwRjNGNi9GOkY4RjxGPkZARkJGRUZIRkpGTEZORlBGUkZURlZGWUZlbkZnbi9Gam5RJ25vcm1hbEYoRlxvRiw3Iy1JJmxpbWl0RzYkJSpwcm90ZWN0ZWRHRio2JC1JIlFHRig2I0kiaEdGKC9GaHQiIiE=

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNiUtSSNtaUdGJTY5USZGbG9hdEYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR1EldHJ1ZUYoLyUqdW5kZXJsaW5lR0Y4LyUqc3Vic2NyaXB0R0Y4LyUsc3VwZXJzY3JpcHRHRjgvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y4LyUrZXhlY3V0YWJsZUdGOC8lKXJlYWRvbmx5R0Y7LyUpY29tcG9zZWRHRjgvJSpjb252ZXJ0ZWRHRjgvJStpbXNlbGVjdGVkR0Y4LyUscGxhY2Vob2xkZXJHRjgvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGRC8lL21hdGhiYWNrZ3JvdW5kR0ZHLyUrZm9udGZhbWlseUdGMi8lLG1hdGh2YXJpYW50R1EnaXRhbGljRigvJSltYXRoc2l6ZUdGNS1JI21vR0YlNjNRMCZBcHBseUZ1bmN0aW9uO0YoLyUlZm9ybUdRJmluZml4RigvJSZmZW5jZUdGOC8lKnNlcGFyYXRvckdGOC8lJ2xzcGFjZUdRJDBlbUYoLyUncnNwYWNlR0ZbcC8lKXN0cmV0Y2h5R0Y4LyUqc3ltbWV0cmljR0Y4LyUobWF4c2l6ZUdRKWluZmluaXR5RigvJShtaW5zaXplR1EiMUYoLyUobGFyZ2VvcEdGOC8lLm1vdmFibGVsaW1pdHNHRjgvJSdhY2NlbnRHRjgvJTBmb250X3N0eWxlX25hbWVHRlgvJSVzaXplR0Y1LyUrZm9yZWdyb3VuZEdGRC8lK2JhY2tncm91bmRHRkctRiQ2JS1GX282M1EiKEYoL0Zjb1EncHJlZml4RigvRmZvRjtGZ28vRmpvUS50aGlubWF0aHNwYWNlRigvRl1wRl9yL0ZfcEY7RmBwRmJwRmVwRmhwRmpwRlxxRl5xRmBxRmJxRmRxLUYkNiMtRi02OVEqdW5kZWZpbmVkRihGMEYzRjZGOUY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ25GaW5GXG8tRl9vNjNRIilGKC9GY29RKHBvc3RmaXhGKEZdckZnb0Zeci9GXXBRMnZlcnl0aGlubWF0aHNwYWNlRihGYXJGYHBGYnBGZXBGaHBGanBGXHFGXnFGYHFGYnFGZHE3IyQiIiJJKnVuZGVmaW5lZEclKnByb3RlY3RlZEc=

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5USwxLjE1NDYwNDAwMEYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjJCIrK1NnYTYhIio=

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5USwxLjE1NDY5MDAwMEYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjJCIrKytwYTYhIio=

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNiUtSSNtaUdGJTY5USFGKC8lJ2ZhbWlseUdRMFRpbWVzfk5ld35Sb21hbkYoLyUlc2l6ZUdRIzEyRigvJSVib2xkR1EmZmFsc2VGKC8lJ2l0YWxpY0dRJXRydWVGKC8lKnVuZGVybGluZUdGOC8lKnN1YnNjcmlwdEdGOC8lLHN1cGVyc2NyaXB0R0Y4LyUrZm9yZWdyb3VuZEdRKFswLDAsMF1GKC8lK2JhY2tncm91bmRHUS5bMjU1LDI1NSwyNTVdRigvJSdvcGFxdWVHRjgvJStleGVjdXRhYmxlR0Y7LyUpcmVhZG9ubHlHRjgvJSljb21wb3NlZEdGOC8lKmNvbnZlcnRlZEdGOC8lK2ltc2VsZWN0ZWRHRjgvJSxwbGFjZWhvbGRlckdGOC8lMGZvbnRfc3R5bGVfbmFtZUdRKTJEfklucHV0RigvJSptYXRoY29sb3JHRkQvJS9tYXRoYmFja2dyb3VuZEdGRy8lK2ZvbnRmYW1pbHlHRjIvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YoLyUpbWF0aHNpemVHRjUtRiQ2JS1GLTY5USZsaW1pdEYoRjBGM0Y2RjlGPEY+RkBGQkZFRkhGSkZMRk5GUEZSRlRGVkZZRmVuRmduRmluRlxvLUkjbW9HRiU2M1EwJkFwcGx5RnVuY3Rpb247RigvJSVmb3JtR1EmaW5maXhGKC8lJmZlbmNlR0Y4LyUqc2VwYXJhdG9yR0Y4LyUnbHNwYWNlR1EkMGVtRigvJSdyc3BhY2VHRmBwLyUpc3RyZXRjaHlHRjgvJSpzeW1tZXRyaWNHRjgvJShtYXhzaXplR1EpaW5maW5pdHlGKC8lKG1pbnNpemVHUSIxRigvJShsYXJnZW9wR0Y4LyUubW92YWJsZWxpbWl0c0dGOC8lJ2FjY2VudEdGOC8lMGZvbnRfc3R5bGVfbmFtZUdGWC8lJXNpemVHRjUvJStmb3JlZ3JvdW5kR0ZELyUrYmFja2dyb3VuZEdGRy1JKG1mZW5jZWRHRiU2Iy1GJDYoRiwtRiQ2JS1GLTY5USJRRihGMEYzRjZGOUY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ25GaW5GXG9GY28tRlxyNiMtRiQ2Iy1GLTY5USJ4RihGMEYzRjZGOUY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ25GaW5GXG8tRmRvNjNRIixGKEZnb0Zqby9GXXBGO0ZecC9GYnBRM3Zlcnl0aGlja21hdGhzcGFjZUYoRmNwRmVwRmdwRmpwRl1xRl9xRmFxRmNxRmVxRmdxRmlxRmlyLUZkbzYzUSI9RihGZ29Gam9GXHAvRl9wUS90aGlja21hdGhzcGFjZUYoL0ZicEZmc0ZjcEZlcEZncEZqcEZdcUZfcUZhcUZjcUZlcUZncUZpcS1JI21uR0YlNjlRIjBGKEYwRjNGNi9GOkY4RjxGPkZARkJGRUZIRkpGTEZORlBGUkZURlZGWUZlbkZnbi9Gam5RJ25vcm1hbEYoRlxvRiw3Iy1JJmxpbWl0RzYkJSpwcm90ZWN0ZWRHRio2JC1JIlFHRig2I0kieEdGKC9GaHQiIiE=

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNiUtSSNtaUdGJTY5USZGbG9hdEYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR1EldHJ1ZUYoLyUqdW5kZXJsaW5lR0Y4LyUqc3Vic2NyaXB0R0Y4LyUsc3VwZXJzY3JpcHRHRjgvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y4LyUrZXhlY3V0YWJsZUdGOC8lKXJlYWRvbmx5R0Y7LyUpY29tcG9zZWRHRjgvJSpjb252ZXJ0ZWRHRjgvJStpbXNlbGVjdGVkR0Y4LyUscGxhY2Vob2xkZXJHRjgvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGRC8lL21hdGhiYWNrZ3JvdW5kR0ZHLyUrZm9udGZhbWlseUdGMi8lLG1hdGh2YXJpYW50R1EnaXRhbGljRigvJSltYXRoc2l6ZUdGNS1JI21vR0YlNjNRMCZBcHBseUZ1bmN0aW9uO0YoLyUlZm9ybUdRJmluZml4RigvJSZmZW5jZUdGOC8lKnNlcGFyYXRvckdGOC8lJ2xzcGFjZUdRJDBlbUYoLyUncnNwYWNlR0ZbcC8lKXN0cmV0Y2h5R0Y4LyUqc3ltbWV0cmljR0Y4LyUobWF4c2l6ZUdRKWluZmluaXR5RigvJShtaW5zaXplR1EiMUYoLyUobGFyZ2VvcEdGOC8lLm1vdmFibGVsaW1pdHNHRjgvJSdhY2NlbnRHRjgvJTBmb250X3N0eWxlX25hbWVHRlgvJSVzaXplR0Y1LyUrZm9yZWdyb3VuZEdGRC8lK2JhY2tncm91bmRHRkctRiQ2JS1GX282M1EiKEYoL0Zjb1EncHJlZml4RigvRmZvRjtGZ28vRmpvUS50aGlubWF0aHNwYWNlRigvRl1wRl9yL0ZfcEY7RmBwRmJwRmVwRmhwRmpwRlxxRl5xRmBxRmJxRmRxLUYkNiMtRi02OVEqdW5kZWZpbmVkRihGMEYzRjZGOUY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ25GaW5GXG8tRl9vNjNRIilGKC9GY29RKHBvc3RmaXhGKEZdckZnb0Zeci9GXXBRMnZlcnl0aGlubWF0aHNwYWNlRihGYXJGYHBGYnBGZXBGaHBGanBGXHFGXnFGYHFGYnFGZHE3IyQiIiJJKnVuZGVmaW5lZEclKnByb3RlY3RlZEc=

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

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNiUtSSNtaUdGJTY5USFGKC8lJ2ZhbWlseUdRMFRpbWVzfk5ld35Sb21hbkYoLyUlc2l6ZUdRIzEyRigvJSVib2xkR1EmZmFsc2VGKC8lJ2l0YWxpY0dRJXRydWVGKC8lKnVuZGVybGluZUdGOC8lKnN1YnNjcmlwdEdGOC8lLHN1cGVyc2NyaXB0R0Y4LyUrZm9yZWdyb3VuZEdRKFswLDAsMF1GKC8lK2JhY2tncm91bmRHUS5bMjU1LDI1NSwyNTVdRigvJSdvcGFxdWVHRjgvJStleGVjdXRhYmxlR0Y7LyUpcmVhZG9ubHlHRjgvJSljb21wb3NlZEdGOC8lKmNvbnZlcnRlZEdGOC8lK2ltc2VsZWN0ZWRHRjgvJSxwbGFjZWhvbGRlckdGOC8lMGZvbnRfc3R5bGVfbmFtZUdRKTJEfklucHV0RigvJSptYXRoY29sb3JHRkQvJS9tYXRoYmFja2dyb3VuZEdGRy8lK2ZvbnRmYW1pbHlHRjIvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YoLyUpbWF0aHNpemVHRjUtRiQ2JS1GLTY5USZsaW1pdEYoRjBGM0Y2RjlGPEY+RkBGQkZFRkhGSkZMRk5GUEZSRlRGVkZZRmVuRmduRmluRlxvLUkjbW9HRiU2M1EwJkFwcGx5RnVuY3Rpb247RigvJSVmb3JtR1EmaW5maXhGKC8lJmZlbmNlR0Y4LyUqc2VwYXJhdG9yR0Y4LyUnbHNwYWNlR1EkMGVtRigvJSdyc3BhY2VHRmBwLyUpc3RyZXRjaHlHRjgvJSpzeW1tZXRyaWNHRjgvJShtYXhzaXplR1EpaW5maW5pdHlGKC8lKG1pbnNpemVHUSIxRigvJShsYXJnZW9wR0Y4LyUubW92YWJsZWxpbWl0c0dGOC8lJ2FjY2VudEdGOC8lMGZvbnRfc3R5bGVfbmFtZUdGWC8lJXNpemVHRjUvJStmb3JlZ3JvdW5kR0ZELyUrYmFja2dyb3VuZEdGRy1JKG1mZW5jZWRHRiU2Iy1GJDYoRiwtRiQ2JS1GLTY5USNRMUYoRjBGM0Y2RjlGPEY+RkBGQkZFRkhGSkZMRk5GUEZSRlRGVkZZRmVuRmduRmluRlxvRmNvLUZccjYjLUYkNiMtRi02OVEiaEYoRjBGM0Y2RjlGPEY+RkBGQkZFRkhGSkZMRk5GUEZSRlRGVkZZRmVuRmduRmluRlxvLUZkbzYzUSIsRihGZ29Gam8vRl1wRjtGXnAvRmJwUTN2ZXJ5dGhpY2ttYXRoc3BhY2VGKEZjcEZlcEZncEZqcEZdcUZfcUZhcUZjcUZlcUZncUZpcUZpci1GZG82M1EiPUYoRmdvRmpvRlxwL0ZfcFEvdGhpY2ttYXRoc3BhY2VGKC9GYnBGZnNGY3BGZXBGZ3BGanBGXXFGX3FGYXFGY3FGZXFGZ3FGaXEtSSNtbkdGJTY5USIwRihGMEYzRjYvRjpGOEY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ24vRmpuUSdub3JtYWxGKEZcb0YsNyMtSSZsaW1pdEc2JCUqcHJvdGVjdGVkR0YqNiQtSSNRMUdGKDYjSSJoR0YoL0ZodCIiIQ==

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNiUtSSZtZnJhY0dGJTYqLUkjbW5HRiU2OVEiMkYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y7LyUqdW5kZXJsaW5lR0Y7LyUqc3Vic2NyaXB0R0Y7LyUsc3VwZXJzY3JpcHRHRjsvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y7LyUrZXhlY3V0YWJsZUdGOy8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjsvJSpjb252ZXJ0ZWRHRjsvJStpbXNlbGVjdGVkR0Y7LyUscGxhY2Vob2xkZXJHRjsvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGRi8lL21hdGhiYWNrZ3JvdW5kR0ZJLyUrZm9udGZhbWlseUdGNS8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGOC1GMDY5USIzRihGM0Y2RjlGPEY+RkBGQkZERkdGSkZMRk5GUUZTRlVGV0ZZRmZuRmhuRmpuRlxvRl9vLyUubGluZXRoaWNrbmVzc0dRIjFGKC8lK2Rlbm9tYWxpZ25HUSdjZW50ZXJGKC8lKW51bWFsaWduR0Zpby8lKWJldmVsbGVkR0Y7LyUrZm9yZWdyb3VuZEdGRi8lK2JhY2tncm91bmRHRkktSSNtb0dGJTYzUTEmSW52aXNpYmxlVGltZXM7RigvJSVmb3JtR1EmaW5maXhGKC8lJmZlbmNlR0Y7LyUqc2VwYXJhdG9yR0Y7LyUnbHNwYWNlR1EkMGVtRigvJSdyc3BhY2VHRl9xLyUpc3RyZXRjaHlHRjsvJSpzeW1tZXRyaWNHRjsvJShtYXhzaXplR1EpaW5maW5pdHlGKC8lKG1pbnNpemVHUSIxRigvJShsYXJnZW9wR0Y7LyUubW92YWJsZWxpbWl0c0dGOy8lJ2FjY2VudEdGOy8lMGZvbnRfc3R5bGVfbmFtZUdGZW4vJSVzaXplR0Y4Rl5wRmBwLUYkNiMtSSZtc3FydEdGJTYlRmFvRl5wRmBwNyMsJComIyIiIyIiJCIiIilGYHMjRmFzRl9zRmFzRmFz

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5USwxLjE1NDcwMDUzOUYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjJCIrUjBxYTYhIio=

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

NiQtSSNtbkc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGKDY5USwwLjU3NzM1MDI2OUYoLyUnZmFtaWx5R1EwVGltZXN+TmV3flJvbWFuRigvJSVzaXplR1EjMTJGKC8lJWJvbGRHUSZmYWxzZUYoLyUnaXRhbGljR0Y1LyUqdW5kZXJsaW5lR0Y1LyUqc3Vic2NyaXB0R0Y1LyUsc3VwZXJzY3JpcHRHRjUvJStmb3JlZ3JvdW5kR1EqWzAsMCwyNTVdRigvJStiYWNrZ3JvdW5kR1EuWzI1NSwyNTUsMjU1XUYoLyUnb3BhcXVlR0Y1LyUrZXhlY3V0YWJsZUdGNS8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjUvJSpjb252ZXJ0ZWRHRjUvJStpbXNlbGVjdGVkR0Y1LyUscGxhY2Vob2xkZXJHRjUvJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lKm1hdGhjb2xvckdGQC8lL21hdGhiYWNrZ3JvdW5kR0ZDLyUrZm9udGZhbWlseUdGLy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRigvJSltYXRoc2l6ZUdGMjcjJCIqcC1OeCYhIio=

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