跳到正文

文华财经缠论指标公式:自动画笔、线段与中枢 ​

想在文华财经 WH6 电脑版主图上自动画笔、线段和中枢,可以下载本页自行编写的近似缠论指标公式。麦语言 TXT 源码免费提供,可查看、修改,无需 DLL;分型、笔、线段和中枢可以分别开关显示。

下方提供源码下载、导入步骤和实际截图,并说明本版近似规则及其与 Struct Guide 网页插件的区别。需要在网页上画线,可查看网页版方案。

下载文华财经近似缠论公式 ​

免费下载 WH6 麦语言 TXT 源码

v1.0.0 · 2026年10月12日 · 约81KB · 无需注册。 文件为含中文注释的 UTF-8 文本,下载后复制全文到公式编辑器;导入步骤见下文。

用户已在 WH6 电脑版 V6.8.950、上证指数日线验证可运行,并提供了实际效果图。其他版本、手机版及云端指标未验证。本公式使用未来函数,历史标注可能随数据更新而变化。

为什么叫“近似缠论公式”? ​

为适应 WH6 麦语言环境的公式长度限制,并控制计算展开的规模,本版沿用通达信近似缠论公式的局部处理方式,针对麦语言重写端点定位与绘图。本页公式与 Struct Guide 浏览器插件的处理流程不同,具体区别如下。

结构本页 WH6 近似公式的规则Struct Guide 浏览器插件的规则
包含与分型每个合并组最多5根原始 K 线;比较三个已结束的有效组,按时间筛选不共用组的分型,标在中间组末根按本站公开规则处理 K 线合并,分型坐标映射到原始极值来源的 K 线处
笔默认在40根范围内整理端点,最多12轮;按合并组末根位置计算间隔严格笔与宽松笔分别按标准 K 线、原始极值来源计数,并维护候选端点与确认依据
线段按最近笔端点的高低变化分组,取组内极值,再检查三笔起始与共同区间按特征序列、缺口后的第二序列及第一笔破坏后的成段确认条件检查结束点
中枢局部三段分组后固定上下沿,按区间交叠和分组条件延伸、结束按已确认线段、成员归属及返回条件检查延伸与新区间

两者的中枢都使用线段覆盖的原始 K 线最高、最低价,并包含连接端点;但线段和成员选择不同,矩形范围也可能不同。本公式不设线段、中枢总个数上限,尾部待确认线段不参与中枢计算。

这些是本版的实现取舍,不代表麦语言的能力上限,也不以图形数量评价两种方式。

想在网页上自动画线?使用 Struct Guide ​

Struct Guide 是浏览器插件,在适配的行情网页原有 K 线上叠加分型、笔、线段和中枢。可切换严格笔/宽松笔,笔和线段以实线、虚线区分已确认与待确认状态,并使用结构快照与回放保存和回看结构变化。具体计算条件见画线规则与参数总览。

安装 Struct Guide 网页画线插件

查看期货时,可先核对新浪财经兼容范围,再按新浪财经缠论画线教程打开对应网页。查看其他市场可查支持网站与周期。

公式在 WH6 中使用客户端数据;插件在浏览器中使用适配网页已加载的数据。 插件不能安装进文华财经,也不转接或同步客户端图表。需要留在 WH6 中可独立使用本页公式;需要网页规则与快照回放可选择插件。

文华财经自动画笔、线段和中枢:实测效果与网页方案对照 ​

两图均展示上证指数日线,分别使用 WH6 近似公式和 Struct Guide 浏览器插件,点击可放大。

文华财经 WH6:近似公式的上证指数日线显示用户提供的运行截图:WH6 V6.8.950,上证指数日线。红绿线为近似线段,紫色线框为中枢;仅展示该环境下的显示效果。
文华财经 WH6:近似公式的上证指数日线显示

蓝色细线为笔,上行线段为红色、下行线段为绿色,中枢为紫色线框、不填充;方向和颜色仅用于标识结构。实线与虚线表示本公式的近似确认状态,不等同于插件的确认流程。截图展示一次运行效果,不代表所有输入均已验证。

同花顺网页:Struct Guide 的上证指数日线显示插件 v2.1.2,宽松笔、全部分型设置;分型图层关闭,笔、线段和中枢图层开启。结构图层由 Struct Guide 绘制。
同花顺网页:Struct Guide 的上证指数日线显示

插件图来自同花顺网页,使用宽松笔模式;分型图层关闭,笔、线段和中枢图层开启。两边的数据来源、复权、历史范围及计算设置尚未逐项对齐,仅展示各自的显示效果,不作为相同输入下的逐项验证,也不能仅凭外观判断某处差异的原因。

麦语言公式怎么导入 WH6? ​

  1. 下载 TXT,用支持 UTF-8 的文本编辑器打开,复制全文。
  2. 在 WH6 新建自定义指标,选择 K线附属指标,输入未使用的名称,例如 SG近似缠论。
  3. 粘贴源码并执行编译检查,通过后保存,加载到 K 线主图。

这是源码文本,不是打包指标文件。替换旧版时先清空编辑器,避免两份代码叠在一起;不要把网页正文一并粘贴。

图层开关与参数
设置默认值作用
SGSF1分型:红色下箭头、绿色上箭头
SGSP1笔:蓝色细线
SGSS1线段:红绿连线
SGSZ1中枢:紫色线框
SGMG4两端分型所在合并组末根的原始 K 线编号差下限;小于4按4处理
SGEW40笔端点整理的单轮范围,以原始 K 线根数计;小于4按4处理

前四项设为0可隐藏图层,计算仍继续。SGMG、SGEW影响计算,不是严格笔/宽松笔切换;SGEW也不是一笔最大长度。各结构的局部规则可对照通达信近似缠论公式的实现说明,两份源码不能直接跨客户端粘贴。

常见问题 ​

有文华财经缠论自动画笔、画线段的公式源码吗? ​

有,上方下载的同一份 WH6 麦语言源码包含笔和线段,无需另装两份指标。SGSP 控制笔、SGSS 控制线段,设为1显示、0隐藏;如果只想看笔和线段,可将分型开关 SGSF、中枢开关 SGSZ 设为0。

本版按局部近似规则整理笔端点、划分线段,不提供插件的严格笔/宽松笔切换,具体处理方式见近似实现说明。下载的是本站自行编写的公式,不是第三方或网络流传版本。

有文华财经缠论中枢指标吗?可以单独显示中枢吗? ​

有,中枢包含在同一份公式中,SGSZ 设为1即可显示紫色线框。若只显示中枢,可将 SGSF、SGSP、SGSS 设为0;这些开关只隐藏图层,笔和线段的计算仍继续。

本版中枢基于局部线段分组,使用线段覆盖的原始 K 线极值检查区间交叠、延伸和结束,尾部待确认线段不参与计算。它不是插件完整中枢流程的复现;历史数据不足或条件未满足时,也可能没有中枢框。实际显示见上方截图。

使用未来函数吗?历史画线会变化吗? ​

会。源码使用 BACKSET、REFX 回填历史标记、取得后续端点依据。新增、修订或补载数据,以及修改参数,都可能改变历史显示。端点所在的 K 线位置,不等于取得确认依据的时间。 插件的待确认对象也会更新,历史数据或设置变化时相关结构可重算。

可以免费使用、修改吗? ​

可以,公式可独立使用,无需安装浏览器插件。修改后请保留版本与参数记录。

支持 WH7、WH8、手机版或云端指标吗? ​

本页仅记录 WH6 电脑版 V6.8.950 的运行验证,尚未验证其他环境,不能直接视为兼容。

通达信缠论公式能直接粘贴到文华财经吗? ​

不能把两种语言直接视为兼容。需要通达信电脑版源码请使用通达信近似缠论公式;本页提供的是单独适配的麦语言版本。

编译报错、没有连线或没有中枢怎么办? ​

先核对文件头是否为 v1.0.0,源码是否完整,是否选择 K线附属指标并开启图层。历史数据不足、合并组无效或连接条件不满足时,可能没有对应图形;中枢须有三条有效近似线段的覆盖区间严格重叠,尾部虚线不计入。

仍有问题时,将客户端版本、错误句与行号、品种、周期、历史范围、参数及截图发至 structguide@outlook.com。

同一品种在公式与网页插件中画得不同,怎么核对? ​

先记录代码或具体合约、数据来源、周期、时段、复权、历史范围和参数,再对照上表的计算规则。两边输入未经对齐,不能只凭截图确定差异原因。检查顺序见画线差异核对顺序。

Struct Guide 插件能读取文华财经的数据,或安装进客户端吗? ​

不能。插件只处理已适配行情网页中加载的 K 线数据。网页 K 线加载失败时,插件不会改用文华财经客户端作为数据源。

查看完整麦语言源码 ​

展开查看文华财经近似缠论公式源码
txt
// Struct Guide 文华财经近似缠论公式 v1.0.0 — 2026-10-12
// 适用:WH6 电脑版,K线附属指标;用户已验证 V6.8.950 上证指数日线可运行。
// Struct Guide 独立编写,无需 DLL,与文华财经无隶属或合作关系。
// 仅用于结构学习与复盘,不提供投资建议;只输出结构端点、连线与区间。
// 含 BACKSET、REFX 未来函数;历史标记可回写,不能视为当时已知结果。
// 包含组最多5根;端点范围40根;笔与线段各整理12轮。
// 线段采用局部分组;不包含插件的特征序列与第二序列流程。
// 中枢取覆盖原始K线极值并包含端点,初始上下沿固定,无固定个数上限。
// 请新建K线附属指标粘贴全文;其他版本、手机版及云端指标未验证。
// 自定义变量使用 SG 前缀,减少与内置名称冲突。
// 本版保留已验证的计算与绘图代码;切换环境后请重新核对。
SGSF:=1;
SGSP:=1;
SGSS:=1;
SGSZ:=1;
SGMG:=4;
SGEW:=40;
SGBN:=BARPOS;
SGTMP1:=SGBN>1;
SGTMP2:=REFWH(H,1);
SGTMP3:=REFWH(L,1);
SGCI:=SGTMP1 AND (H>=SGTMP2 AND L<=SGTMP3 OR H<=SGTMP2 AND L>=SGTMP3);
SGR0GS:=SGBN=1 OR SGCI=0;
SGR0GR:=IFELSE(COUNT(SGR0GS,0)>0,BARSLAST(SGR0GS),SGBN)+1;
SGR0NR:=MIN(SGR0GR,5);
SGTMP4:=SGR0NR-1;
SGR0AH:=REFWH(H,SGTMP4);
SGR0AL:=REFWH(L,SGTMP4);
SGTMP5:=SGR0NR-2;
SGTMP6:=MAX(SGTMP5,0);
SGR0BH:=REFWH(H,SGTMP6);
SGR0BL:=REFWH(L,SGTMP6);
SGR0GU:=IFELSE(SGBN>SGR0GR,SGR0AH>REFWH(H,SGR0NR),IFELSE(SGR0BH+SGR0BL<>SGR0AH+SGR0AL,SGR0BH+SGR0BL>SGR0AH+SGR0AL,REFWH(C,SGTMP6)>=REFWH(C,SGTMP4)));
SGTMP7:=MAX(SGTMP4,1);
SGR0WH:=IFELSE(SGR0GU,HHV(SGTMP2,SGTMP7),LLV(SGTMP2,SGTMP7));
SGR0WL:=IFELSE(SGR0GU,HHV(SGTMP3,SGTMP7),LLV(SGTMP3,SGTMP7));
SGR0BF:=SGR0GR>1 AND (SGR0WH>=H AND SGR0WL<=L OR SGR0WH<=H AND SGR0WL>=L)=0;
SGR1GS:=SGR0GS OR SGR0BF AND SGR0GR<=5;
SGR1GR:=IFELSE(COUNT(SGR1GS,0)>0,BARSLAST(SGR1GS),SGBN)+1;
SGR1NR:=MIN(SGR1GR,5);
SGTMP8:=SGR1NR-1;
SGR1AH:=REFWH(H,SGTMP8);
SGR1AL:=REFWH(L,SGTMP8);
SGTMP9:=SGR1NR-2;
SGTMP10:=MAX(SGTMP9,0);
SGR1BH:=REFWH(H,SGTMP10);
SGR1BL:=REFWH(L,SGTMP10);
SGR1GU:=IFELSE(SGBN>SGR1GR,SGR1AH>REFWH(H,SGR1NR),IFELSE(SGR1BH+SGR1BL<>SGR1AH+SGR1AL,SGR1BH+SGR1BL>SGR1AH+SGR1AL,REFWH(C,SGTMP10)>=REFWH(C,SGTMP8)));
SGTMP11:=MAX(SGTMP8,1);
SGR1WH:=IFELSE(SGR1GU,HHV(SGTMP2,SGTMP11),LLV(SGTMP2,SGTMP11));
SGR1WL:=IFELSE(SGR1GU,HHV(SGTMP3,SGTMP11),LLV(SGTMP3,SGTMP11));
SGR1BF:=SGR1GR>1 AND (SGR1WH>=H AND SGR1WL<=L OR SGR1WH<=H AND SGR1WL>=L)=0;
SGR2GS:=SGR1GS OR SGR1BF AND SGR1GR<=5;
SGR2GR:=IFELSE(COUNT(SGR2GS,0)>0,BARSLAST(SGR2GS),SGBN)+1;
SGR2NR:=MIN(SGR2GR,5);
SGTMP12:=SGR2NR-1;
SGR2AH:=REFWH(H,SGTMP12);
SGR2AL:=REFWH(L,SGTMP12);
SGTMP13:=SGR2NR-2;
SGTMP14:=MAX(SGTMP13,0);
SGR2BH:=REFWH(H,SGTMP14);
SGR2BL:=REFWH(L,SGTMP14);
SGR2GU:=IFELSE(SGBN>SGR2GR,SGR2AH>REFWH(H,SGR2NR),IFELSE(SGR2BH+SGR2BL<>SGR2AH+SGR2AL,SGR2BH+SGR2BL>SGR2AH+SGR2AL,REFWH(C,SGTMP14)>=REFWH(C,SGTMP12)));
SGTMP15:=MAX(SGTMP12,1);
SGR2WH:=IFELSE(SGR2GU,HHV(SGTMP2,SGTMP15),LLV(SGTMP2,SGTMP15));
SGR2WL:=IFELSE(SGR2GU,HHV(SGTMP3,SGTMP15),LLV(SGTMP3,SGTMP15));
SGR2BF:=SGR2GR>1 AND (SGR2WH>=H AND SGR2WL<=L OR SGR2WH<=H AND SGR2WL>=L)=0;
SGR3GS:=SGR2GS OR SGR2BF AND SGR2GR<=5;
SGR3GR:=IFELSE(COUNT(SGR3GS,0)>0,BARSLAST(SGR3GS),SGBN)+1;
SGR3NR:=MIN(SGR3GR,5);
SGTMP16:=SGR3NR-1;
SGR3AH:=REFWH(H,SGTMP16);
SGR3AL:=REFWH(L,SGTMP16);
SGTMP17:=SGR3NR-2;
SGTMP18:=MAX(SGTMP17,0);
SGR3BH:=REFWH(H,SGTMP18);
SGR3BL:=REFWH(L,SGTMP18);
SGR3GU:=IFELSE(SGBN>SGR3GR,SGR3AH>REFWH(H,SGR3NR),IFELSE(SGR3BH+SGR3BL<>SGR3AH+SGR3AL,SGR3BH+SGR3BL>SGR3AH+SGR3AL,REFWH(C,SGTMP18)>=REFWH(C,SGTMP16)));
SGTMP19:=MAX(SGTMP16,1);
SGR3WH:=IFELSE(SGR3GU,HHV(SGTMP2,SGTMP19),LLV(SGTMP2,SGTMP19));
SGR3WL:=IFELSE(SGR3GU,HHV(SGTMP3,SGTMP19),LLV(SGTMP3,SGTMP19));
SGR3BF:=SGR3GR>1 AND (SGR3WH>=H AND SGR3WL<=L OR SGR3WH<=H AND SGR3WL>=L)=0;
SGGS:=SGR3GS OR SGR3BF AND SGR3GR<=5;
SGGN:=COUNT(SGGS,0);
SGGR:=IFELSE(COUNT(SGGS,0)>0,BARSLAST(SGGS),SGBN)+1;
SGNR:=MIN(SGGR,5);
SGTMP20:=SGNR-1;
SGAH:=REFWH(H,SGTMP20);
SGAL:=REFWH(L,SGTMP20);
SGTMP21:=SGNR-2;
SGTMP22:=MAX(SGTMP21,0);
SGBH:=REFWH(H,SGTMP22);
SGBL:=REFWH(L,SGTMP22);
SGGU:=IFELSE(SGBN>SGGR,SGAH>REFWH(H,SGNR),IFELSE(SGBH+SGBL<>SGAH+SGAL,SGBH+SGBL>SGAH+SGAL,REFWH(C,SGTMP22)>=REFWH(C,SGTMP20)));
SGRHH:=IFELSE(SGGU,HHV(H,SGNR),LLV(H,SGNR));
SGRLL:=IFELSE(SGGU,HHV(L,SGNR),LLV(L,SGNR));
SGTMP23:=MAX(SGTMP20,1);
SGWH:=IFELSE(SGGU,HHV(SGTMP2,SGTMP23),LLV(SGTMP2,SGTMP23));
SGWL:=IFELSE(SGGU,HHV(SGTMP3,SGTMP23),LLV(SGTMP3,SGTMP23));
SGBF:=SGGR>1 AND (SGWH>=H AND SGWL<=L OR SGWH<=H AND SGWL>=L)=0;
SGGV:=SGGR<=5 AND COUNT(SGBF,SGNR)=0;
SGTMP24:=SGGS AND SGTMP1;
SGG0A:=SGTMP24 AND MOD(SGGN,2)=0;
SGG0B:=SGTMP24 AND MOD(SGGN,2)=1;
SGG0E:=BACKSET(SGG0A,2)-BACKSET(SGG0A,1)>0 OR BACKSET(SGG0B,2)-BACKSET(SGG0B,1)>0;
SGG0H:=SGRHH;
SGG0L:=SGRLL;
SGG0S:=SGGR;
SGG1N:=COUNT(SGG0E,0);
SGTMP25:=SGBN-1;
SGG1D:=MIN(IFELSE(COUNT(REFWH(SGG0E,1),0)>0,BARSLAST(REFWH(SGG0E,1)),SGBN)+1,SGTMP25);
SGG1A:=MIN(SGG1D+REFWH(SGG1D,SGG1D),SGTMP25);
SGG1W:=SGG1D+REFWH(SGG0S,SGG1D);
SGTMP26:=REFWH(SGG0H,SGG1D);
SGTMP27:=REFWH(SGG0L,SGG1D);
SGG1I:=SGG0H>=SGTMP26 AND SGG0L<=SGTMP27 OR SGG0H<=SGTMP26 AND SGG0L>=SGTMP27;
SGG1M:=SGG0E AND SGG1N>=2 AND MOD(SGG1N-0,2)=0 AND SGGV AND REFWH(SGGV,SGG1D) AND SGG1W<=5 AND SGG1I;
SGTMP28:=SGG0H+SGG0L;
SGTMP29:=REFWH(SGTMP28,SGG1D);
SGG1U:=IFELSE(SGG1N>=3,SGTMP26>=REFWH(SGG0H,SGG1A),IFELSE(SGTMP28<>SGTMP29,SGTMP28>SGTMP29,C>=REFWH(C,SGG1D)));
SGG1T:=BACKSET(SGG1M,2)-BACKSET(SGG1M,1)>0;
SGG1B:=BACKSET(SGG1T,IFELSE(COUNT(SGG0E,0)>0,BARSLAST(SGG0E),SGBN)+1);
SGG1E:=SGG0E AND SGG1B=0;
SGG1H:=IFELSE(SGG1M,IFELSE(SGG1U,MAX(SGG0H,SGTMP26),MIN(SGG0H,SGTMP26)),SGG0H);
SGG1L:=IFELSE(SGG1M,IFELSE(SGG1U,MAX(SGG0L,SGTMP27),MIN(SGG0L,SGTMP27)),SGG0L);
SGG1S:=IFELSE(SGG1M,SGG1W,SGG0S);
SGG2N:=COUNT(SGG1E,0);
SGG2D:=MIN(IFELSE(COUNT(REFWH(SGG1E,1),0)>0,BARSLAST(REFWH(SGG1E,1)),SGBN)+1,SGTMP25);
SGG2A:=MIN(SGG2D+REFWH(SGG2D,SGG2D),SGTMP25);
SGG2W:=SGG2D+REFWH(SGG1S,SGG2D);
SGTMP30:=REFWH(SGG1H,SGG2D);
SGTMP31:=REFWH(SGG1L,SGG2D);
SGG2I:=SGG1H>=SGTMP30 AND SGG1L<=SGTMP31 OR SGG1H<=SGTMP30 AND SGG1L>=SGTMP31;
SGG2M:=SGG1E AND SGG2N>=3 AND MOD(SGG2N-1,2)=0 AND SGGV AND REFWH(SGGV,SGG2D) AND SGG2W<=5 AND SGG2I;
SGTMP32:=SGG1H+SGG1L;
SGTMP33:=REFWH(SGTMP32,SGG2D);
SGG2U:=IFELSE(SGG2N>=3,SGTMP30>=REFWH(SGG1H,SGG2A),IFELSE(SGTMP32<>SGTMP33,SGTMP32>SGTMP33,C>=REFWH(C,SGG2D)));
SGG2T:=BACKSET(SGG2M,2)-BACKSET(SGG2M,1)>0;
SGG2B:=BACKSET(SGG2T,IFELSE(COUNT(SGG1E,0)>0,BARSLAST(SGG1E),SGBN)+1);
SGG2E:=SGG1E AND SGG2B=0;
SGG2H:=IFELSE(SGG2M,IFELSE(SGG2U,MAX(SGG1H,SGTMP30),MIN(SGG1H,SGTMP30)),SGG1H);
SGG2L:=IFELSE(SGG2M,IFELSE(SGG2U,MAX(SGG1L,SGTMP31),MIN(SGG1L,SGTMP31)),SGG1L);
SGG2S:=IFELSE(SGG2M,SGG2W,SGG1S);
SGG3N:=COUNT(SGG2E,0);
SGG3D:=MIN(IFELSE(COUNT(REFWH(SGG2E,1),0)>0,BARSLAST(REFWH(SGG2E,1)),SGBN)+1,SGTMP25);
SGG3A:=MIN(SGG3D+REFWH(SGG3D,SGG3D),SGTMP25);
SGG3W:=SGG3D+REFWH(SGG2S,SGG3D);
SGTMP34:=REFWH(SGG2H,SGG3D);
SGTMP35:=REFWH(SGG2L,SGG3D);
SGG3I:=SGG2H>=SGTMP34 AND SGG2L<=SGTMP35 OR SGG2H<=SGTMP34 AND SGG2L>=SGTMP35;
SGG3M:=SGG2E AND SGG3N>=2 AND MOD(SGG3N-0,2)=0 AND SGGV AND REFWH(SGGV,SGG3D) AND SGG3W<=5 AND SGG3I;
SGTMP36:=SGG2H+SGG2L;
SGTMP37:=REFWH(SGTMP36,SGG3D);
SGG3U:=IFELSE(SGG3N>=3,SGTMP34>=REFWH(SGG2H,SGG3A),IFELSE(SGTMP36<>SGTMP37,SGTMP36>SGTMP37,C>=REFWH(C,SGG3D)));
SGG3T:=BACKSET(SGG3M,2)-BACKSET(SGG3M,1)>0;
SGG3B:=BACKSET(SGG3T,IFELSE(COUNT(SGG2E,0)>0,BARSLAST(SGG2E),SGBN)+1);
SGG3E:=SGG2E AND SGG3B=0;
SGG3H:=IFELSE(SGG3M,IFELSE(SGG3U,MAX(SGG2H,SGTMP34),MIN(SGG2H,SGTMP34)),SGG2H);
SGG3L:=IFELSE(SGG3M,IFELSE(SGG3U,MAX(SGG2L,SGTMP35),MIN(SGG2L,SGTMP35)),SGG2L);
SGG3S:=IFELSE(SGG3M,SGG3W,SGG2S);
SGG4N:=COUNT(SGG3E,0);
SGG4D:=MIN(IFELSE(COUNT(REFWH(SGG3E,1),0)>0,BARSLAST(REFWH(SGG3E,1)),SGBN)+1,SGTMP25);
SGG4A:=MIN(SGG4D+REFWH(SGG4D,SGG4D),SGTMP25);
SGG4W:=SGG4D+REFWH(SGG3S,SGG4D);
SGTMP38:=REFWH(SGG3H,SGG4D);
SGTMP39:=REFWH(SGG3L,SGG4D);
SGG4I:=SGG3H>=SGTMP38 AND SGG3L<=SGTMP39 OR SGG3H<=SGTMP38 AND SGG3L>=SGTMP39;
SGG4M:=SGG3E AND SGG4N>=3 AND MOD(SGG4N-1,2)=0 AND SGGV AND REFWH(SGGV,SGG4D) AND SGG4W<=5 AND SGG4I;
SGTMP40:=SGG3H+SGG3L;
SGTMP41:=REFWH(SGTMP40,SGG4D);
SGG4U:=IFELSE(SGG4N>=3,SGTMP38>=REFWH(SGG3H,SGG4A),IFELSE(SGTMP40<>SGTMP41,SGTMP40>SGTMP41,C>=REFWH(C,SGG4D)));
SGG4T:=BACKSET(SGG4M,2)-BACKSET(SGG4M,1)>0;
SGG4B:=BACKSET(SGG4T,IFELSE(COUNT(SGG3E,0)>0,BARSLAST(SGG3E),SGBN)+1);
SGG4E:=SGG3E AND SGG4B=0;
SGG4H:=IFELSE(SGG4M,IFELSE(SGG4U,MAX(SGG3H,SGTMP38),MIN(SGG3H,SGTMP38)),SGG3H);
SGG4L:=IFELSE(SGG4M,IFELSE(SGG4U,MAX(SGG3L,SGTMP39),MIN(SGG3L,SGTMP39)),SGG3L);
SGG4S:=IFELSE(SGG4M,SGG4W,SGG3S);
SGG5N:=COUNT(SGG4E,0);
SGG5D:=MIN(IFELSE(COUNT(REFWH(SGG4E,1),0)>0,BARSLAST(REFWH(SGG4E,1)),SGBN)+1,SGTMP25);
SGG5A:=MIN(SGG5D+REFWH(SGG5D,SGG5D),SGTMP25);
SGG5W:=SGG5D+REFWH(SGG4S,SGG5D);
SGTMP42:=REFWH(SGG4H,SGG5D);
SGTMP43:=REFWH(SGG4L,SGG5D);
SGG5I:=SGG4H>=SGTMP42 AND SGG4L<=SGTMP43 OR SGG4H<=SGTMP42 AND SGG4L>=SGTMP43;
SGG5M:=SGG4E AND SGG5N>=2 AND MOD(SGG5N-0,2)=0 AND SGGV AND REFWH(SGGV,SGG5D) AND SGG5W<=5 AND SGG5I;
SGTMP44:=SGG4H+SGG4L;
SGTMP45:=REFWH(SGTMP44,SGG5D);
SGG5U:=IFELSE(SGG5N>=3,SGTMP42>=REFWH(SGG4H,SGG5A),IFELSE(SGTMP44<>SGTMP45,SGTMP44>SGTMP45,C>=REFWH(C,SGG5D)));
SGG5T:=BACKSET(SGG5M,2)-BACKSET(SGG5M,1)>0;
SGG5B:=BACKSET(SGG5T,IFELSE(COUNT(SGG4E,0)>0,BARSLAST(SGG4E),SGBN)+1);
SGG5E:=SGG4E AND SGG5B=0;
SGG5H:=IFELSE(SGG5M,IFELSE(SGG5U,MAX(SGG4H,SGTMP42),MIN(SGG4H,SGTMP42)),SGG4H);
SGG5L:=IFELSE(SGG5M,IFELSE(SGG5U,MAX(SGG4L,SGTMP43),MIN(SGG4L,SGTMP43)),SGG4L);
SGG5S:=IFELSE(SGG5M,SGG5W,SGG4S);
SGG6N:=COUNT(SGG5E,0);
SGG6D:=MIN(IFELSE(COUNT(REFWH(SGG5E,1),0)>0,BARSLAST(REFWH(SGG5E,1)),SGBN)+1,SGTMP25);
SGG6A:=MIN(SGG6D+REFWH(SGG6D,SGG6D),SGTMP25);
SGG6W:=SGG6D+REFWH(SGG5S,SGG6D);
SGTMP46:=REFWH(SGG5H,SGG6D);
SGTMP47:=REFWH(SGG5L,SGG6D);
SGG6I:=SGG5H>=SGTMP46 AND SGG5L<=SGTMP47 OR SGG5H<=SGTMP46 AND SGG5L>=SGTMP47;
SGG6M:=SGG5E AND SGG6N>=3 AND MOD(SGG6N-1,2)=0 AND SGGV AND REFWH(SGGV,SGG6D) AND SGG6W<=5 AND SGG6I;
SGTMP48:=SGG5H+SGG5L;
SGTMP49:=REFWH(SGTMP48,SGG6D);
SGG6U:=IFELSE(SGG6N>=3,SGTMP46>=REFWH(SGG5H,SGG6A),IFELSE(SGTMP48<>SGTMP49,SGTMP48>SGTMP49,C>=REFWH(C,SGG6D)));
SGG6T:=BACKSET(SGG6M,2)-BACKSET(SGG6M,1)>0;
SGG6B:=BACKSET(SGG6T,IFELSE(COUNT(SGG5E,0)>0,BARSLAST(SGG5E),SGBN)+1);
SGG6E:=SGG5E AND SGG6B=0;
SGG6H:=IFELSE(SGG6M,IFELSE(SGG6U,MAX(SGG5H,SGTMP46),MIN(SGG5H,SGTMP46)),SGG5H);
SGG6L:=IFELSE(SGG6M,IFELSE(SGG6U,MAX(SGG5L,SGTMP47),MIN(SGG5L,SGTMP47)),SGG5L);
SGG6S:=IFELSE(SGG6M,SGG6W,SGG5S);
SGG7N:=COUNT(SGG6E,0);
SGG7D:=MIN(IFELSE(COUNT(REFWH(SGG6E,1),0)>0,BARSLAST(REFWH(SGG6E,1)),SGBN)+1,SGTMP25);
SGG7A:=MIN(SGG7D+REFWH(SGG7D,SGG7D),SGTMP25);
SGG7W:=SGG7D+REFWH(SGG6S,SGG7D);
SGTMP50:=REFWH(SGG6H,SGG7D);
SGTMP51:=REFWH(SGG6L,SGG7D);
SGG7I:=SGG6H>=SGTMP50 AND SGG6L<=SGTMP51 OR SGG6H<=SGTMP50 AND SGG6L>=SGTMP51;
SGG7M:=SGG6E AND SGG7N>=2 AND MOD(SGG7N-0,2)=0 AND SGGV AND REFWH(SGGV,SGG7D) AND SGG7W<=5 AND SGG7I;
SGTMP52:=SGG6H+SGG6L;
SGTMP53:=REFWH(SGTMP52,SGG7D);
SGG7U:=IFELSE(SGG7N>=3,SGTMP50>=REFWH(SGG6H,SGG7A),IFELSE(SGTMP52<>SGTMP53,SGTMP52>SGTMP53,C>=REFWH(C,SGG7D)));
SGG7T:=BACKSET(SGG7M,2)-BACKSET(SGG7M,1)>0;
SGG7B:=BACKSET(SGG7T,IFELSE(COUNT(SGG6E,0)>0,BARSLAST(SGG6E),SGBN)+1);
SGG7E:=SGG6E AND SGG7B=0;
SGG7H:=IFELSE(SGG7M,IFELSE(SGG7U,MAX(SGG6H,SGTMP50),MIN(SGG6H,SGTMP50)),SGG6H);
SGG7L:=IFELSE(SGG7M,IFELSE(SGG7U,MAX(SGG6L,SGTMP51),MIN(SGG6L,SGTMP51)),SGG6L);
SGG7S:=IFELSE(SGG7M,SGG7W,SGG6S);
SGG8N:=COUNT(SGG7E,0);
SGG8D:=MIN(IFELSE(COUNT(REFWH(SGG7E,1),0)>0,BARSLAST(REFWH(SGG7E,1)),SGBN)+1,SGTMP25);
SGG8A:=MIN(SGG8D+REFWH(SGG8D,SGG8D),SGTMP25);
SGG8W:=SGG8D+REFWH(SGG7S,SGG8D);
SGTMP54:=REFWH(SGG7H,SGG8D);
SGTMP55:=REFWH(SGG7L,SGG8D);
SGG8I:=SGG7H>=SGTMP54 AND SGG7L<=SGTMP55 OR SGG7H<=SGTMP54 AND SGG7L>=SGTMP55;
SGG8M:=SGG7E AND SGG8N>=3 AND MOD(SGG8N-1,2)=0 AND SGGV AND REFWH(SGGV,SGG8D) AND SGG8W<=5 AND SGG8I;
SGTMP56:=SGG7H+SGG7L;
SGTMP57:=REFWH(SGTMP56,SGG8D);
SGG8U:=IFELSE(SGG8N>=3,SGTMP54>=REFWH(SGG7H,SGG8A),IFELSE(SGTMP56<>SGTMP57,SGTMP56>SGTMP57,C>=REFWH(C,SGG8D)));
SGG8T:=BACKSET(SGG8M,2)-BACKSET(SGG8M,1)>0;
SGG8B:=BACKSET(SGG8T,IFELSE(COUNT(SGG7E,0)>0,BARSLAST(SGG7E),SGBN)+1);
SGG8E:=SGG7E AND SGG8B=0;
SGG8H:=IFELSE(SGG8M,IFELSE(SGG8U,MAX(SGG7H,SGTMP54),MIN(SGG7H,SGTMP54)),SGG7H);
SGG8L:=IFELSE(SGG8M,IFELSE(SGG8U,MAX(SGG7L,SGTMP55),MIN(SGG7L,SGTMP55)),SGG7L);
SGGE:=SGG8E;
SGMH:=SGG8H;
SGML:=SGG8L;
SGTMP58:=COUNT(SGGE,0);
SGGC:=SGTMP58;
SGQ1:=MIN(IFELSE(COUNT(REFWH(SGGE,1),0)>0,BARSLAST(REFWH(SGGE,1)),SGBN)+1,SGTMP25);
SGQ2:=MIN(SGQ1+REFWH(SGQ1,SGQ1),SGTMP25);
SGCH:=REFWH(SGMH,SGQ1);
SGCL:=REFWH(SGML,SGQ1);
SGLH:=REFWH(SGMH,SGQ2);
SGLL:=REFWH(SGML,SGQ2);
SGBC:=SGGE AND SGGC>=2 AND (SGMH>=SGCH AND SGML<=SGCL OR SGMH<=SGCH AND SGML>=SGCL);
SGGX:=SGGE AND (SGGV=0 OR SGBC);
SGOK:=SGGE AND SGGC>=3 AND SGGV AND REFWH(SGGV,SGQ1) AND REFWH(SGGV,SGQ2);
SGT0:=SGOK AND SGCH>SGLH AND SGCH>SGMH AND SGCL>SGLL AND SGCL>SGML;
SGB0:=SGOK AND SGCH<SGLH AND SGCH<SGMH AND SGCL<SGLL AND SGCL<SGML;
SGTT:=BACKSET(SGT0,2)-BACKSET(SGT0,1)>0;
SGBT:=BACKSET(SGB0,2)-BACKSET(SGB0,1)>0;
SGTMP59:=SGGE=0;
SGTMP60:=SGTT AND SGTMP59;
SGTMP61:=SGTMP58>0;
SGTMP62:=BARSLAST(SGGE);
SGTMP63:=IFELSE(SGTMP61,SGTMP62,SGBN);
SGTMP64:=SGTMP63+1;
SGTMP65:=MAX(SGTMP63,1);
SGFRT:=SGTT AND SGGE OR BACKSET(SGTMP60,SGTMP64)-BACKSET(SGTMP60,SGTMP65)>0;
SGTMP66:=SGBT AND SGTMP59;
SGFRB:=SGBT AND SGGE OR BACKSET(SGTMP66,SGTMP64)-BACKSET(SGTMP66,SGTMP65)>0;
SGF0A:=IFELSE(SGFRT OR SGFRB,2,0);
SGF0B:=IFELSE(SGGE,0,1);
SGF0C:=IFELSE(SGGE,1,2);
SGF1D:=MIN(1,SGTMP25);
SGTMP67:=SGBN<=1;
SGF1A:=IFELSE(SGTMP67,SGF0A,IFELSE(REFWH(SGF0A,SGF1D)=0,SGF0A,IFELSE(REFWH(SGF0A,SGF1D)=1,SGF0B,SGF0C)));
SGF1B:=IFELSE(SGTMP67,SGF0B,IFELSE(REFWH(SGF0B,SGF1D)=0,SGF0A,IFELSE(REFWH(SGF0B,SGF1D)=1,SGF0B,SGF0C)));
SGF1C:=IFELSE(SGTMP67,SGF0C,IFELSE(REFWH(SGF0C,SGF1D)=0,SGF0A,IFELSE(REFWH(SGF0C,SGF1D)=1,SGF0B,SGF0C)));
SGF2D:=MIN(2,SGTMP25);
SGTMP68:=SGBN<=2;
SGF2A:=IFELSE(SGTMP68,SGF1A,IFELSE(REFWH(SGF1A,SGF2D)=0,SGF1A,IFELSE(REFWH(SGF1A,SGF2D)=1,SGF1B,SGF1C)));
SGF2B:=IFELSE(SGTMP68,SGF1B,IFELSE(REFWH(SGF1B,SGF2D)=0,SGF1A,IFELSE(REFWH(SGF1B,SGF2D)=1,SGF1B,SGF1C)));
SGF2C:=IFELSE(SGTMP68,SGF1C,IFELSE(REFWH(SGF1C,SGF2D)=0,SGF1A,IFELSE(REFWH(SGF1C,SGF2D)=1,SGF1B,SGF1C)));
SGF3D:=MIN(4,SGTMP25);
SGTMP69:=SGBN<=4;
SGF3A:=IFELSE(SGTMP69,SGF2A,IFELSE(REFWH(SGF2A,SGF3D)=0,SGF2A,IFELSE(REFWH(SGF2A,SGF3D)=1,SGF2B,SGF2C)));
SGF3B:=IFELSE(SGTMP69,SGF2B,IFELSE(REFWH(SGF2B,SGF3D)=0,SGF2A,IFELSE(REFWH(SGF2B,SGF3D)=1,SGF2B,SGF2C)));
SGF3C:=IFELSE(SGTMP69,SGF2C,IFELSE(REFWH(SGF2C,SGF3D)=0,SGF2A,IFELSE(REFWH(SGF2C,SGF3D)=1,SGF2B,SGF2C)));
SGF4D:=MIN(8,SGTMP25);
SGTMP70:=SGBN<=8;
SGF4A:=IFELSE(SGTMP70,SGF3A,IFELSE(REFWH(SGF3A,SGF4D)=0,SGF3A,IFELSE(REFWH(SGF3A,SGF4D)=1,SGF3B,SGF3C)));
SGF4B:=IFELSE(SGTMP70,SGF3B,IFELSE(REFWH(SGF3B,SGF4D)=0,SGF3A,IFELSE(REFWH(SGF3B,SGF4D)=1,SGF3B,SGF3C)));
SGF4C:=IFELSE(SGTMP70,SGF3C,IFELSE(REFWH(SGF3C,SGF4D)=0,SGF3A,IFELSE(REFWH(SGF3C,SGF4D)=1,SGF3B,SGF3C)));
SGF5D:=MIN(16,SGTMP25);
SGTMP71:=SGBN<=16;
SGF5A:=IFELSE(SGTMP71,SGF4A,IFELSE(REFWH(SGF4A,SGF5D)=0,SGF4A,IFELSE(REFWH(SGF4A,SGF5D)=1,SGF4B,SGF4C)));
SGF5B:=IFELSE(SGTMP71,SGF4B,IFELSE(REFWH(SGF4B,SGF5D)=0,SGF4A,IFELSE(REFWH(SGF4B,SGF5D)=1,SGF4B,SGF4C)));
SGF5C:=IFELSE(SGTMP71,SGF4C,IFELSE(REFWH(SGF4C,SGF5D)=0,SGF4A,IFELSE(REFWH(SGF4C,SGF5D)=1,SGF4B,SGF4C)));
SGF6D:=MIN(32,SGTMP25);
SGTMP72:=SGBN<=32;
SGF6A:=IFELSE(SGTMP72,SGF5A,IFELSE(REFWH(SGF5A,SGF6D)=0,SGF5A,IFELSE(REFWH(SGF5A,SGF6D)=1,SGF5B,SGF5C)));
SGF6B:=IFELSE(SGTMP72,SGF5B,IFELSE(REFWH(SGF5B,SGF6D)=0,SGF5A,IFELSE(REFWH(SGF5B,SGF6D)=1,SGF5B,SGF5C)));
SGF6C:=IFELSE(SGTMP72,SGF5C,IFELSE(REFWH(SGF5C,SGF6D)=0,SGF5A,IFELSE(REFWH(SGF5C,SGF6D)=1,SGF5B,SGF5C)));
SGF7D:=MIN(64,SGTMP25);
SGTMP73:=SGBN<=64;
SGF7A:=IFELSE(SGTMP73,SGF6A,IFELSE(REFWH(SGF6A,SGF7D)=0,SGF6A,IFELSE(REFWH(SGF6A,SGF7D)=1,SGF6B,SGF6C)));
SGF7B:=IFELSE(SGTMP73,SGF6B,IFELSE(REFWH(SGF6B,SGF7D)=0,SGF6A,IFELSE(REFWH(SGF6B,SGF7D)=1,SGF6B,SGF6C)));
SGF7C:=IFELSE(SGTMP73,SGF6C,IFELSE(REFWH(SGF6C,SGF7D)=0,SGF6A,IFELSE(REFWH(SGF6C,SGF7D)=1,SGF6B,SGF6C)));
SGF8D:=MIN(128,SGTMP25);
SGTMP74:=SGBN<=128;
SGF8A:=IFELSE(SGTMP74,SGF7A,IFELSE(REFWH(SGF7A,SGF8D)=0,SGF7A,IFELSE(REFWH(SGF7A,SGF8D)=1,SGF7B,SGF7C)));
SGF8B:=IFELSE(SGTMP74,SGF7B,IFELSE(REFWH(SGF7B,SGF8D)=0,SGF7A,IFELSE(REFWH(SGF7B,SGF8D)=1,SGF7B,SGF7C)));
SGF8C:=IFELSE(SGTMP74,SGF7C,IFELSE(REFWH(SGF7C,SGF8D)=0,SGF7A,IFELSE(REFWH(SGF7C,SGF8D)=1,SGF7B,SGF7C)));
SGF9D:=MIN(256,SGTMP25);
SGTMP75:=SGBN<=256;
SGF9A:=IFELSE(SGTMP75,SGF8A,IFELSE(REFWH(SGF8A,SGF9D)=0,SGF8A,IFELSE(REFWH(SGF8A,SGF9D)=1,SGF8B,SGF8C)));
SGF9B:=IFELSE(SGTMP75,SGF8B,IFELSE(REFWH(SGF8B,SGF9D)=0,SGF8A,IFELSE(REFWH(SGF8B,SGF9D)=1,SGF8B,SGF8C)));
SGF9C:=IFELSE(SGTMP75,SGF8C,IFELSE(REFWH(SGF8C,SGF9D)=0,SGF8A,IFELSE(REFWH(SGF8C,SGF9D)=1,SGF8B,SGF8C)));
SGF10D:=MIN(512,SGTMP25);
SGTMP76:=SGBN<=512;
SGF10A:=IFELSE(SGTMP76,SGF9A,IFELSE(REFWH(SGF9A,SGF10D)=0,SGF9A,IFELSE(REFWH(SGF9A,SGF10D)=1,SGF9B,SGF9C)));
SGF10B:=IFELSE(SGTMP76,SGF9B,IFELSE(REFWH(SGF9B,SGF10D)=0,SGF9A,IFELSE(REFWH(SGF9B,SGF10D)=1,SGF9B,SGF9C)));
SGF10C:=IFELSE(SGTMP76,SGF9C,IFELSE(REFWH(SGF9C,SGF10D)=0,SGF9A,IFELSE(REFWH(SGF9C,SGF10D)=1,SGF9B,SGF9C)));
SGF11D:=MIN(1024,SGTMP25);
SGTMP77:=SGBN<=1024;
SGF11A:=IFELSE(SGTMP77,SGF10A,IFELSE(REFWH(SGF10A,SGF11D)=0,SGF10A,IFELSE(REFWH(SGF10A,SGF11D)=1,SGF10B,SGF10C)));
SGF11B:=IFELSE(SGTMP77,SGF10B,IFELSE(REFWH(SGF10B,SGF11D)=0,SGF10A,IFELSE(REFWH(SGF10B,SGF11D)=1,SGF10B,SGF10C)));
SGF11C:=IFELSE(SGTMP77,SGF10C,IFELSE(REFWH(SGF10C,SGF11D)=0,SGF10A,IFELSE(REFWH(SGF10C,SGF11D)=1,SGF10B,SGF10C)));
SGF12D:=MIN(2048,SGTMP25);
SGTMP78:=SGBN<=2048;
SGF12A:=IFELSE(SGTMP78,SGF11A,IFELSE(REFWH(SGF11A,SGF12D)=0,SGF11A,IFELSE(REFWH(SGF11A,SGF12D)=1,SGF11B,SGF11C)));
SGF12B:=IFELSE(SGTMP78,SGF11B,IFELSE(REFWH(SGF11B,SGF12D)=0,SGF11A,IFELSE(REFWH(SGF11B,SGF12D)=1,SGF11B,SGF11C)));
SGF12C:=IFELSE(SGTMP78,SGF11C,IFELSE(REFWH(SGF11C,SGF12D)=0,SGF11A,IFELSE(REFWH(SGF11C,SGF12D)=1,SGF11B,SGF11C)));
SGF13D:=MIN(4096,SGTMP25);
SGTMP79:=SGBN<=4096;
SGF13A:=IFELSE(SGTMP79,SGF12A,IFELSE(REFWH(SGF12A,SGF13D)=0,SGF12A,IFELSE(REFWH(SGF12A,SGF13D)=1,SGF12B,SGF12C)));
SGF13B:=IFELSE(SGTMP79,SGF12B,IFELSE(REFWH(SGF12B,SGF13D)=0,SGF12A,IFELSE(REFWH(SGF12B,SGF13D)=1,SGF12B,SGF12C)));
SGF13C:=IFELSE(SGTMP79,SGF12C,IFELSE(REFWH(SGF12C,SGF13D)=0,SGF12A,IFELSE(REFWH(SGF12C,SGF13D)=1,SGF12B,SGF12C)));
SGF14D:=MIN(8192,SGTMP25);
SGTMP80:=SGBN<=8192;
SGF14A:=IFELSE(SGTMP80,SGF13A,IFELSE(REFWH(SGF13A,SGF14D)=0,SGF13A,IFELSE(REFWH(SGF13A,SGF14D)=1,SGF13B,SGF13C)));
SGF14B:=IFELSE(SGTMP80,SGF13B,IFELSE(REFWH(SGF13B,SGF14D)=0,SGF13A,IFELSE(REFWH(SGF13B,SGF14D)=1,SGF13B,SGF13C)));
SGF14C:=IFELSE(SGTMP80,SGF13C,IFELSE(REFWH(SGF13C,SGF14D)=0,SGF13A,IFELSE(REFWH(SGF13C,SGF14D)=1,SGF13B,SGF13C)));
SGF15D:=MIN(16384,SGTMP25);
SGTMP81:=SGBN<=16384;
SGF15A:=IFELSE(SGTMP81,SGF14A,IFELSE(REFWH(SGF14A,SGF15D)=0,SGF14A,IFELSE(REFWH(SGF14A,SGF15D)=1,SGF14B,SGF14C)));
SGF15B:=IFELSE(SGTMP81,SGF14B,IFELSE(REFWH(SGF14B,SGF15D)=0,SGF14A,IFELSE(REFWH(SGF14B,SGF15D)=1,SGF14B,SGF14C)));
SGF15C:=IFELSE(SGTMP81,SGF14C,IFELSE(REFWH(SGF14C,SGF15D)=0,SGF14A,IFELSE(REFWH(SGF14C,SGF15D)=1,SGF14B,SGF14C)));
SGF16D:=MIN(32768,SGTMP25);
SGTMP82:=SGBN<=32768;
SGF16A:=IFELSE(SGTMP82,SGF15A,IFELSE(REFWH(SGF15A,SGF16D)=0,SGF15A,IFELSE(REFWH(SGF15A,SGF16D)=1,SGF15B,SGF15C)));
SGF16B:=IFELSE(SGTMP82,SGF15B,IFELSE(REFWH(SGF15B,SGF16D)=0,SGF15A,IFELSE(REFWH(SGF15B,SGF16D)=1,SGF15B,SGF15C)));
SGF16C:=IFELSE(SGTMP82,SGF15C,IFELSE(REFWH(SGF15C,SGF16D)=0,SGF15A,IFELSE(REFWH(SGF15C,SGF16D)=1,SGF15B,SGF15C)));
SGF17D:=MIN(65536,SGTMP25);
SGTMP83:=SGBN<=65536;
SGF17A:=IFELSE(SGTMP83,SGF16A,IFELSE(REFWH(SGF16A,SGF17D)=0,SGF16A,IFELSE(REFWH(SGF16A,SGF17D)=1,SGF16B,SGF16C)));
SGF17B:=IFELSE(SGTMP83,SGF16B,IFELSE(REFWH(SGF16B,SGF17D)=0,SGF16A,IFELSE(REFWH(SGF16B,SGF17D)=1,SGF16B,SGF16C)));
SGF17C:=IFELSE(SGTMP83,SGF16C,IFELSE(REFWH(SGF16C,SGF17D)=0,SGF16A,IFELSE(REFWH(SGF16C,SGF17D)=1,SGF16B,SGF16C)));
SGF18D:=MIN(131072,SGTMP25);
SGTMP84:=SGBN<=131072;
SGF18A:=IFELSE(SGTMP84,SGF17A,IFELSE(REFWH(SGF17A,SGF18D)=0,SGF17A,IFELSE(REFWH(SGF17A,SGF18D)=1,SGF17B,SGF17C)));
SGF18B:=IFELSE(SGTMP84,SGF17B,IFELSE(REFWH(SGF17B,SGF18D)=0,SGF17A,IFELSE(REFWH(SGF17B,SGF18D)=1,SGF17B,SGF17C)));
SGF18C:=IFELSE(SGTMP84,SGF17C,IFELSE(REFWH(SGF17C,SGF18D)=0,SGF17A,IFELSE(REFWH(SGF17C,SGF18D)=1,SGF17B,SGF17C)));
SGF19D:=MIN(262144,SGTMP25);
SGTMP85:=SGBN<=262144;
SGF19A:=IFELSE(SGTMP85,SGF18A,IFELSE(REFWH(SGF18A,SGF19D)=0,SGF18A,IFELSE(REFWH(SGF18A,SGF19D)=1,SGF18B,SGF18C)));
SGF19B:=IFELSE(SGTMP85,SGF18B,IFELSE(REFWH(SGF18B,SGF19D)=0,SGF18A,IFELSE(REFWH(SGF18B,SGF19D)=1,SGF18B,SGF18C)));
SGF19C:=IFELSE(SGTMP85,SGF18C,IFELSE(REFWH(SGF18C,SGF19D)=0,SGF18A,IFELSE(REFWH(SGF18C,SGF19D)=1,SGF18B,SGF18C)));
SGF20D:=MIN(524288,SGTMP25);
SGTMP86:=SGBN<=524288;
SGF20A:=IFELSE(SGTMP86,SGF19A,IFELSE(REFWH(SGF19A,SGF20D)=0,SGF19A,IFELSE(REFWH(SGF19A,SGF20D)=1,SGF19B,SGF19C)));
SGF20B:=IFELSE(SGTMP86,SGF19B,IFELSE(REFWH(SGF19B,SGF20D)=0,SGF19A,IFELSE(REFWH(SGF19B,SGF20D)=1,SGF19B,SGF19C)));
SGF20C:=IFELSE(SGTMP86,SGF19C,IFELSE(REFWH(SGF19C,SGF20D)=0,SGF19A,IFELSE(REFWH(SGF19C,SGF20D)=1,SGF19B,SGF19C)));
SGF21D:=MIN(1048576,SGTMP25);
SGTMP87:=SGBN<=1048576;
SGF21A:=IFELSE(SGTMP87,SGF20A,IFELSE(REFWH(SGF20A,SGF21D)=0,SGF20A,IFELSE(REFWH(SGF20A,SGF21D)=1,SGF20B,SGF20C)));
SGF21B:=IFELSE(SGTMP87,SGF20B,IFELSE(REFWH(SGF20B,SGF21D)=0,SGF20A,IFELSE(REFWH(SGF20B,SGF21D)=1,SGF20B,SGF20C)));
SGF21C:=IFELSE(SGTMP87,SGF20C,IFELSE(REFWH(SGF20C,SGF21D)=0,SGF20A,IFELSE(REFWH(SGF20C,SGF21D)=1,SGF20B,SGF20C)));
SGF22D:=MIN(2097152,SGTMP25);
SGTMP88:=SGBN<=2097152;
SGF22A:=IFELSE(SGTMP88,SGF21A,IFELSE(REFWH(SGF21A,SGF22D)=0,SGF21A,IFELSE(REFWH(SGF21A,SGF22D)=1,SGF21B,SGF21C)));
SGF22B:=IFELSE(SGTMP88,SGF21B,IFELSE(REFWH(SGF21B,SGF22D)=0,SGF21A,IFELSE(REFWH(SGF21B,SGF22D)=1,SGF21B,SGF21C)));
SGF22C:=IFELSE(SGTMP88,SGF21C,IFELSE(REFWH(SGF21C,SGF22D)=0,SGF21A,IFELSE(REFWH(SGF21C,SGF22D)=1,SGF21B,SGF21C)));
SGF23D:=MIN(4194304,SGTMP25);
SGTMP89:=SGBN<=4194304;
SGF23A:=IFELSE(SGTMP89,SGF22A,IFELSE(REFWH(SGF22A,SGF23D)=0,SGF22A,IFELSE(REFWH(SGF22A,SGF23D)=1,SGF22B,SGF22C)));
SGF23B:=IFELSE(SGTMP89,SGF22B,IFELSE(REFWH(SGF22B,SGF23D)=0,SGF22A,IFELSE(REFWH(SGF22B,SGF23D)=1,SGF22B,SGF22C)));
SGF23C:=IFELSE(SGTMP89,SGF22C,IFELSE(REFWH(SGF22C,SGF23D)=0,SGF22A,IFELSE(REFWH(SGF22C,SGF23D)=1,SGF22B,SGF22C)));
SGF24D:=MIN(8388608,SGTMP25);
SGTMP90:=SGBN<=8388608;
SGF24A:=IFELSE(SGTMP90,SGF23A,IFELSE(REFWH(SGF23A,SGF24D)=0,SGF23A,IFELSE(REFWH(SGF23A,SGF24D)=1,SGF23B,SGF23C)));
SGF24B:=IFELSE(SGTMP90,SGF23B,IFELSE(REFWH(SGF23B,SGF24D)=0,SGF23A,IFELSE(REFWH(SGF23B,SGF24D)=1,SGF23B,SGF23C)));
SGF24C:=IFELSE(SGTMP90,SGF23C,IFELSE(REFWH(SGF23C,SGF24D)=0,SGF23A,IFELSE(REFWH(SGF23C,SGF24D)=1,SGF23B,SGF23C)));
SGF25D:=MIN(16777216,SGTMP25);
SGTMP91:=SGBN<=16777216;
SGF25A:=IFELSE(SGTMP91,SGF24A,IFELSE(REFWH(SGF24A,SGF25D)=0,SGF24A,IFELSE(REFWH(SGF24A,SGF25D)=1,SGF24B,SGF24C)));
SGF25B:=IFELSE(SGTMP91,SGF24B,IFELSE(REFWH(SGF24B,SGF25D)=0,SGF24A,IFELSE(REFWH(SGF24B,SGF25D)=1,SGF24B,SGF24C)));
SGF25C:=IFELSE(SGTMP91,SGF24C,IFELSE(REFWH(SGF24C,SGF25D)=0,SGF24A,IFELSE(REFWH(SGF24C,SGF25D)=1,SGF24B,SGF24C)));
SGF26D:=MIN(33554432,SGTMP25);
SGTMP92:=SGBN<=33554432;
SGF26A:=IFELSE(SGTMP92,SGF25A,IFELSE(REFWH(SGF25A,SGF26D)=0,SGF25A,IFELSE(REFWH(SGF25A,SGF26D)=1,SGF25B,SGF25C)));
SGF26B:=IFELSE(SGTMP92,SGF25B,IFELSE(REFWH(SGF25B,SGF26D)=0,SGF25A,IFELSE(REFWH(SGF25B,SGF26D)=1,SGF25B,SGF25C)));
SGF26C:=IFELSE(SGTMP92,SGF25C,IFELSE(REFWH(SGF25C,SGF26D)=0,SGF25A,IFELSE(REFWH(SGF25C,SGF26D)=1,SGF25B,SGF25C)));
SGF27D:=MIN(67108864,SGTMP25);
SGTMP93:=SGBN<=67108864;
SGF27A:=IFELSE(SGTMP93,SGF26A,IFELSE(REFWH(SGF26A,SGF27D)=0,SGF26A,IFELSE(REFWH(SGF26A,SGF27D)=1,SGF26B,SGF26C)));
SGF27B:=IFELSE(SGTMP93,SGF26B,IFELSE(REFWH(SGF26B,SGF27D)=0,SGF26A,IFELSE(REFWH(SGF26B,SGF27D)=1,SGF26B,SGF26C)));
SGF27C:=IFELSE(SGTMP93,SGF26C,IFELSE(REFWH(SGF26C,SGF27D)=0,SGF26A,IFELSE(REFWH(SGF26C,SGF27D)=1,SGF26B,SGF26C)));
SGF28D:=MIN(134217728,SGTMP25);
SGTMP94:=SGBN<=134217728;
SGF28A:=IFELSE(SGTMP94,SGF27A,IFELSE(REFWH(SGF27A,SGF28D)=0,SGF27A,IFELSE(REFWH(SGF27A,SGF28D)=1,SGF27B,SGF27C)));
SGF28B:=IFELSE(SGTMP94,SGF27B,IFELSE(REFWH(SGF27B,SGF28D)=0,SGF27A,IFELSE(REFWH(SGF27B,SGF28D)=1,SGF27B,SGF27C)));
SGF28C:=IFELSE(SGTMP94,SGF27C,IFELSE(REFWH(SGF27C,SGF28D)=0,SGF27A,IFELSE(REFWH(SGF27C,SGF28D)=1,SGF27B,SGF27C)));
SGF29D:=MIN(268435456,SGTMP25);
SGTMP95:=SGBN<=268435456;
SGF29A:=IFELSE(SGTMP95,SGF28A,IFELSE(REFWH(SGF28A,SGF29D)=0,SGF28A,IFELSE(REFWH(SGF28A,SGF29D)=1,SGF28B,SGF28C)));
SGF29B:=IFELSE(SGTMP95,SGF28B,IFELSE(REFWH(SGF28B,SGF29D)=0,SGF28A,IFELSE(REFWH(SGF28B,SGF29D)=1,SGF28B,SGF28C)));
SGF29C:=IFELSE(SGTMP95,SGF28C,IFELSE(REFWH(SGF28C,SGF29D)=0,SGF28A,IFELSE(REFWH(SGF28C,SGF29D)=1,SGF28B,SGF28C)));
SGF30D:=MIN(536870912,SGTMP25);
SGTMP96:=SGBN<=536870912;
SGF30A:=IFELSE(SGTMP96,SGF29A,IFELSE(REFWH(SGF29A,SGF30D)=0,SGF29A,IFELSE(REFWH(SGF29A,SGF30D)=1,SGF29B,SGF29C)));
SGF30B:=IFELSE(SGTMP96,SGF29B,IFELSE(REFWH(SGF29B,SGF30D)=0,SGF29A,IFELSE(REFWH(SGF29B,SGF30D)=1,SGF29B,SGF29C)));
SGF30C:=IFELSE(SGTMP96,SGF29C,IFELSE(REFWH(SGF29C,SGF30D)=0,SGF29A,IFELSE(REFWH(SGF29C,SGF30D)=1,SGF29B,SGF29C)));
SGF31D:=MIN(1073741824,SGTMP25);
SGF31A:=IFELSE(SGBN<=1073741824,SGF30A,IFELSE(REFWH(SGF30A,SGF31D)=0,SGF30A,IFELSE(REFWH(SGF30A,SGF31D)=1,SGF30B,SGF30C)));
SGFS:=SGBN=1 OR REFWH(SGF31A,1)=0;
SGFT:=SGFRT AND SGFS;
SGFB:=SGFRB AND SGFS;
SGFE:=SGFT OR SGFB;
SGFK:=IFELSE(SGFT,1,-(1));
SGTMP97:=COUNT(SGFE,0);
SGFC:=SGTMP97;
SGTMP98:=SGTMP97>0;
SGES:=SGFE AND (SGFC=1 OR SGFK<>REFWH(IFELSE(SGTMP98,VALUEWHEN(SGFE,SGFK),0),1));
SGER:=IFELSE(COUNT(SGES,0)>0,BARSLAST(SGES),SGBN)+1;
SGTMP99:=MAX(SGEW,4);
SGTMP100:=MIN(SGER,SGTMP99);
SGEH:=HHV(IFELSE(SGTMP98,VALUEWHEN(SGFE,SGMH),0),SGTMP100);
SGEL:=LLV(IFELSE(SGTMP98,VALUEWHEN(SGFE,SGML),0),SGTMP100);
SGEX:=SGFE AND SGES=0 AND SGER<=SGTMP99 AND COUNT(SGGX,SGER)=0 AND IFELSE(SGFT,SGMH>REFWH(SGEH,1),SGML<REFWH(SGEL,1));
SGEA:=SGES OR SGEX;
SGEB:=BACKSET(SGEX,2)-BACKSET(SGEX,1)>0;
SGEC:=BACKSET(SGEB,IFELSE(COUNT(SGEA,0)>0,BARSLAST(SGEA),SGBN)+1);
SGKE0:=SGEA AND SGEC=0;
SGTMP101:=COUNT(SGKE0,0);
SGJ1N:=SGTMP101;
SGJ1D:=MIN(IFELSE(COUNT(REFWH(SGKE0,1),0)>0,BARSLAST(REFWH(SGKE0,1)),SGBN)+1,SGTMP25);
SGJ1A:=MIN(SGJ1D+REFWH(SGJ1D,SGJ1D),SGTMP25);
SGTMP102:=SGTMP101>0;
SGTMP103:=IFELSE(SGFT,SGMH,SGML);
SGJ1P:=IFELSE(SGTMP102,VALUEWHEN(SGKE0,SGTMP103),0);
SGTMP104:=MAX(SGMG,4);
SGJ1V:=SGKE0 AND SGJ1N>=2 AND SGJ1D>=SGTMP104 AND SGGC-REFWH(SGGC,SGJ1D)>=3 AND IFELSE(SGFT,SGMH>REFWH(SGJ1P,SGJ1D) AND SGMH>REFWH(SGMH,SGJ1D),REFWH(SGJ1P,SGJ1D)>SGML AND REFWH(SGMH,SGJ1D)>SGMH);
SGJ1C:=SGKE0 AND SGJ1N>=3 AND MOD(SGJ1N-0,3)=0 AND SGJ1A<=SGTMP99 AND COUNT(SGGX,SGJ1A+1)=0 AND REFWH(SGJ1V,SGJ1D)=0;
SGJ1K:=IFELSE(SGFT,SGMH>REFWH(SGMH,SGJ1A),SGML<REFWH(SGML,SGJ1A));
SGJ1B:=BACKSET(SGJ1C AND SGJ1K=0,SGJ1D+1);
SGJ1T:=BACKSET(SGJ1C AND SGJ1K,2)-BACKSET(SGJ1C AND SGJ1K,1)>0;
SGTMP105:=IFELSE(SGTMP102,BARSLAST(SGKE0),SGBN);
SGJ1R:=BACKSET(SGJ1T,MIN(SGTMP105+REFWH(SGJ1D,SGTMP105)+1,SGBN));
SGKE1:=SGKE0 AND SGJ1B=0 AND SGJ1R=0;
SGTMP106:=COUNT(SGKE1,0);
SGJ2N:=SGTMP106;
SGJ2D:=MIN(IFELSE(COUNT(REFWH(SGKE1,1),0)>0,BARSLAST(REFWH(SGKE1,1)),SGBN)+1,SGTMP25);
SGJ2A:=MIN(SGJ2D+REFWH(SGJ2D,SGJ2D),SGTMP25);
SGTMP107:=SGTMP106>0;
SGJ2P:=IFELSE(SGTMP107,VALUEWHEN(SGKE1,SGTMP103),0);
SGJ2V:=SGKE1 AND SGJ2N>=2 AND SGJ2D>=SGTMP104 AND SGGC-REFWH(SGGC,SGJ2D)>=3 AND IFELSE(SGFT,SGMH>REFWH(SGJ2P,SGJ2D) AND SGMH>REFWH(SGMH,SGJ2D),REFWH(SGJ2P,SGJ2D)>SGML AND REFWH(SGMH,SGJ2D)>SGMH);
SGJ2C:=SGKE1 AND SGJ2N>=4 AND MOD(SGJ2N-1,3)=0 AND SGJ2A<=SGTMP99 AND COUNT(SGGX,SGJ2A+1)=0 AND REFWH(SGJ2V,SGJ2D)=0;
SGJ2K:=IFELSE(SGFT,SGMH>REFWH(SGMH,SGJ2A),SGML<REFWH(SGML,SGJ2A));
SGJ2B:=BACKSET(SGJ2C AND SGJ2K=0,SGJ2D+1);
SGJ2T:=BACKSET(SGJ2C AND SGJ2K,2)-BACKSET(SGJ2C AND SGJ2K,1)>0;
SGTMP108:=IFELSE(SGTMP107,BARSLAST(SGKE1),SGBN);
SGJ2R:=BACKSET(SGJ2T,MIN(SGTMP108+REFWH(SGJ2D,SGTMP108)+1,SGBN));
SGKE2:=SGKE1 AND SGJ2B=0 AND SGJ2R=0;
SGTMP109:=COUNT(SGKE2,0);
SGJ3N:=SGTMP109;
SGJ3D:=MIN(IFELSE(COUNT(REFWH(SGKE2,1),0)>0,BARSLAST(REFWH(SGKE2,1)),SGBN)+1,SGTMP25);
SGJ3A:=MIN(SGJ3D+REFWH(SGJ3D,SGJ3D),SGTMP25);
SGTMP110:=SGTMP109>0;
SGJ3P:=IFELSE(SGTMP110,VALUEWHEN(SGKE2,SGTMP103),0);
SGJ3V:=SGKE2 AND SGJ3N>=2 AND SGJ3D>=SGTMP104 AND SGGC-REFWH(SGGC,SGJ3D)>=3 AND IFELSE(SGFT,SGMH>REFWH(SGJ3P,SGJ3D) AND SGMH>REFWH(SGMH,SGJ3D),REFWH(SGJ3P,SGJ3D)>SGML AND REFWH(SGMH,SGJ3D)>SGMH);
SGJ3C:=SGKE2 AND SGJ3N>=5 AND MOD(SGJ3N-2,3)=0 AND SGJ3A<=SGTMP99 AND COUNT(SGGX,SGJ3A+1)=0 AND REFWH(SGJ3V,SGJ3D)=0;
SGJ3K:=IFELSE(SGFT,SGMH>REFWH(SGMH,SGJ3A),SGML<REFWH(SGML,SGJ3A));
SGJ3B:=BACKSET(SGJ3C AND SGJ3K=0,SGJ3D+1);
SGJ3T:=BACKSET(SGJ3C AND SGJ3K,2)-BACKSET(SGJ3C AND SGJ3K,1)>0;
SGTMP111:=IFELSE(SGTMP110,BARSLAST(SGKE2),SGBN);
SGJ3R:=BACKSET(SGJ3T,MIN(SGTMP111+REFWH(SGJ3D,SGTMP111)+1,SGBN));
SGKE3:=SGKE2 AND SGJ3B=0 AND SGJ3R=0;
SGTMP112:=COUNT(SGKE3,0);
SGJ4N:=SGTMP112;
SGJ4D:=MIN(IFELSE(COUNT(REFWH(SGKE3,1),0)>0,BARSLAST(REFWH(SGKE3,1)),SGBN)+1,SGTMP25);
SGJ4A:=MIN(SGJ4D+REFWH(SGJ4D,SGJ4D),SGTMP25);
SGTMP113:=SGTMP112>0;
SGJ4P:=IFELSE(SGTMP113,VALUEWHEN(SGKE3,SGTMP103),0);
SGJ4V:=SGKE3 AND SGJ4N>=2 AND SGJ4D>=SGTMP104 AND SGGC-REFWH(SGGC,SGJ4D)>=3 AND IFELSE(SGFT,SGMH>REFWH(SGJ4P,SGJ4D) AND SGMH>REFWH(SGMH,SGJ4D),REFWH(SGJ4P,SGJ4D)>SGML AND REFWH(SGMH,SGJ4D)>SGMH);
SGJ4C:=SGKE3 AND SGJ4N>=3 AND MOD(SGJ4N-0,3)=0 AND SGJ4A<=SGTMP99 AND COUNT(SGGX,SGJ4A+1)=0 AND REFWH(SGJ4V,SGJ4D)=0;
SGJ4K:=IFELSE(SGFT,SGMH>REFWH(SGMH,SGJ4A),SGML<REFWH(SGML,SGJ4A));
SGJ4B:=BACKSET(SGJ4C AND SGJ4K=0,SGJ4D+1);
SGJ4T:=BACKSET(SGJ4C AND SGJ4K,2)-BACKSET(SGJ4C AND SGJ4K,1)>0;
SGTMP114:=IFELSE(SGTMP113,BARSLAST(SGKE3),SGBN);
SGJ4R:=BACKSET(SGJ4T,MIN(SGTMP114+REFWH(SGJ4D,SGTMP114)+1,SGBN));
SGKE4:=SGKE3 AND SGJ4B=0 AND SGJ4R=0;
SGTMP115:=COUNT(SGKE4,0);
SGJ5N:=SGTMP115;
SGJ5D:=MIN(IFELSE(COUNT(REFWH(SGKE4,1),0)>0,BARSLAST(REFWH(SGKE4,1)),SGBN)+1,SGTMP25);
SGJ5A:=MIN(SGJ5D+REFWH(SGJ5D,SGJ5D),SGTMP25);
SGTMP116:=SGTMP115>0;
SGJ5P:=IFELSE(SGTMP116,VALUEWHEN(SGKE4,SGTMP103),0);
SGJ5V:=SGKE4 AND SGJ5N>=2 AND SGJ5D>=SGTMP104 AND SGGC-REFWH(SGGC,SGJ5D)>=3 AND IFELSE(SGFT,SGMH>REFWH(SGJ5P,SGJ5D) AND SGMH>REFWH(SGMH,SGJ5D),REFWH(SGJ5P,SGJ5D)>SGML AND REFWH(SGMH,SGJ5D)>SGMH);
SGJ5C:=SGKE4 AND SGJ5N>=4 AND MOD(SGJ5N-1,3)=0 AND SGJ5A<=SGTMP99 AND COUNT(SGGX,SGJ5A+1)=0 AND REFWH(SGJ5V,SGJ5D)=0;
SGJ5K:=IFELSE(SGFT,SGMH>REFWH(SGMH,SGJ5A),SGML<REFWH(SGML,SGJ5A));
SGJ5B:=BACKSET(SGJ5C AND SGJ5K=0,SGJ5D+1);
SGJ5T:=BACKSET(SGJ5C AND SGJ5K,2)-BACKSET(SGJ5C AND SGJ5K,1)>0;
SGTMP117:=IFELSE(SGTMP116,BARSLAST(SGKE4),SGBN);
SGJ5R:=BACKSET(SGJ5T,MIN(SGTMP117+REFWH(SGJ5D,SGTMP117)+1,SGBN));
SGKE5:=SGKE4 AND SGJ5B=0 AND SGJ5R=0;
SGTMP118:=COUNT(SGKE5,0);
SGJ6N:=SGTMP118;
SGJ6D:=MIN(IFELSE(COUNT(REFWH(SGKE5,1),0)>0,BARSLAST(REFWH(SGKE5,1)),SGBN)+1,SGTMP25);
SGJ6A:=MIN(SGJ6D+REFWH(SGJ6D,SGJ6D),SGTMP25);
SGTMP119:=SGTMP118>0;
SGJ6P:=IFELSE(SGTMP119,VALUEWHEN(SGKE5,SGTMP103),0);
SGJ6V:=SGKE5 AND SGJ6N>=2 AND SGJ6D>=SGTMP104 AND SGGC-REFWH(SGGC,SGJ6D)>=3 AND IFELSE(SGFT,SGMH>REFWH(SGJ6P,SGJ6D) AND SGMH>REFWH(SGMH,SGJ6D),REFWH(SGJ6P,SGJ6D)>SGML AND REFWH(SGMH,SGJ6D)>SGMH);
SGJ6C:=SGKE5 AND SGJ6N>=5 AND MOD(SGJ6N-2,3)=0 AND SGJ6A<=SGTMP99 AND COUNT(SGGX,SGJ6A+1)=0 AND REFWH(SGJ6V,SGJ6D)=0;
SGJ6K:=IFELSE(SGFT,SGMH>REFWH(SGMH,SGJ6A),SGML<REFWH(SGML,SGJ6A));
SGJ6B:=BACKSET(SGJ6C AND SGJ6K=0,SGJ6D+1);
SGJ6T:=BACKSET(SGJ6C AND SGJ6K,2)-BACKSET(SGJ6C AND SGJ6K,1)>0;
SGTMP120:=IFELSE(SGTMP119,BARSLAST(SGKE5),SGBN);
SGJ6R:=BACKSET(SGJ6T,MIN(SGTMP120+REFWH(SGJ6D,SGTMP120)+1,SGBN));
SGKE6:=SGKE5 AND SGJ6B=0 AND SGJ6R=0;
SGTMP121:=COUNT(SGKE6,0);
SGJ7N:=SGTMP121;
SGJ7D:=MIN(IFELSE(COUNT(REFWH(SGKE6,1),0)>0,BARSLAST(REFWH(SGKE6,1)),SGBN)+1,SGTMP25);
SGJ7A:=MIN(SGJ7D+REFWH(SGJ7D,SGJ7D),SGTMP25);
SGTMP122:=SGTMP121>0;
SGJ7P:=IFELSE(SGTMP122,VALUEWHEN(SGKE6,SGTMP103),0);
SGJ7V:=SGKE6 AND SGJ7N>=2 AND SGJ7D>=SGTMP104 AND SGGC-REFWH(SGGC,SGJ7D)>=3 AND IFELSE(SGFT,SGMH>REFWH(SGJ7P,SGJ7D) AND SGMH>REFWH(SGMH,SGJ7D),REFWH(SGJ7P,SGJ7D)>SGML AND REFWH(SGMH,SGJ7D)>SGMH);
SGJ7C:=SGKE6 AND SGJ7N>=3 AND MOD(SGJ7N-0,3)=0 AND SGJ7A<=SGTMP99 AND COUNT(SGGX,SGJ7A+1)=0 AND REFWH(SGJ7V,SGJ7D)=0;
SGJ7K:=IFELSE(SGFT,SGMH>REFWH(SGMH,SGJ7A),SGML<REFWH(SGML,SGJ7A));
SGJ7B:=BACKSET(SGJ7C AND SGJ7K=0,SGJ7D+1);
SGJ7T:=BACKSET(SGJ7C AND SGJ7K,2)-BACKSET(SGJ7C AND SGJ7K,1)>0;
SGTMP123:=IFELSE(SGTMP122,BARSLAST(SGKE6),SGBN);
SGJ7R:=BACKSET(SGJ7T,MIN(SGTMP123+REFWH(SGJ7D,SGTMP123)+1,SGBN));
SGKE7:=SGKE6 AND SGJ7B=0 AND SGJ7R=0;
SGTMP124:=COUNT(SGKE7,0);
SGJ8N:=SGTMP124;
SGJ8D:=MIN(IFELSE(COUNT(REFWH(SGKE7,1),0)>0,BARSLAST(REFWH(SGKE7,1)),SGBN)+1,SGTMP25);
SGJ8A:=MIN(SGJ8D+REFWH(SGJ8D,SGJ8D),SGTMP25);
SGTMP125:=SGTMP124>0;
SGJ8P:=IFELSE(SGTMP125,VALUEWHEN(SGKE7,SGTMP103),0);
SGJ8V:=SGKE7 AND SGJ8N>=2 AND SGJ8D>=SGTMP104 AND SGGC-REFWH(SGGC,SGJ8D)>=3 AND IFELSE(SGFT,SGMH>REFWH(SGJ8P,SGJ8D) AND SGMH>REFWH(SGMH,SGJ8D),REFWH(SGJ8P,SGJ8D)>SGML AND REFWH(SGMH,SGJ8D)>SGMH);
SGJ8C:=SGKE7 AND SGJ8N>=4 AND MOD(SGJ8N-1,3)=0 AND SGJ8A<=SGTMP99 AND COUNT(SGGX,SGJ8A+1)=0 AND REFWH(SGJ8V,SGJ8D)=0;
SGJ8K:=IFELSE(SGFT,SGMH>REFWH(SGMH,SGJ8A),SGML<REFWH(SGML,SGJ8A));
SGJ8B:=BACKSET(SGJ8C AND SGJ8K=0,SGJ8D+1);
SGJ8T:=BACKSET(SGJ8C AND SGJ8K,2)-BACKSET(SGJ8C AND SGJ8K,1)>0;
SGTMP126:=IFELSE(SGTMP125,BARSLAST(SGKE7),SGBN);
SGJ8R:=BACKSET(SGJ8T,MIN(SGTMP126+REFWH(SGJ8D,SGTMP126)+1,SGBN));
SGKE8:=SGKE7 AND SGJ8B=0 AND SGJ8R=0;
SGTMP127:=COUNT(SGKE8,0);
SGJ9N:=SGTMP127;
SGJ9D:=MIN(IFELSE(COUNT(REFWH(SGKE8,1),0)>0,BARSLAST(REFWH(SGKE8,1)),SGBN)+1,SGTMP25);
SGJ9A:=MIN(SGJ9D+REFWH(SGJ9D,SGJ9D),SGTMP25);
SGTMP128:=SGTMP127>0;
SGJ9P:=IFELSE(SGTMP128,VALUEWHEN(SGKE8,SGTMP103),0);
SGJ9V:=SGKE8 AND SGJ9N>=2 AND SGJ9D>=SGTMP104 AND SGGC-REFWH(SGGC,SGJ9D)>=3 AND IFELSE(SGFT,SGMH>REFWH(SGJ9P,SGJ9D) AND SGMH>REFWH(SGMH,SGJ9D),REFWH(SGJ9P,SGJ9D)>SGML AND REFWH(SGMH,SGJ9D)>SGMH);
SGJ9C:=SGKE8 AND SGJ9N>=5 AND MOD(SGJ9N-2,3)=0 AND SGJ9A<=SGTMP99 AND COUNT(SGGX,SGJ9A+1)=0 AND REFWH(SGJ9V,SGJ9D)=0;
SGJ9K:=IFELSE(SGFT,SGMH>REFWH(SGMH,SGJ9A),SGML<REFWH(SGML,SGJ9A));
SGJ9B:=BACKSET(SGJ9C AND SGJ9K=0,SGJ9D+1);
SGJ9T:=BACKSET(SGJ9C AND SGJ9K,2)-BACKSET(SGJ9C AND SGJ9K,1)>0;
SGTMP129:=IFELSE(SGTMP128,BARSLAST(SGKE8),SGBN);
SGJ9R:=BACKSET(SGJ9T,MIN(SGTMP129+REFWH(SGJ9D,SGTMP129)+1,SGBN));
SGKE9:=SGKE8 AND SGJ9B=0 AND SGJ9R=0;
SGTMP130:=COUNT(SGKE9,0);
SGJ10N:=SGTMP130;
SGJ10D:=MIN(IFELSE(COUNT(REFWH(SGKE9,1),0)>0,BARSLAST(REFWH(SGKE9,1)),SGBN)+1,SGTMP25);
SGJ10A:=MIN(SGJ10D+REFWH(SGJ10D,SGJ10D),SGTMP25);
SGTMP131:=SGTMP130>0;
SGJ10P:=IFELSE(SGTMP131,VALUEWHEN(SGKE9,SGTMP103),0);
SGJ10V:=SGKE9 AND SGJ10N>=2 AND SGJ10D>=SGTMP104 AND SGGC-REFWH(SGGC,SGJ10D)>=3 AND IFELSE(SGFT,SGMH>REFWH(SGJ10P,SGJ10D) AND SGMH>REFWH(SGMH,SGJ10D),REFWH(SGJ10P,SGJ10D)>SGML AND REFWH(SGMH,SGJ10D)>SGMH);
SGJ10C:=SGKE9 AND SGJ10N>=3 AND MOD(SGJ10N-0,3)=0 AND SGJ10A<=SGTMP99 AND COUNT(SGGX,SGJ10A+1)=0 AND REFWH(SGJ10V,SGJ10D)=0;
SGJ10K:=IFELSE(SGFT,SGMH>REFWH(SGMH,SGJ10A),SGML<REFWH(SGML,SGJ10A));
SGJ10B:=BACKSET(SGJ10C AND SGJ10K=0,SGJ10D+1);
SGJ10T:=BACKSET(SGJ10C AND SGJ10K,2)-BACKSET(SGJ10C AND SGJ10K,1)>0;
SGTMP132:=IFELSE(SGTMP131,BARSLAST(SGKE9),SGBN);
SGJ10R:=BACKSET(SGJ10T,MIN(SGTMP132+REFWH(SGJ10D,SGTMP132)+1,SGBN));
SGKE10:=SGKE9 AND SGJ10B=0 AND SGJ10R=0;
SGTMP133:=COUNT(SGKE10,0);
SGJ11N:=SGTMP133;
SGJ11D:=MIN(IFELSE(COUNT(REFWH(SGKE10,1),0)>0,BARSLAST(REFWH(SGKE10,1)),SGBN)+1,SGTMP25);
SGJ11A:=MIN(SGJ11D+REFWH(SGJ11D,SGJ11D),SGTMP25);
SGTMP134:=SGTMP133>0;
SGJ11P:=IFELSE(SGTMP134,VALUEWHEN(SGKE10,SGTMP103),0);
SGJ11V:=SGKE10 AND SGJ11N>=2 AND SGJ11D>=SGTMP104 AND SGGC-REFWH(SGGC,SGJ11D)>=3 AND IFELSE(SGFT,SGMH>REFWH(SGJ11P,SGJ11D) AND SGMH>REFWH(SGMH,SGJ11D),REFWH(SGJ11P,SGJ11D)>SGML AND REFWH(SGMH,SGJ11D)>SGMH);
SGJ11C:=SGKE10 AND SGJ11N>=4 AND MOD(SGJ11N-1,3)=0 AND SGJ11A<=SGTMP99 AND COUNT(SGGX,SGJ11A+1)=0 AND REFWH(SGJ11V,SGJ11D)=0;
SGJ11K:=IFELSE(SGFT,SGMH>REFWH(SGMH,SGJ11A),SGML<REFWH(SGML,SGJ11A));
SGJ11B:=BACKSET(SGJ11C AND SGJ11K=0,SGJ11D+1);
SGJ11T:=BACKSET(SGJ11C AND SGJ11K,2)-BACKSET(SGJ11C AND SGJ11K,1)>0;
SGTMP135:=IFELSE(SGTMP134,BARSLAST(SGKE10),SGBN);
SGJ11R:=BACKSET(SGJ11T,MIN(SGTMP135+REFWH(SGJ11D,SGTMP135)+1,SGBN));
SGKE11:=SGKE10 AND SGJ11B=0 AND SGJ11R=0;
SGTMP136:=COUNT(SGKE11,0);
SGJ12N:=SGTMP136;
SGJ12D:=MIN(IFELSE(COUNT(REFWH(SGKE11,1),0)>0,BARSLAST(REFWH(SGKE11,1)),SGBN)+1,SGTMP25);
SGJ12A:=MIN(SGJ12D+REFWH(SGJ12D,SGJ12D),SGTMP25);
SGTMP137:=SGTMP136>0;
SGJ12P:=IFELSE(SGTMP137,VALUEWHEN(SGKE11,SGTMP103),0);
SGJ12V:=SGKE11 AND SGJ12N>=2 AND SGJ12D>=SGTMP104 AND SGGC-REFWH(SGGC,SGJ12D)>=3 AND IFELSE(SGFT,SGMH>REFWH(SGJ12P,SGJ12D) AND SGMH>REFWH(SGMH,SGJ12D),REFWH(SGJ12P,SGJ12D)>SGML AND REFWH(SGMH,SGJ12D)>SGMH);
SGJ12C:=SGKE11 AND SGJ12N>=5 AND MOD(SGJ12N-2,3)=0 AND SGJ12A<=SGTMP99 AND COUNT(SGGX,SGJ12A+1)=0 AND REFWH(SGJ12V,SGJ12D)=0;
SGJ12K:=IFELSE(SGFT,SGMH>REFWH(SGMH,SGJ12A),SGML<REFWH(SGML,SGJ12A));
SGJ12B:=BACKSET(SGJ12C AND SGJ12K=0,SGJ12D+1);
SGJ12T:=BACKSET(SGJ12C AND SGJ12K,2)-BACKSET(SGJ12C AND SGJ12K,1)>0;
SGTMP138:=IFELSE(SGTMP137,BARSLAST(SGKE11),SGBN);
SGJ12R:=BACKSET(SGJ12T,MIN(SGTMP138+REFWH(SGJ12D,SGTMP138)+1,SGBN));
SGKE12:=SGKE11 AND SGJ12B=0 AND SGJ12R=0;
SGPE:=SGKE12;
SGTMP139:=COUNT(SGPE,0);
SGPC:=SGTMP139;
SGTMP140:=SGTMP139>0;
SGPP:=IFELSE(SGTMP140,VALUEWHEN(SGPE,SGTMP103),0);
SGPH:=IFELSE(SGTMP140,VALUEWHEN(SGPE,SGMH),0);
SGD1:=MIN(IFELSE(COUNT(REFWH(SGPE,1),0)>0,BARSLAST(REFWH(SGPE,1)),SGBN)+1,SGTMP25);
SGD2:=MIN(SGD1+REFWH(SGD1,SGD1),SGTMP25);
SGD3:=MIN(SGD2+REFWH(SGD1,SGD2),SGTMP25);
SGP1:=REFWH(SGPP,SGD1);
SGP2:=REFWH(SGPP,SGD2);
SGP3:=REFWH(SGPP,SGD3);
SGTMP141:=SGD1+1;
SGPV:=SGPE AND SGPC>=2 AND SGD1>=SGTMP104 AND COUNT(SGGX,SGTMP141)=0 AND SGGC-REFWH(SGGC,SGD1)>=3 AND IFELSE(SGFT,SGMH>SGP1 AND SGMH>REFWH(SGPH,SGD1),SGP1>SGML AND REFWH(SGPH,SGD1)>SGMH);
SGTMP142:=SGPC>=3;
SGTMP143:=SGPV AND SGTMP142;
SGTMP144:=REFWH(SGPV,SGD1);
SGTMP145:=SGTMP143 AND SGTMP144;
SGTMP146:=REFWH(SGFT,SGD1);
SGTMP147:=SGFT<>SGTMP146;
SGTMP148:=SGTMP145 AND SGTMP147;
SGTMP149:=MOD(SGPC,2);
SGTMP150:=SGTMP149=0;
SGTMP151:=SGTMP148 AND SGTMP150;
SGWPC0:=BACKSET(SGTMP151,SGTMP141)-BACKSET(SGTMP151 AND SGD1>0,MAX(SGD1,1))>0;
SGTMP152:=SGTMP149=1;
SGTMP153:=SGTMP148 AND SGTMP152;
SGWPC1:=BACKSET(SGTMP153,SGTMP141)-BACKSET(SGTMP153 AND SGD1>0,MAX(SGD1,1))>0;
SGWPC:=SGWPC0 OR SGWPC1;
SGPCONF:=SGPV AND SGWPC;
SGPWAIT:=SGPV AND SGPCONF=0;
SGPG:=MIN(MIN(MAX(SGPP,SGP1),MAX(SGP1,SGP2)),MAX(SGP2,SGP3));
SGPD:=MAX(MAX(MIN(SGPP,SGP1),MIN(SGP1,SGP2)),MIN(SGP2,SGP3));
SGTMP154:=SGPC>=4;
SGTMP155:=SGPE AND SGTMP154;
SGSDUP:=SGTMP155 AND SGPP>SGP2 AND SGP1>SGP3;
SGSDDN:=SGTMP155 AND SGPP<SGP2 AND SGP1<SGP3;
SGTMP156:=SGPV=0;
SGTMP157:=SGPE AND SGTMP156;
SGSDE:=SGSDUP OR SGSDDN OR SGTMP157;
SGSDV:=IFELSE(COUNT(SGSDE,0)>0,VALUEWHEN(SGSDE,IFELSE(SGTMP157,0,IFELSE(SGSDUP,1,-(1)))),0);
SGTMP158:=REFWH(SGSDV,1);
SGSCHANGE:=SGSDE AND SGSDV<>SGTMP158;
SGTMP159:=COUNT(SGSCHANGE,0);
SGTMP160:=SGTMP159>0;
SGSRLEN:=IFELSE(SGTMP160,BARSLAST(SGSCHANGE),SGBN)+1;
SGSMAX:=HHV(SGPP,SGSRLEN);
SGSMIN:=LLV(SGPP,SGSRLEN);
SGWHREC:=SGPE AND SGFT AND SGSDV=1 AND (SGSCHANGE OR SGPP>REFWH(SGSMAX,1));
SGWLREC:=SGPE AND SGFB AND SGSDV=-(1) AND (SGSCHANGE OR SGPP<REFWH(SGSMIN,1));
SGWBEST:=IFELSE(COUNT(SGWHREC OR SGWLREC,0)>0,VALUEWHEN(SGWHREC OR SGWLREC,SGBN),0);
SGTMP161:=REFWH(SGWBEST,1);
SGTMP162:=IFELSE(SGTMP160,VALUEWHEN(SGSCHANGE,SGBN),0);
SGWRDONE:=SGSCHANGE AND SGTMP158<>0 AND SGTMP161>=REFWH(SGTMP162,1) AND SGTMP161>0;
SGWRDIST:=SGBN-SGTMP161;
SGWRNUM:=SGTMP159;
SGTMP163:=MOD(SGWRNUM,2);
SGTMP164:=SGTMP163=0;
SGTMP165:=SGWRDONE AND SGTMP164;
SGWPO0:=BACKSET(SGTMP165,SGWRDIST+1)-BACKSET(SGTMP165 AND SGWRDIST>0,MAX(SGWRDIST,1))>0;
SGTMP166:=SGTMP163=1;
SGTMP167:=SGWRDONE AND SGTMP166;
SGWPO1:=BACKSET(SGTMP167,SGWRDIST+1)-BACKSET(SGTMP167 AND SGWRDIST>0,MAX(SGWRDIST,1))>0;
SGWPOLD:=SGWPO0 OR SGWPO1;
SGWTAIL:=ISLASTBAR AND SGSDV<>0 AND SGWBEST>=SGTMP162;
SGWPDIST:=SGBN-SGWBEST;
SGWPNEW:=BACKSET(SGWTAIL,SGWPDIST+1)-BACKSET(SGWTAIL AND SGWPDIST>0,MAX(SGWPDIST,1))>0;
SGSPICK:=SGPE AND (SGWPOLD OR SGWPNEW);
SGWHBACK:=BACKSET(SGSCHANGE,SGBN);
SGSHASN:=IFELSE(ISLASTBAR,0,REFX(SGWHBACK,1));
SGSRSTART:=SGSCHANGE AND SGSDV<>0 AND SGTMP158=0 AND SGTMP154 AND COUNT(SGTMP157,SGD3)=0;
SGTMP168:=MOD(SGPC,4);
SGTMP169:=SGTMP168=0;
SGTMP170:=SGSRSTART AND SGTMP169;
SGTMP171:=SGD3+1;
SGTMP172:=SGD3>0;
SGTMP173:=MAX(SGD3,1);
SGSSEED0:=BACKSET(SGTMP170,SGTMP171)-BACKSET(SGTMP170 AND SGTMP172,SGTMP173)>0;
SGTMP174:=SGTMP168=1;
SGTMP175:=SGSRSTART AND SGTMP174;
SGSSEED1:=BACKSET(SGTMP175,SGTMP171)-BACKSET(SGTMP175 AND SGTMP172,SGTMP173)>0;
SGTMP176:=SGTMP168=2;
SGTMP177:=SGSRSTART AND SGTMP176;
SGSSEED2:=BACKSET(SGTMP177,SGTMP171)-BACKSET(SGTMP177 AND SGTMP172,SGTMP173)>0;
SGTMP178:=SGTMP168=3;
SGTMP179:=SGSRSTART AND SGTMP178;
SGSSEED3:=BACKSET(SGTMP179,SGTMP171)-BACKSET(SGTMP179 AND SGTMP172,SGTMP173)>0;
SGSSEED:=SGSSEED0 OR SGSSEED1 OR SGSSEED2 OR SGSSEED3;
SGSE0:=SGSPICK OR SGPE AND SGSSEED;
SGTMP180:=SGPG>SGPD;
SGTMP181:=SGTMP155 AND SGTMP180;
SGTMP182:=SGTMP181 AND SGTMP169;
SGSINIT0:=BACKSET(SGTMP182,SGTMP171)-BACKSET(SGTMP182 AND SGTMP172,SGTMP173)>0;
SGTMP183:=SGTMP181 AND SGTMP174;
SGSINIT1:=BACKSET(SGTMP183,SGTMP171)-BACKSET(SGTMP183 AND SGTMP172,SGTMP173)>0;
SGTMP184:=SGTMP181 AND SGTMP176;
SGSINIT2:=BACKSET(SGTMP184,SGTMP171)-BACKSET(SGTMP184 AND SGTMP172,SGTMP173)>0;
SGTMP185:=SGTMP181 AND SGTMP178;
SGSINIT3:=BACKSET(SGTMP185,SGTMP171)-BACKSET(SGTMP185 AND SGTMP172,SGTMP173)>0;
SGSINIT:=SGSINIT0 OR SGSINIT1 OR SGSINIT2 OR SGSINIT3;
SGTMP186:=COUNT(SGSE0,0);
SGQ1N:=SGTMP186;
SGQ1D:=MIN(IFELSE(COUNT(REFWH(SGSE0,1),0)>0,BARSLAST(REFWH(SGSE0,1)),SGBN)+1,SGTMP25);
SGQ1A:=MIN(SGQ1D+REFWH(SGQ1D,SGQ1D),SGTMP25);
SGTMP187:=SGTMP186>0;
SGQ1P:=IFELSE(SGTMP187,VALUEWHEN(SGSE0,SGPP),0);
SGQ1V:=SGSE0 AND SGQ1N>=2 AND SGPC-REFWH(SGPC,SGQ1D)>=3 AND SGFT<>REFWH(SGFT,SGQ1D) AND COUNT(SGTMP157,SGQ1D)=0 AND REFWH(SGSINIT,SGQ1D) AND IFELSE(SGFT,SGPP>REFWH(SGQ1P,SGQ1D),SGPP<REFWH(SGQ1P,SGQ1D));
SGQ1C:=SGSE0 AND SGQ1N>=3 AND MOD(SGQ1N-0,3)=0 AND SGFT=REFWH(SGFT,SGQ1A) AND COUNT(SGTMP157,SGQ1A)=0 AND REFWH(SGQ1V,SGQ1D)=0;
SGQ1K:=REFWH(SGSINIT,SGQ1A)=0 OR IFELSE(SGFT,SGPP>REFWH(SGPP,SGQ1A),SGPP<REFWH(SGPP,SGQ1A));
SGQ1B:=BACKSET(SGQ1C AND SGQ1K=0,SGQ1D+1);
SGQ1T:=BACKSET(SGQ1C AND SGQ1K,2)-BACKSET(SGQ1C AND SGQ1K,1)>0;
SGTMP188:=IFELSE(SGTMP187,BARSLAST(SGSE0),SGBN);
SGQ1R:=BACKSET(SGQ1T,MIN(SGTMP188+REFWH(SGQ1D,SGTMP188)+1,SGBN));
SGSE1:=SGSE0 AND SGQ1B=0 AND SGQ1R=0;
SGTMP189:=COUNT(SGSE1,0);
SGQ2N:=SGTMP189;
SGQ2D:=MIN(IFELSE(COUNT(REFWH(SGSE1,1),0)>0,BARSLAST(REFWH(SGSE1,1)),SGBN)+1,SGTMP25);
SGQ2A:=MIN(SGQ2D+REFWH(SGQ2D,SGQ2D),SGTMP25);
SGTMP190:=SGTMP189>0;
SGQ2P:=IFELSE(SGTMP190,VALUEWHEN(SGSE1,SGPP),0);
SGQ2V:=SGSE1 AND SGQ2N>=2 AND SGPC-REFWH(SGPC,SGQ2D)>=3 AND SGFT<>REFWH(SGFT,SGQ2D) AND COUNT(SGTMP157,SGQ2D)=0 AND REFWH(SGSINIT,SGQ2D) AND IFELSE(SGFT,SGPP>REFWH(SGQ2P,SGQ2D),SGPP<REFWH(SGQ2P,SGQ2D));
SGQ2C:=SGSE1 AND SGQ2N>=4 AND MOD(SGQ2N-1,3)=0 AND SGFT=REFWH(SGFT,SGQ2A) AND COUNT(SGTMP157,SGQ2A)=0 AND REFWH(SGQ2V,SGQ2D)=0;
SGQ2K:=REFWH(SGSINIT,SGQ2A)=0 OR IFELSE(SGFT,SGPP>REFWH(SGPP,SGQ2A),SGPP<REFWH(SGPP,SGQ2A));
SGQ2B:=BACKSET(SGQ2C AND SGQ2K=0,SGQ2D+1);
SGQ2T:=BACKSET(SGQ2C AND SGQ2K,2)-BACKSET(SGQ2C AND SGQ2K,1)>0;
SGTMP191:=IFELSE(SGTMP190,BARSLAST(SGSE1),SGBN);
SGQ2R:=BACKSET(SGQ2T,MIN(SGTMP191+REFWH(SGQ2D,SGTMP191)+1,SGBN));
SGSE2:=SGSE1 AND SGQ2B=0 AND SGQ2R=0;
SGTMP192:=COUNT(SGSE2,0);
SGQ3N:=SGTMP192;
SGQ3D:=MIN(IFELSE(COUNT(REFWH(SGSE2,1),0)>0,BARSLAST(REFWH(SGSE2,1)),SGBN)+1,SGTMP25);
SGQ3A:=MIN(SGQ3D+REFWH(SGQ3D,SGQ3D),SGTMP25);
SGTMP193:=SGTMP192>0;
SGQ3P:=IFELSE(SGTMP193,VALUEWHEN(SGSE2,SGPP),0);
SGQ3V:=SGSE2 AND SGQ3N>=2 AND SGPC-REFWH(SGPC,SGQ3D)>=3 AND SGFT<>REFWH(SGFT,SGQ3D) AND COUNT(SGTMP157,SGQ3D)=0 AND REFWH(SGSINIT,SGQ3D) AND IFELSE(SGFT,SGPP>REFWH(SGQ3P,SGQ3D),SGPP<REFWH(SGQ3P,SGQ3D));
SGQ3C:=SGSE2 AND SGQ3N>=5 AND MOD(SGQ3N-2,3)=0 AND SGFT=REFWH(SGFT,SGQ3A) AND COUNT(SGTMP157,SGQ3A)=0 AND REFWH(SGQ3V,SGQ3D)=0;
SGQ3K:=REFWH(SGSINIT,SGQ3A)=0 OR IFELSE(SGFT,SGPP>REFWH(SGPP,SGQ3A),SGPP<REFWH(SGPP,SGQ3A));
SGQ3B:=BACKSET(SGQ3C AND SGQ3K=0,SGQ3D+1);
SGQ3T:=BACKSET(SGQ3C AND SGQ3K,2)-BACKSET(SGQ3C AND SGQ3K,1)>0;
SGTMP194:=IFELSE(SGTMP193,BARSLAST(SGSE2),SGBN);
SGQ3R:=BACKSET(SGQ3T,MIN(SGTMP194+REFWH(SGQ3D,SGTMP194)+1,SGBN));
SGSE3:=SGSE2 AND SGQ3B=0 AND SGQ3R=0;
SGTMP195:=COUNT(SGSE3,0);
SGQ4N:=SGTMP195;
SGQ4D:=MIN(IFELSE(COUNT(REFWH(SGSE3,1),0)>0,BARSLAST(REFWH(SGSE3,1)),SGBN)+1,SGTMP25);
SGQ4A:=MIN(SGQ4D+REFWH(SGQ4D,SGQ4D),SGTMP25);
SGTMP196:=SGTMP195>0;
SGQ4P:=IFELSE(SGTMP196,VALUEWHEN(SGSE3,SGPP),0);
SGQ4V:=SGSE3 AND SGQ4N>=2 AND SGPC-REFWH(SGPC,SGQ4D)>=3 AND SGFT<>REFWH(SGFT,SGQ4D) AND COUNT(SGTMP157,SGQ4D)=0 AND REFWH(SGSINIT,SGQ4D) AND IFELSE(SGFT,SGPP>REFWH(SGQ4P,SGQ4D),SGPP<REFWH(SGQ4P,SGQ4D));
SGQ4C:=SGSE3 AND SGQ4N>=3 AND MOD(SGQ4N-0,3)=0 AND SGFT=REFWH(SGFT,SGQ4A) AND COUNT(SGTMP157,SGQ4A)=0 AND REFWH(SGQ4V,SGQ4D)=0;
SGQ4K:=REFWH(SGSINIT,SGQ4A)=0 OR IFELSE(SGFT,SGPP>REFWH(SGPP,SGQ4A),SGPP<REFWH(SGPP,SGQ4A));
SGQ4B:=BACKSET(SGQ4C AND SGQ4K=0,SGQ4D+1);
SGQ4T:=BACKSET(SGQ4C AND SGQ4K,2)-BACKSET(SGQ4C AND SGQ4K,1)>0;
SGTMP197:=IFELSE(SGTMP196,BARSLAST(SGSE3),SGBN);
SGQ4R:=BACKSET(SGQ4T,MIN(SGTMP197+REFWH(SGQ4D,SGTMP197)+1,SGBN));
SGSE4:=SGSE3 AND SGQ4B=0 AND SGQ4R=0;
SGTMP198:=COUNT(SGSE4,0);
SGQ5N:=SGTMP198;
SGQ5D:=MIN(IFELSE(COUNT(REFWH(SGSE4,1),0)>0,BARSLAST(REFWH(SGSE4,1)),SGBN)+1,SGTMP25);
SGQ5A:=MIN(SGQ5D+REFWH(SGQ5D,SGQ5D),SGTMP25);
SGTMP199:=SGTMP198>0;
SGQ5P:=IFELSE(SGTMP199,VALUEWHEN(SGSE4,SGPP),0);
SGQ5V:=SGSE4 AND SGQ5N>=2 AND SGPC-REFWH(SGPC,SGQ5D)>=3 AND SGFT<>REFWH(SGFT,SGQ5D) AND COUNT(SGTMP157,SGQ5D)=0 AND REFWH(SGSINIT,SGQ5D) AND IFELSE(SGFT,SGPP>REFWH(SGQ5P,SGQ5D),SGPP<REFWH(SGQ5P,SGQ5D));
SGQ5C:=SGSE4 AND SGQ5N>=4 AND MOD(SGQ5N-1,3)=0 AND SGFT=REFWH(SGFT,SGQ5A) AND COUNT(SGTMP157,SGQ5A)=0 AND REFWH(SGQ5V,SGQ5D)=0;
SGQ5K:=REFWH(SGSINIT,SGQ5A)=0 OR IFELSE(SGFT,SGPP>REFWH(SGPP,SGQ5A),SGPP<REFWH(SGPP,SGQ5A));
SGQ5B:=BACKSET(SGQ5C AND SGQ5K=0,SGQ5D+1);
SGQ5T:=BACKSET(SGQ5C AND SGQ5K,2)-BACKSET(SGQ5C AND SGQ5K,1)>0;
SGTMP200:=IFELSE(SGTMP199,BARSLAST(SGSE4),SGBN);
SGQ5R:=BACKSET(SGQ5T,MIN(SGTMP200+REFWH(SGQ5D,SGTMP200)+1,SGBN));
SGSE5:=SGSE4 AND SGQ5B=0 AND SGQ5R=0;
SGTMP201:=COUNT(SGSE5,0);
SGQ6N:=SGTMP201;
SGQ6D:=MIN(IFELSE(COUNT(REFWH(SGSE5,1),0)>0,BARSLAST(REFWH(SGSE5,1)),SGBN)+1,SGTMP25);
SGQ6A:=MIN(SGQ6D+REFWH(SGQ6D,SGQ6D),SGTMP25);
SGTMP202:=SGTMP201>0;
SGQ6P:=IFELSE(SGTMP202,VALUEWHEN(SGSE5,SGPP),0);
SGQ6V:=SGSE5 AND SGQ6N>=2 AND SGPC-REFWH(SGPC,SGQ6D)>=3 AND SGFT<>REFWH(SGFT,SGQ6D) AND COUNT(SGTMP157,SGQ6D)=0 AND REFWH(SGSINIT,SGQ6D) AND IFELSE(SGFT,SGPP>REFWH(SGQ6P,SGQ6D),SGPP<REFWH(SGQ6P,SGQ6D));
SGQ6C:=SGSE5 AND SGQ6N>=5 AND MOD(SGQ6N-2,3)=0 AND SGFT=REFWH(SGFT,SGQ6A) AND COUNT(SGTMP157,SGQ6A)=0 AND REFWH(SGQ6V,SGQ6D)=0;
SGQ6K:=REFWH(SGSINIT,SGQ6A)=0 OR IFELSE(SGFT,SGPP>REFWH(SGPP,SGQ6A),SGPP<REFWH(SGPP,SGQ6A));
SGQ6B:=BACKSET(SGQ6C AND SGQ6K=0,SGQ6D+1);
SGQ6T:=BACKSET(SGQ6C AND SGQ6K,2)-BACKSET(SGQ6C AND SGQ6K,1)>0;
SGTMP203:=IFELSE(SGTMP202,BARSLAST(SGSE5),SGBN);
SGQ6R:=BACKSET(SGQ6T,MIN(SGTMP203+REFWH(SGQ6D,SGTMP203)+1,SGBN));
SGSE6:=SGSE5 AND SGQ6B=0 AND SGQ6R=0;
SGTMP204:=COUNT(SGSE6,0);
SGQ7N:=SGTMP204;
SGQ7D:=MIN(IFELSE(COUNT(REFWH(SGSE6,1),0)>0,BARSLAST(REFWH(SGSE6,1)),SGBN)+1,SGTMP25);
SGQ7A:=MIN(SGQ7D+REFWH(SGQ7D,SGQ7D),SGTMP25);
SGTMP205:=SGTMP204>0;
SGQ7P:=IFELSE(SGTMP205,VALUEWHEN(SGSE6,SGPP),0);
SGQ7V:=SGSE6 AND SGQ7N>=2 AND SGPC-REFWH(SGPC,SGQ7D)>=3 AND SGFT<>REFWH(SGFT,SGQ7D) AND COUNT(SGTMP157,SGQ7D)=0 AND REFWH(SGSINIT,SGQ7D) AND IFELSE(SGFT,SGPP>REFWH(SGQ7P,SGQ7D),SGPP<REFWH(SGQ7P,SGQ7D));
SGQ7C:=SGSE6 AND SGQ7N>=3 AND MOD(SGQ7N-0,3)=0 AND SGFT=REFWH(SGFT,SGQ7A) AND COUNT(SGTMP157,SGQ7A)=0 AND REFWH(SGQ7V,SGQ7D)=0;
SGQ7K:=REFWH(SGSINIT,SGQ7A)=0 OR IFELSE(SGFT,SGPP>REFWH(SGPP,SGQ7A),SGPP<REFWH(SGPP,SGQ7A));
SGQ7B:=BACKSET(SGQ7C AND SGQ7K=0,SGQ7D+1);
SGQ7T:=BACKSET(SGQ7C AND SGQ7K,2)-BACKSET(SGQ7C AND SGQ7K,1)>0;
SGTMP206:=IFELSE(SGTMP205,BARSLAST(SGSE6),SGBN);
SGQ7R:=BACKSET(SGQ7T,MIN(SGTMP206+REFWH(SGQ7D,SGTMP206)+1,SGBN));
SGSE7:=SGSE6 AND SGQ7B=0 AND SGQ7R=0;
SGTMP207:=COUNT(SGSE7,0);
SGQ8N:=SGTMP207;
SGQ8D:=MIN(IFELSE(COUNT(REFWH(SGSE7,1),0)>0,BARSLAST(REFWH(SGSE7,1)),SGBN)+1,SGTMP25);
SGQ8A:=MIN(SGQ8D+REFWH(SGQ8D,SGQ8D),SGTMP25);
SGTMP208:=SGTMP207>0;
SGQ8P:=IFELSE(SGTMP208,VALUEWHEN(SGSE7,SGPP),0);
SGQ8V:=SGSE7 AND SGQ8N>=2 AND SGPC-REFWH(SGPC,SGQ8D)>=3 AND SGFT<>REFWH(SGFT,SGQ8D) AND COUNT(SGTMP157,SGQ8D)=0 AND REFWH(SGSINIT,SGQ8D) AND IFELSE(SGFT,SGPP>REFWH(SGQ8P,SGQ8D),SGPP<REFWH(SGQ8P,SGQ8D));
SGQ8C:=SGSE7 AND SGQ8N>=4 AND MOD(SGQ8N-1,3)=0 AND SGFT=REFWH(SGFT,SGQ8A) AND COUNT(SGTMP157,SGQ8A)=0 AND REFWH(SGQ8V,SGQ8D)=0;
SGQ8K:=REFWH(SGSINIT,SGQ8A)=0 OR IFELSE(SGFT,SGPP>REFWH(SGPP,SGQ8A),SGPP<REFWH(SGPP,SGQ8A));
SGQ8B:=BACKSET(SGQ8C AND SGQ8K=0,SGQ8D+1);
SGQ8T:=BACKSET(SGQ8C AND SGQ8K,2)-BACKSET(SGQ8C AND SGQ8K,1)>0;
SGTMP209:=IFELSE(SGTMP208,BARSLAST(SGSE7),SGBN);
SGQ8R:=BACKSET(SGQ8T,MIN(SGTMP209+REFWH(SGQ8D,SGTMP209)+1,SGBN));
SGSE8:=SGSE7 AND SGQ8B=0 AND SGQ8R=0;
SGTMP210:=COUNT(SGSE8,0);
SGQ9N:=SGTMP210;
SGQ9D:=MIN(IFELSE(COUNT(REFWH(SGSE8,1),0)>0,BARSLAST(REFWH(SGSE8,1)),SGBN)+1,SGTMP25);
SGQ9A:=MIN(SGQ9D+REFWH(SGQ9D,SGQ9D),SGTMP25);
SGTMP211:=SGTMP210>0;
SGQ9P:=IFELSE(SGTMP211,VALUEWHEN(SGSE8,SGPP),0);
SGQ9V:=SGSE8 AND SGQ9N>=2 AND SGPC-REFWH(SGPC,SGQ9D)>=3 AND SGFT<>REFWH(SGFT,SGQ9D) AND COUNT(SGTMP157,SGQ9D)=0 AND REFWH(SGSINIT,SGQ9D) AND IFELSE(SGFT,SGPP>REFWH(SGQ9P,SGQ9D),SGPP<REFWH(SGQ9P,SGQ9D));
SGQ9C:=SGSE8 AND SGQ9N>=5 AND MOD(SGQ9N-2,3)=0 AND SGFT=REFWH(SGFT,SGQ9A) AND COUNT(SGTMP157,SGQ9A)=0 AND REFWH(SGQ9V,SGQ9D)=0;
SGQ9K:=REFWH(SGSINIT,SGQ9A)=0 OR IFELSE(SGFT,SGPP>REFWH(SGPP,SGQ9A),SGPP<REFWH(SGPP,SGQ9A));
SGQ9B:=BACKSET(SGQ9C AND SGQ9K=0,SGQ9D+1);
SGQ9T:=BACKSET(SGQ9C AND SGQ9K,2)-BACKSET(SGQ9C AND SGQ9K,1)>0;
SGTMP212:=IFELSE(SGTMP211,BARSLAST(SGSE8),SGBN);
SGQ9R:=BACKSET(SGQ9T,MIN(SGTMP212+REFWH(SGQ9D,SGTMP212)+1,SGBN));
SGSE9:=SGSE8 AND SGQ9B=0 AND SGQ9R=0;
SGTMP213:=COUNT(SGSE9,0);
SGQ10N:=SGTMP213;
SGQ10D:=MIN(IFELSE(COUNT(REFWH(SGSE9,1),0)>0,BARSLAST(REFWH(SGSE9,1)),SGBN)+1,SGTMP25);
SGQ10A:=MIN(SGQ10D+REFWH(SGQ10D,SGQ10D),SGTMP25);
SGTMP214:=SGTMP213>0;
SGQ10P:=IFELSE(SGTMP214,VALUEWHEN(SGSE9,SGPP),0);
SGQ10V:=SGSE9 AND SGQ10N>=2 AND SGPC-REFWH(SGPC,SGQ10D)>=3 AND SGFT<>REFWH(SGFT,SGQ10D) AND COUNT(SGTMP157,SGQ10D)=0 AND REFWH(SGSINIT,SGQ10D) AND IFELSE(SGFT,SGPP>REFWH(SGQ10P,SGQ10D),SGPP<REFWH(SGQ10P,SGQ10D));
SGQ10C:=SGSE9 AND SGQ10N>=3 AND MOD(SGQ10N-0,3)=0 AND SGFT=REFWH(SGFT,SGQ10A) AND COUNT(SGTMP157,SGQ10A)=0 AND REFWH(SGQ10V,SGQ10D)=0;
SGQ10K:=REFWH(SGSINIT,SGQ10A)=0 OR IFELSE(SGFT,SGPP>REFWH(SGPP,SGQ10A),SGPP<REFWH(SGPP,SGQ10A));
SGQ10B:=BACKSET(SGQ10C AND SGQ10K=0,SGQ10D+1);
SGQ10T:=BACKSET(SGQ10C AND SGQ10K,2)-BACKSET(SGQ10C AND SGQ10K,1)>0;
SGTMP215:=IFELSE(SGTMP214,BARSLAST(SGSE9),SGBN);
SGQ10R:=BACKSET(SGQ10T,MIN(SGTMP215+REFWH(SGQ10D,SGTMP215)+1,SGBN));
SGSE10:=SGSE9 AND SGQ10B=0 AND SGQ10R=0;
SGTMP216:=COUNT(SGSE10,0);
SGQ11N:=SGTMP216;
SGQ11D:=MIN(IFELSE(COUNT(REFWH(SGSE10,1),0)>0,BARSLAST(REFWH(SGSE10,1)),SGBN)+1,SGTMP25);
SGQ11A:=MIN(SGQ11D+REFWH(SGQ11D,SGQ11D),SGTMP25);
SGTMP217:=SGTMP216>0;
SGQ11P:=IFELSE(SGTMP217,VALUEWHEN(SGSE10,SGPP),0);
SGQ11V:=SGSE10 AND SGQ11N>=2 AND SGPC-REFWH(SGPC,SGQ11D)>=3 AND SGFT<>REFWH(SGFT,SGQ11D) AND COUNT(SGTMP157,SGQ11D)=0 AND REFWH(SGSINIT,SGQ11D) AND IFELSE(SGFT,SGPP>REFWH(SGQ11P,SGQ11D),SGPP<REFWH(SGQ11P,SGQ11D));
SGQ11C:=SGSE10 AND SGQ11N>=4 AND MOD(SGQ11N-1,3)=0 AND SGFT=REFWH(SGFT,SGQ11A) AND COUNT(SGTMP157,SGQ11A)=0 AND REFWH(SGQ11V,SGQ11D)=0;
SGQ11K:=REFWH(SGSINIT,SGQ11A)=0 OR IFELSE(SGFT,SGPP>REFWH(SGPP,SGQ11A),SGPP<REFWH(SGPP,SGQ11A));
SGQ11B:=BACKSET(SGQ11C AND SGQ11K=0,SGQ11D+1);
SGQ11T:=BACKSET(SGQ11C AND SGQ11K,2)-BACKSET(SGQ11C AND SGQ11K,1)>0;
SGTMP218:=IFELSE(SGTMP217,BARSLAST(SGSE10),SGBN);
SGQ11R:=BACKSET(SGQ11T,MIN(SGTMP218+REFWH(SGQ11D,SGTMP218)+1,SGBN));
SGSE11:=SGSE10 AND SGQ11B=0 AND SGQ11R=0;
SGTMP219:=COUNT(SGSE11,0);
SGQ12N:=SGTMP219;
SGQ12D:=MIN(IFELSE(COUNT(REFWH(SGSE11,1),0)>0,BARSLAST(REFWH(SGSE11,1)),SGBN)+1,SGTMP25);
SGQ12A:=MIN(SGQ12D+REFWH(SGQ12D,SGQ12D),SGTMP25);
SGTMP220:=SGTMP219>0;
SGQ12P:=IFELSE(SGTMP220,VALUEWHEN(SGSE11,SGPP),0);
SGQ12V:=SGSE11 AND SGQ12N>=2 AND SGPC-REFWH(SGPC,SGQ12D)>=3 AND SGFT<>REFWH(SGFT,SGQ12D) AND COUNT(SGTMP157,SGQ12D)=0 AND REFWH(SGSINIT,SGQ12D) AND IFELSE(SGFT,SGPP>REFWH(SGQ12P,SGQ12D),SGPP<REFWH(SGQ12P,SGQ12D));
SGQ12C:=SGSE11 AND SGQ12N>=5 AND MOD(SGQ12N-2,3)=0 AND SGFT=REFWH(SGFT,SGQ12A) AND COUNT(SGTMP157,SGQ12A)=0 AND REFWH(SGQ12V,SGQ12D)=0;
SGQ12K:=REFWH(SGSINIT,SGQ12A)=0 OR IFELSE(SGFT,SGPP>REFWH(SGPP,SGQ12A),SGPP<REFWH(SGPP,SGQ12A));
SGQ12B:=BACKSET(SGQ12C AND SGQ12K=0,SGQ12D+1);
SGQ12T:=BACKSET(SGQ12C AND SGQ12K,2)-BACKSET(SGQ12C AND SGQ12K,1)>0;
SGTMP221:=IFELSE(SGTMP220,BARSLAST(SGSE11),SGBN);
SGQ12R:=BACKSET(SGQ12T,MIN(SGTMP221+REFWH(SGQ12D,SGTMP221)+1,SGBN));
SGSE12:=SGSE11 AND SGQ12B=0 AND SGQ12R=0;
SGSA:=SGSE12;
SGTMP222:=REFWH(SGSA,1);
SGTMP223:=COUNT(SGTMP222,0);
SGTMP224:=SGTMP223>0;
SGTMP225:=BARSLAST(SGTMP222);
SGTMP226:=IFELSE(SGTMP224,SGTMP225,SGBN);
SGTMP227:=SGTMP226+1;
SGTMP228:=MIN(SGTMP227,SGTMP25);
SGSXD:=SGTMP228;
SGTMP229:=REFWH(SGPP,SGSXD);
SGSVALID:=SGSA AND COUNT(SGSA,0)>=2 AND SGPC-REFWH(SGPC,SGSXD)>=3 AND SGFT<>REFWH(SGFT,SGSXD) AND COUNT(SGTMP157,SGSXD)=0 AND REFWH(SGSINIT,SGSXD) AND IFELSE(SGFT,SGPP>SGTMP229,SGPP<SGTMP229);
SGSV:=SGSVALID AND SGSHASN;
SGSPEND:=SGSVALID AND SGSHASN=0 AND SGSPICK;
SGSH:=MAX(HHV(H,SGSXD+1),MAX(SGPP,SGTMP229));
SGSL:=MIN(LLV(L,SGSXD+1),MIN(SGPP,SGTMP229));
SGSC:=COUNT(SGSA,0);
SGE1:=SGTMP228;
SGE2:=MIN(SGE1+REFWH(SGE1,SGE1),SGTMP25);
SGE3:=MIN(SGE2+REFWH(SGE1,SGE2),SGTMP25);
SGZG0:=MIN(SGSH,MIN(REFWH(SGSH,SGE1),REFWH(SGSH,SGE2)));
SGZD0:=MAX(SGSL,MAX(REFWH(SGSL,SGE1),REFWH(SGSL,SGE2)));
SGZC:=SGSA AND SGSC>=4 AND SGSV AND REFWH(SGSV,SGE1) AND REFWH(SGSV,SGE2) AND SGZG0>SGZD0;
SGZRESET:=SGSA AND (SGSV=0 OR SGSC>=4 AND (SGZG0<=SGZD0 OR REFWH(SGZC,SGE1) AND (SGZG0<REFWH(SGZD0,SGE1) OR SGZD0>REFWH(SGZG0,SGE1))));
SGTMP230:=COUNT(SGZRESET,0)>0;
SGZRANGE:=IFELSE(SGTMP230,BARSLAST(SGZRESET),SGBN)+1;
SGZELIG:=SGZC AND SGSC-IFELSE(SGTMP230,VALUEWHEN(SGZRESET,SGSC),0)>=3;
SGZSTART:=SGZELIG AND COUNT(SGZELIG,SGZRANGE)=1;
SGTMP231:=COUNT(SGZSTART,0);
SGTMP232:=SGTMP231>0;
SGZID:=IFELSE(SGTMP232,VALUEWHEN(SGZSTART,SGBN),0);
SGZLEFT:=IFELSE(SGTMP232,VALUEWHEN(SGZSTART,SGBN-SGE3),0);
SGZGH:=IFELSE(SGTMP232,VALUEWHEN(SGZSTART,SGZG0),0);
SGZDL:=IFELSE(SGTMP232,VALUEWHEN(SGZSTART,SGZD0),0);
SGZSEE:=COUNT(SGZSTART,SGZRANGE)>0;
SGZBAD:=SGSA AND SGZSEE AND SGBN>SGZID AND (SGSV=0 OR SGSH<SGZDL OR SGSL>SGZGH);
SGZOK:=SGZSEE AND COUNT(SGZBAD,SGZRANGE)=0;
SGZEND:=SGZBAD AND COUNT(SGZBAD,SGZRANGE)=1 OR SGZRESET AND REFWH(SGZOK,1);
SGZMEM:=SGSA AND SGSV AND SGZOK;
SGTMP233:=COUNT(SGZMEM,0)>0;
SGWZM:=IFELSE(SGTMP233,VALUEWHEN(SGZMEM,SGBN),0);
SGWZEND:=(SGZEND OR ISLASTBAR) AND SGTMP233;
SGTMP234:=SGBN-SGWZM;
SGWZF:=BACKSET(SGWZEND,SGTMP234+1)-BACKSET(SGWZEND AND SGTMP234>0,MAX(SGTMP234,1))>0;
SGWZLAST:=SGZMEM AND SGWZF;
SGWZI0:=IFELSE(SGWZLAST,SGBN,0);
SGWZL0:=IFELSE(SGWZLAST,SGZLEFT,0);
SGWZU0:=IFELSE(SGWZLAST,SGZGH,0);
SGWZD0:=IFELSE(SGWZLAST,SGZDL,0);
SGWZA1:=SGWZI0=0 AND IFELSE(REFX(SGWZI0,1)>0,1,0);
SGWZI1:=IFELSE(SGWZA1,REFX(SGWZI0,1),SGWZI0);
SGWZL1:=IFELSE(SGWZA1,REFX(SGWZL0,1),SGWZL0);
SGWZU1:=IFELSE(SGWZA1,REFX(SGWZU0,1),SGWZU0);
SGWZD1:=IFELSE(SGWZA1,REFX(SGWZD0,1),SGWZD0);
SGWZA2:=SGWZI1=0 AND IFELSE(REFX(SGWZI1,2)>0,1,0);
SGWZI2:=IFELSE(SGWZA2,REFX(SGWZI1,2),SGWZI1);
SGWZL2:=IFELSE(SGWZA2,REFX(SGWZL1,2),SGWZL1);
SGWZU2:=IFELSE(SGWZA2,REFX(SGWZU1,2),SGWZU1);
SGWZD2:=IFELSE(SGWZA2,REFX(SGWZD1,2),SGWZD1);
SGWZA3:=SGWZI2=0 AND IFELSE(REFX(SGWZI2,4)>0,1,0);
SGWZI3:=IFELSE(SGWZA3,REFX(SGWZI2,4),SGWZI2);
SGWZL3:=IFELSE(SGWZA3,REFX(SGWZL2,4),SGWZL2);
SGWZU3:=IFELSE(SGWZA3,REFX(SGWZU2,4),SGWZU2);
SGWZD3:=IFELSE(SGWZA3,REFX(SGWZD2,4),SGWZD2);
SGWZA4:=SGWZI3=0 AND IFELSE(REFX(SGWZI3,8)>0,1,0);
SGWZI4:=IFELSE(SGWZA4,REFX(SGWZI3,8),SGWZI3);
SGWZL4:=IFELSE(SGWZA4,REFX(SGWZL3,8),SGWZL3);
SGWZU4:=IFELSE(SGWZA4,REFX(SGWZU3,8),SGWZU3);
SGWZD4:=IFELSE(SGWZA4,REFX(SGWZD3,8),SGWZD3);
SGWZA5:=SGWZI4=0 AND IFELSE(REFX(SGWZI4,16)>0,1,0);
SGWZI5:=IFELSE(SGWZA5,REFX(SGWZI4,16),SGWZI4);
SGWZL5:=IFELSE(SGWZA5,REFX(SGWZL4,16),SGWZL4);
SGWZU5:=IFELSE(SGWZA5,REFX(SGWZU4,16),SGWZU4);
SGWZD5:=IFELSE(SGWZA5,REFX(SGWZD4,16),SGWZD4);
SGWZA6:=SGWZI5=0 AND IFELSE(REFX(SGWZI5,32)>0,1,0);
SGWZI6:=IFELSE(SGWZA6,REFX(SGWZI5,32),SGWZI5);
SGWZL6:=IFELSE(SGWZA6,REFX(SGWZL5,32),SGWZL5);
SGWZU6:=IFELSE(SGWZA6,REFX(SGWZU5,32),SGWZU5);
SGWZD6:=IFELSE(SGWZA6,REFX(SGWZD5,32),SGWZD5);
SGWZA7:=SGWZI6=0 AND IFELSE(REFX(SGWZI6,64)>0,1,0);
SGWZI7:=IFELSE(SGWZA7,REFX(SGWZI6,64),SGWZI6);
SGWZL7:=IFELSE(SGWZA7,REFX(SGWZL6,64),SGWZL6);
SGWZU7:=IFELSE(SGWZA7,REFX(SGWZU6,64),SGWZU6);
SGWZD7:=IFELSE(SGWZA7,REFX(SGWZD6,64),SGWZD6);
SGWZA8:=SGWZI7=0 AND IFELSE(REFX(SGWZI7,128)>0,1,0);
SGWZI8:=IFELSE(SGWZA8,REFX(SGWZI7,128),SGWZI7);
SGWZL8:=IFELSE(SGWZA8,REFX(SGWZL7,128),SGWZL7);
SGWZU8:=IFELSE(SGWZA8,REFX(SGWZU7,128),SGWZU7);
SGWZD8:=IFELSE(SGWZA8,REFX(SGWZD7,128),SGWZD7);
SGWZA9:=SGWZI8=0 AND IFELSE(REFX(SGWZI8,256)>0,1,0);
SGWZI9:=IFELSE(SGWZA9,REFX(SGWZI8,256),SGWZI8);
SGWZL9:=IFELSE(SGWZA9,REFX(SGWZL8,256),SGWZL8);
SGWZU9:=IFELSE(SGWZA9,REFX(SGWZU8,256),SGWZU8);
SGWZD9:=IFELSE(SGWZA9,REFX(SGWZD8,256),SGWZD8);
SGWZA10:=SGWZI9=0 AND IFELSE(REFX(SGWZI9,512)>0,1,0);
SGWZI10:=IFELSE(SGWZA10,REFX(SGWZI9,512),SGWZI9);
SGWZL10:=IFELSE(SGWZA10,REFX(SGWZL9,512),SGWZL9);
SGWZU10:=IFELSE(SGWZA10,REFX(SGWZU9,512),SGWZU9);
SGWZD10:=IFELSE(SGWZA10,REFX(SGWZD9,512),SGWZD9);
SGWZA11:=SGWZI10=0 AND IFELSE(REFX(SGWZI10,1024)>0,1,0);
SGWZI11:=IFELSE(SGWZA11,REFX(SGWZI10,1024),SGWZI10);
SGWZL11:=IFELSE(SGWZA11,REFX(SGWZL10,1024),SGWZL10);
SGWZU11:=IFELSE(SGWZA11,REFX(SGWZU10,1024),SGWZU10);
SGWZD11:=IFELSE(SGWZA11,REFX(SGWZD10,1024),SGWZD10);
SGWZA12:=SGWZI11=0 AND IFELSE(REFX(SGWZI11,2048)>0,1,0);
SGWZI12:=IFELSE(SGWZA12,REFX(SGWZI11,2048),SGWZI11);
SGWZL12:=IFELSE(SGWZA12,REFX(SGWZL11,2048),SGWZL11);
SGWZU12:=IFELSE(SGWZA12,REFX(SGWZU11,2048),SGWZU11);
SGWZD12:=IFELSE(SGWZA12,REFX(SGWZD11,2048),SGWZD11);
SGWZA13:=SGWZI12=0 AND IFELSE(REFX(SGWZI12,4096)>0,1,0);
SGWZI13:=IFELSE(SGWZA13,REFX(SGWZI12,4096),SGWZI12);
SGWZL13:=IFELSE(SGWZA13,REFX(SGWZL12,4096),SGWZL12);
SGWZU13:=IFELSE(SGWZA13,REFX(SGWZU12,4096),SGWZU12);
SGWZD13:=IFELSE(SGWZA13,REFX(SGWZD12,4096),SGWZD12);
SGWZA14:=SGWZI13=0 AND IFELSE(REFX(SGWZI13,8192)>0,1,0);
SGWZI14:=IFELSE(SGWZA14,REFX(SGWZI13,8192),SGWZI13);
SGWZL14:=IFELSE(SGWZA14,REFX(SGWZL13,8192),SGWZL13);
SGWZU14:=IFELSE(SGWZA14,REFX(SGWZU13,8192),SGWZU13);
SGWZD14:=IFELSE(SGWZA14,REFX(SGWZD13,8192),SGWZD13);
SGWZA15:=SGWZI14=0 AND IFELSE(REFX(SGWZI14,16384)>0,1,0);
SGWZI15:=IFELSE(SGWZA15,REFX(SGWZI14,16384),SGWZI14);
SGWZL15:=IFELSE(SGWZA15,REFX(SGWZL14,16384),SGWZL14);
SGWZU15:=IFELSE(SGWZA15,REFX(SGWZU14,16384),SGWZU14);
SGWZD15:=IFELSE(SGWZA15,REFX(SGWZD14,16384),SGWZD14);
SGWZA16:=SGWZI15=0 AND IFELSE(REFX(SGWZI15,32768)>0,1,0);
SGWZI16:=IFELSE(SGWZA16,REFX(SGWZI15,32768),SGWZI15);
SGWZL16:=IFELSE(SGWZA16,REFX(SGWZL15,32768),SGWZL15);
SGWZU16:=IFELSE(SGWZA16,REFX(SGWZU15,32768),SGWZU15);
SGWZD16:=IFELSE(SGWZA16,REFX(SGWZD15,32768),SGWZD15);
SGWZA17:=SGWZI16=0 AND IFELSE(REFX(SGWZI16,65536)>0,1,0);
SGWZI17:=IFELSE(SGWZA17,REFX(SGWZI16,65536),SGWZI16);
SGWZL17:=IFELSE(SGWZA17,REFX(SGWZL16,65536),SGWZL16);
SGWZU17:=IFELSE(SGWZA17,REFX(SGWZU16,65536),SGWZU16);
SGWZD17:=IFELSE(SGWZA17,REFX(SGWZD16,65536),SGWZD16);
SGWZA18:=SGWZI17=0 AND IFELSE(REFX(SGWZI17,131072)>0,1,0);
SGWZI18:=IFELSE(SGWZA18,REFX(SGWZI17,131072),SGWZI17);
SGWZL18:=IFELSE(SGWZA18,REFX(SGWZL17,131072),SGWZL17);
SGWZU18:=IFELSE(SGWZA18,REFX(SGWZU17,131072),SGWZU17);
SGWZD18:=IFELSE(SGWZA18,REFX(SGWZD17,131072),SGWZD17);
SGWZA19:=SGWZI18=0 AND IFELSE(REFX(SGWZI18,262144)>0,1,0);
SGWZI19:=IFELSE(SGWZA19,REFX(SGWZI18,262144),SGWZI18);
SGWZL19:=IFELSE(SGWZA19,REFX(SGWZL18,262144),SGWZL18);
SGWZU19:=IFELSE(SGWZA19,REFX(SGWZU18,262144),SGWZU18);
SGWZD19:=IFELSE(SGWZA19,REFX(SGWZD18,262144),SGWZD18);
SGWZA20:=SGWZI19=0 AND IFELSE(REFX(SGWZI19,524288)>0,1,0);
SGWZI20:=IFELSE(SGWZA20,REFX(SGWZI19,524288),SGWZI19);
SGWZL20:=IFELSE(SGWZA20,REFX(SGWZL19,524288),SGWZL19);
SGWZU20:=IFELSE(SGWZA20,REFX(SGWZU19,524288),SGWZU19);
SGWZD20:=IFELSE(SGWZA20,REFX(SGWZD19,524288),SGWZD19);
SGWZA21:=SGWZI20=0 AND IFELSE(REFX(SGWZI20,1048576)>0,1,0);
SGWZI21:=IFELSE(SGWZA21,REFX(SGWZI20,1048576),SGWZI20);
SGWZL21:=IFELSE(SGWZA21,REFX(SGWZL20,1048576),SGWZL20);
SGWZU21:=IFELSE(SGWZA21,REFX(SGWZU20,1048576),SGWZU20);
SGWZD21:=IFELSE(SGWZA21,REFX(SGWZD20,1048576),SGWZD20);
SGWZA22:=SGWZI21=0 AND IFELSE(REFX(SGWZI21,2097152)>0,1,0);
SGWZI22:=IFELSE(SGWZA22,REFX(SGWZI21,2097152),SGWZI21);
SGWZL22:=IFELSE(SGWZA22,REFX(SGWZL21,2097152),SGWZL21);
SGWZU22:=IFELSE(SGWZA22,REFX(SGWZU21,2097152),SGWZU21);
SGWZD22:=IFELSE(SGWZA22,REFX(SGWZD21,2097152),SGWZD21);
SGWZA23:=SGWZI22=0 AND IFELSE(REFX(SGWZI22,4194304)>0,1,0);
SGWZI23:=IFELSE(SGWZA23,REFX(SGWZI22,4194304),SGWZI22);
SGWZL23:=IFELSE(SGWZA23,REFX(SGWZL22,4194304),SGWZL22);
SGWZU23:=IFELSE(SGWZA23,REFX(SGWZU22,4194304),SGWZU22);
SGWZD23:=IFELSE(SGWZA23,REFX(SGWZD22,4194304),SGWZD22);
SGWZA24:=SGWZI23=0 AND IFELSE(REFX(SGWZI23,8388608)>0,1,0);
SGWZI24:=IFELSE(SGWZA24,REFX(SGWZI23,8388608),SGWZI23);
SGWZL24:=IFELSE(SGWZA24,REFX(SGWZL23,8388608),SGWZL23);
SGWZU24:=IFELSE(SGWZA24,REFX(SGWZU23,8388608),SGWZU23);
SGWZD24:=IFELSE(SGWZA24,REFX(SGWZD23,8388608),SGWZD23);
SGWZA25:=SGWZI24=0 AND IFELSE(REFX(SGWZI24,16777216)>0,1,0);
SGWZI25:=IFELSE(SGWZA25,REFX(SGWZI24,16777216),SGWZI24);
SGWZL25:=IFELSE(SGWZA25,REFX(SGWZL24,16777216),SGWZL24);
SGWZU25:=IFELSE(SGWZA25,REFX(SGWZU24,16777216),SGWZU24);
SGWZD25:=IFELSE(SGWZA25,REFX(SGWZD24,16777216),SGWZD24);
SGWZA26:=SGWZI25=0 AND IFELSE(REFX(SGWZI25,33554432)>0,1,0);
SGWZI26:=IFELSE(SGWZA26,REFX(SGWZI25,33554432),SGWZI25);
SGWZL26:=IFELSE(SGWZA26,REFX(SGWZL25,33554432),SGWZL25);
SGWZU26:=IFELSE(SGWZA26,REFX(SGWZU25,33554432),SGWZU25);
SGWZD26:=IFELSE(SGWZA26,REFX(SGWZD25,33554432),SGWZD25);
SGWZA27:=SGWZI26=0 AND IFELSE(REFX(SGWZI26,67108864)>0,1,0);
SGWZI27:=IFELSE(SGWZA27,REFX(SGWZI26,67108864),SGWZI26);
SGWZL27:=IFELSE(SGWZA27,REFX(SGWZL26,67108864),SGWZL26);
SGWZU27:=IFELSE(SGWZA27,REFX(SGWZU26,67108864),SGWZU26);
SGWZD27:=IFELSE(SGWZA27,REFX(SGWZD26,67108864),SGWZD26);
SGWZA28:=SGWZI27=0 AND IFELSE(REFX(SGWZI27,134217728)>0,1,0);
SGWZI28:=IFELSE(SGWZA28,REFX(SGWZI27,134217728),SGWZI27);
SGWZL28:=IFELSE(SGWZA28,REFX(SGWZL27,134217728),SGWZL27);
SGWZU28:=IFELSE(SGWZA28,REFX(SGWZU27,134217728),SGWZU27);
SGWZD28:=IFELSE(SGWZA28,REFX(SGWZD27,134217728),SGWZD27);
SGWZA29:=SGWZI28=0 AND IFELSE(REFX(SGWZI28,268435456)>0,1,0);
SGWZI29:=IFELSE(SGWZA29,REFX(SGWZI28,268435456),SGWZI28);
SGWZL29:=IFELSE(SGWZA29,REFX(SGWZL28,268435456),SGWZL28);
SGWZU29:=IFELSE(SGWZA29,REFX(SGWZU28,268435456),SGWZU28);
SGWZD29:=IFELSE(SGWZA29,REFX(SGWZD28,268435456),SGWZD28);
SGWZA30:=SGWZI29=0 AND IFELSE(REFX(SGWZI29,536870912)>0,1,0);
SGWZI30:=IFELSE(SGWZA30,REFX(SGWZI29,536870912),SGWZI29);
SGWZL30:=IFELSE(SGWZA30,REFX(SGWZL29,536870912),SGWZL29);
SGWZU30:=IFELSE(SGWZA30,REFX(SGWZU29,536870912),SGWZU29);
SGWZD30:=IFELSE(SGWZA30,REFX(SGWZD29,536870912),SGWZD29);
SGWZA31:=SGWZI30=0 AND IFELSE(REFX(SGWZI30,1073741824)>0,1,0);
SGWZI31:=IFELSE(SGWZA31,REFX(SGWZI30,1073741824),SGWZI30);
SGWZL31:=IFELSE(SGWZA31,REFX(SGWZL30,1073741824),SGWZL30);
SGWZU31:=IFELSE(SGWZA31,REFX(SGWZU30,1073741824),SGWZU30);
SGWZD31:=IFELSE(SGWZA31,REFX(SGWZD30,1073741824),SGWZD30);
SGWLEFT:=SGSZ=1 AND SGWZI31>SGBN AND SGBN=SGWZL31 AND SGWZU31>SGWZD31;
SGTMP235:=SGPCONF OR SGPWAIT;
SGWPI0:=IFELSE(SGTMP235,SGBN,0);
SGWPP0:=IFELSE(SGTMP235,SGPP,0);
SGWPD0:=IFELSE(SGTMP235,SGD1,0);
SGWPT0:=IFELSE(SGTMP235,IFELSE(SGPCONF,1,2),0);
SGWPA1:=SGWPI0=0 AND IFELSE(REFX(SGWPI0,1)>0,1,0);
SGWPI1:=IFELSE(SGWPA1,REFX(SGWPI0,1),SGWPI0);
SGWPP1:=IFELSE(SGWPA1,REFX(SGWPP0,1),SGWPP0);
SGWPD1:=IFELSE(SGWPA1,REFX(SGWPD0,1),SGWPD0);
SGWPT1:=IFELSE(SGWPA1,REFX(SGWPT0,1),SGWPT0);
SGWPA2:=SGWPI1=0 AND IFELSE(REFX(SGWPI1,2)>0,1,0);
SGWPI2:=IFELSE(SGWPA2,REFX(SGWPI1,2),SGWPI1);
SGWPP2:=IFELSE(SGWPA2,REFX(SGWPP1,2),SGWPP1);
SGWPD2:=IFELSE(SGWPA2,REFX(SGWPD1,2),SGWPD1);
SGWPT2:=IFELSE(SGWPA2,REFX(SGWPT1,2),SGWPT1);
SGWPA3:=SGWPI2=0 AND IFELSE(REFX(SGWPI2,4)>0,1,0);
SGWPI3:=IFELSE(SGWPA3,REFX(SGWPI2,4),SGWPI2);
SGWPP3:=IFELSE(SGWPA3,REFX(SGWPP2,4),SGWPP2);
SGWPD3:=IFELSE(SGWPA3,REFX(SGWPD2,4),SGWPD2);
SGWPT3:=IFELSE(SGWPA3,REFX(SGWPT2,4),SGWPT2);
SGWPA4:=SGWPI3=0 AND IFELSE(REFX(SGWPI3,8)>0,1,0);
SGWPI4:=IFELSE(SGWPA4,REFX(SGWPI3,8),SGWPI3);
SGWPP4:=IFELSE(SGWPA4,REFX(SGWPP3,8),SGWPP3);
SGWPD4:=IFELSE(SGWPA4,REFX(SGWPD3,8),SGWPD3);
SGWPT4:=IFELSE(SGWPA4,REFX(SGWPT3,8),SGWPT3);
SGWPA5:=SGWPI4=0 AND IFELSE(REFX(SGWPI4,16)>0,1,0);
SGWPI5:=IFELSE(SGWPA5,REFX(SGWPI4,16),SGWPI4);
SGWPP5:=IFELSE(SGWPA5,REFX(SGWPP4,16),SGWPP4);
SGWPD5:=IFELSE(SGWPA5,REFX(SGWPD4,16),SGWPD4);
SGWPT5:=IFELSE(SGWPA5,REFX(SGWPT4,16),SGWPT4);
SGWPA6:=SGWPI5=0 AND IFELSE(REFX(SGWPI5,32)>0,1,0);
SGWPI6:=IFELSE(SGWPA6,REFX(SGWPI5,32),SGWPI5);
SGWPP6:=IFELSE(SGWPA6,REFX(SGWPP5,32),SGWPP5);
SGWPD6:=IFELSE(SGWPA6,REFX(SGWPD5,32),SGWPD5);
SGWPT6:=IFELSE(SGWPA6,REFX(SGWPT5,32),SGWPT5);
SGWPA7:=SGWPI6=0 AND IFELSE(REFX(SGWPI6,64)>0,1,0);
SGWPI7:=IFELSE(SGWPA7,REFX(SGWPI6,64),SGWPI6);
SGWPP7:=IFELSE(SGWPA7,REFX(SGWPP6,64),SGWPP6);
SGWPD7:=IFELSE(SGWPA7,REFX(SGWPD6,64),SGWPD6);
SGWPT7:=IFELSE(SGWPA7,REFX(SGWPT6,64),SGWPT6);
SGWPA8:=SGWPI7=0 AND IFELSE(REFX(SGWPI7,128)>0,1,0);
SGWPI8:=IFELSE(SGWPA8,REFX(SGWPI7,128),SGWPI7);
SGWPP8:=IFELSE(SGWPA8,REFX(SGWPP7,128),SGWPP7);
SGWPD8:=IFELSE(SGWPA8,REFX(SGWPD7,128),SGWPD7);
SGWPT8:=IFELSE(SGWPA8,REFX(SGWPT7,128),SGWPT7);
SGWPA9:=SGWPI8=0 AND IFELSE(REFX(SGWPI8,256)>0,1,0);
SGWPI9:=IFELSE(SGWPA9,REFX(SGWPI8,256),SGWPI8);
SGWPP9:=IFELSE(SGWPA9,REFX(SGWPP8,256),SGWPP8);
SGWPD9:=IFELSE(SGWPA9,REFX(SGWPD8,256),SGWPD8);
SGWPT9:=IFELSE(SGWPA9,REFX(SGWPT8,256),SGWPT8);
SGWPA10:=SGWPI9=0 AND IFELSE(REFX(SGWPI9,512)>0,1,0);
SGWPI10:=IFELSE(SGWPA10,REFX(SGWPI9,512),SGWPI9);
SGWPP10:=IFELSE(SGWPA10,REFX(SGWPP9,512),SGWPP9);
SGWPD10:=IFELSE(SGWPA10,REFX(SGWPD9,512),SGWPD9);
SGWPT10:=IFELSE(SGWPA10,REFX(SGWPT9,512),SGWPT9);
SGWPA11:=SGWPI10=0 AND IFELSE(REFX(SGWPI10,1024)>0,1,0);
SGWPI11:=IFELSE(SGWPA11,REFX(SGWPI10,1024),SGWPI10);
SGWPP11:=IFELSE(SGWPA11,REFX(SGWPP10,1024),SGWPP10);
SGWPD11:=IFELSE(SGWPA11,REFX(SGWPD10,1024),SGWPD10);
SGWPT11:=IFELSE(SGWPA11,REFX(SGWPT10,1024),SGWPT10);
SGWPA12:=SGWPI11=0 AND IFELSE(REFX(SGWPI11,2048)>0,1,0);
SGWPI12:=IFELSE(SGWPA12,REFX(SGWPI11,2048),SGWPI11);
SGWPP12:=IFELSE(SGWPA12,REFX(SGWPP11,2048),SGWPP11);
SGWPD12:=IFELSE(SGWPA12,REFX(SGWPD11,2048),SGWPD11);
SGWPT12:=IFELSE(SGWPA12,REFX(SGWPT11,2048),SGWPT11);
SGWPA13:=SGWPI12=0 AND IFELSE(REFX(SGWPI12,4096)>0,1,0);
SGWPI13:=IFELSE(SGWPA13,REFX(SGWPI12,4096),SGWPI12);
SGWPP13:=IFELSE(SGWPA13,REFX(SGWPP12,4096),SGWPP12);
SGWPD13:=IFELSE(SGWPA13,REFX(SGWPD12,4096),SGWPD12);
SGWPT13:=IFELSE(SGWPA13,REFX(SGWPT12,4096),SGWPT12);
SGWPA14:=SGWPI13=0 AND IFELSE(REFX(SGWPI13,8192)>0,1,0);
SGWPI14:=IFELSE(SGWPA14,REFX(SGWPI13,8192),SGWPI13);
SGWPP14:=IFELSE(SGWPA14,REFX(SGWPP13,8192),SGWPP13);
SGWPD14:=IFELSE(SGWPA14,REFX(SGWPD13,8192),SGWPD13);
SGWPT14:=IFELSE(SGWPA14,REFX(SGWPT13,8192),SGWPT13);
SGWPA15:=SGWPI14=0 AND IFELSE(REFX(SGWPI14,16384)>0,1,0);
SGWPI15:=IFELSE(SGWPA15,REFX(SGWPI14,16384),SGWPI14);
SGWPP15:=IFELSE(SGWPA15,REFX(SGWPP14,16384),SGWPP14);
SGWPD15:=IFELSE(SGWPA15,REFX(SGWPD14,16384),SGWPD14);
SGWPT15:=IFELSE(SGWPA15,REFX(SGWPT14,16384),SGWPT14);
SGWPA16:=SGWPI15=0 AND IFELSE(REFX(SGWPI15,32768)>0,1,0);
SGWPI16:=IFELSE(SGWPA16,REFX(SGWPI15,32768),SGWPI15);
SGWPP16:=IFELSE(SGWPA16,REFX(SGWPP15,32768),SGWPP15);
SGWPD16:=IFELSE(SGWPA16,REFX(SGWPD15,32768),SGWPD15);
SGWPT16:=IFELSE(SGWPA16,REFX(SGWPT15,32768),SGWPT15);
SGWPA17:=SGWPI16=0 AND IFELSE(REFX(SGWPI16,65536)>0,1,0);
SGWPI17:=IFELSE(SGWPA17,REFX(SGWPI16,65536),SGWPI16);
SGWPP17:=IFELSE(SGWPA17,REFX(SGWPP16,65536),SGWPP16);
SGWPD17:=IFELSE(SGWPA17,REFX(SGWPD16,65536),SGWPD16);
SGWPT17:=IFELSE(SGWPA17,REFX(SGWPT16,65536),SGWPT16);
SGWPA18:=SGWPI17=0 AND IFELSE(REFX(SGWPI17,131072)>0,1,0);
SGWPI18:=IFELSE(SGWPA18,REFX(SGWPI17,131072),SGWPI17);
SGWPP18:=IFELSE(SGWPA18,REFX(SGWPP17,131072),SGWPP17);
SGWPD18:=IFELSE(SGWPA18,REFX(SGWPD17,131072),SGWPD17);
SGWPT18:=IFELSE(SGWPA18,REFX(SGWPT17,131072),SGWPT17);
SGWPA19:=SGWPI18=0 AND IFELSE(REFX(SGWPI18,262144)>0,1,0);
SGWPI19:=IFELSE(SGWPA19,REFX(SGWPI18,262144),SGWPI18);
SGWPP19:=IFELSE(SGWPA19,REFX(SGWPP18,262144),SGWPP18);
SGWPD19:=IFELSE(SGWPA19,REFX(SGWPD18,262144),SGWPD18);
SGWPT19:=IFELSE(SGWPA19,REFX(SGWPT18,262144),SGWPT18);
SGWPA20:=SGWPI19=0 AND IFELSE(REFX(SGWPI19,524288)>0,1,0);
SGWPI20:=IFELSE(SGWPA20,REFX(SGWPI19,524288),SGWPI19);
SGWPP20:=IFELSE(SGWPA20,REFX(SGWPP19,524288),SGWPP19);
SGWPD20:=IFELSE(SGWPA20,REFX(SGWPD19,524288),SGWPD19);
SGWPT20:=IFELSE(SGWPA20,REFX(SGWPT19,524288),SGWPT19);
SGWPA21:=SGWPI20=0 AND IFELSE(REFX(SGWPI20,1048576)>0,1,0);
SGWPI21:=IFELSE(SGWPA21,REFX(SGWPI20,1048576),SGWPI20);
SGWPP21:=IFELSE(SGWPA21,REFX(SGWPP20,1048576),SGWPP20);
SGWPD21:=IFELSE(SGWPA21,REFX(SGWPD20,1048576),SGWPD20);
SGWPT21:=IFELSE(SGWPA21,REFX(SGWPT20,1048576),SGWPT20);
SGWPA22:=SGWPI21=0 AND IFELSE(REFX(SGWPI21,2097152)>0,1,0);
SGWPI22:=IFELSE(SGWPA22,REFX(SGWPI21,2097152),SGWPI21);
SGWPP22:=IFELSE(SGWPA22,REFX(SGWPP21,2097152),SGWPP21);
SGWPD22:=IFELSE(SGWPA22,REFX(SGWPD21,2097152),SGWPD21);
SGWPT22:=IFELSE(SGWPA22,REFX(SGWPT21,2097152),SGWPT21);
SGWPA23:=SGWPI22=0 AND IFELSE(REFX(SGWPI22,4194304)>0,1,0);
SGWPI23:=IFELSE(SGWPA23,REFX(SGWPI22,4194304),SGWPI22);
SGWPP23:=IFELSE(SGWPA23,REFX(SGWPP22,4194304),SGWPP22);
SGWPD23:=IFELSE(SGWPA23,REFX(SGWPD22,4194304),SGWPD22);
SGWPT23:=IFELSE(SGWPA23,REFX(SGWPT22,4194304),SGWPT22);
SGWPA24:=SGWPI23=0 AND IFELSE(REFX(SGWPI23,8388608)>0,1,0);
SGWPI24:=IFELSE(SGWPA24,REFX(SGWPI23,8388608),SGWPI23);
SGWPP24:=IFELSE(SGWPA24,REFX(SGWPP23,8388608),SGWPP23);
SGWPD24:=IFELSE(SGWPA24,REFX(SGWPD23,8388608),SGWPD23);
SGWPT24:=IFELSE(SGWPA24,REFX(SGWPT23,8388608),SGWPT23);
SGWPA25:=SGWPI24=0 AND IFELSE(REFX(SGWPI24,16777216)>0,1,0);
SGWPI25:=IFELSE(SGWPA25,REFX(SGWPI24,16777216),SGWPI24);
SGWPP25:=IFELSE(SGWPA25,REFX(SGWPP24,16777216),SGWPP24);
SGWPD25:=IFELSE(SGWPA25,REFX(SGWPD24,16777216),SGWPD24);
SGWPT25:=IFELSE(SGWPA25,REFX(SGWPT24,16777216),SGWPT24);
SGWPA26:=SGWPI25=0 AND IFELSE(REFX(SGWPI25,33554432)>0,1,0);
SGWPI26:=IFELSE(SGWPA26,REFX(SGWPI25,33554432),SGWPI25);
SGWPP26:=IFELSE(SGWPA26,REFX(SGWPP25,33554432),SGWPP25);
SGWPD26:=IFELSE(SGWPA26,REFX(SGWPD25,33554432),SGWPD25);
SGWPT26:=IFELSE(SGWPA26,REFX(SGWPT25,33554432),SGWPT25);
SGWPA27:=SGWPI26=0 AND IFELSE(REFX(SGWPI26,67108864)>0,1,0);
SGWPI27:=IFELSE(SGWPA27,REFX(SGWPI26,67108864),SGWPI26);
SGWPP27:=IFELSE(SGWPA27,REFX(SGWPP26,67108864),SGWPP26);
SGWPD27:=IFELSE(SGWPA27,REFX(SGWPD26,67108864),SGWPD26);
SGWPT27:=IFELSE(SGWPA27,REFX(SGWPT26,67108864),SGWPT26);
SGWPA28:=SGWPI27=0 AND IFELSE(REFX(SGWPI27,134217728)>0,1,0);
SGWPI28:=IFELSE(SGWPA28,REFX(SGWPI27,134217728),SGWPI27);
SGWPP28:=IFELSE(SGWPA28,REFX(SGWPP27,134217728),SGWPP27);
SGWPD28:=IFELSE(SGWPA28,REFX(SGWPD27,134217728),SGWPD27);
SGWPT28:=IFELSE(SGWPA28,REFX(SGWPT27,134217728),SGWPT27);
SGWPA29:=SGWPI28=0 AND IFELSE(REFX(SGWPI28,268435456)>0,1,0);
SGWPI29:=IFELSE(SGWPA29,REFX(SGWPI28,268435456),SGWPI28);
SGWPP29:=IFELSE(SGWPA29,REFX(SGWPP28,268435456),SGWPP28);
SGWPD29:=IFELSE(SGWPA29,REFX(SGWPD28,268435456),SGWPD28);
SGWPT29:=IFELSE(SGWPA29,REFX(SGWPT28,268435456),SGWPT28);
SGWPA30:=SGWPI29=0 AND IFELSE(REFX(SGWPI29,536870912)>0,1,0);
SGWPI30:=IFELSE(SGWPA30,REFX(SGWPI29,536870912),SGWPI29);
SGWPP30:=IFELSE(SGWPA30,REFX(SGWPP29,536870912),SGWPP29);
SGWPD30:=IFELSE(SGWPA30,REFX(SGWPD29,536870912),SGWPD29);
SGWPT30:=IFELSE(SGWPA30,REFX(SGWPT29,536870912),SGWPT29);
SGWPA31:=SGWPI30=0 AND IFELSE(REFX(SGWPI30,1073741824)>0,1,0);
SGWPI31:=IFELSE(SGWPA31,REFX(SGWPI30,1073741824),SGWPI30);
SGWPP31:=IFELSE(SGWPA31,REFX(SGWPP30,1073741824),SGWPP30);
SGWPD31:=IFELSE(SGWPA31,REFX(SGWPD30,1073741824),SGWPD30);
SGWPT31:=IFELSE(SGWPA31,REFX(SGWPT30,1073741824),SGWPT30);
SGWPI:=IFELSE(ISLASTBAR,0,REFX(SGWPI31,1));
SGWPP:=IFELSE(ISLASTBAR,0,REFX(SGWPP31,1));
SGWPD:=IFELSE(ISLASTBAR,0,REFX(SGWPD31,1));
SGWPT:=IFELSE(ISLASTBAR,0,REFX(SGWPT31,1));
SGWPDRAW:=SGWPI>SGBN AND SGBN=SGWPI-SGWPD;
SGWPSLOPE:=(SGWPP-SGPP)/MAX(SGWPD,1);
SGTMP236:=SGSV OR SGSPEND;
SGWSI0:=IFELSE(SGTMP236,SGBN,0);
SGWSP0:=IFELSE(SGTMP236,SGPP,0);
SGWSD0:=IFELSE(SGTMP236,SGSXD,0);
SGWST0:=IFELSE(SGTMP236,IFELSE(SGSV,1,2),0);
SGWSA1:=SGWSI0=0 AND IFELSE(REFX(SGWSI0,1)>0,1,0);
SGWSI1:=IFELSE(SGWSA1,REFX(SGWSI0,1),SGWSI0);
SGWSP1:=IFELSE(SGWSA1,REFX(SGWSP0,1),SGWSP0);
SGWSD1:=IFELSE(SGWSA1,REFX(SGWSD0,1),SGWSD0);
SGWST1:=IFELSE(SGWSA1,REFX(SGWST0,1),SGWST0);
SGWSA2:=SGWSI1=0 AND IFELSE(REFX(SGWSI1,2)>0,1,0);
SGWSI2:=IFELSE(SGWSA2,REFX(SGWSI1,2),SGWSI1);
SGWSP2:=IFELSE(SGWSA2,REFX(SGWSP1,2),SGWSP1);
SGWSD2:=IFELSE(SGWSA2,REFX(SGWSD1,2),SGWSD1);
SGWST2:=IFELSE(SGWSA2,REFX(SGWST1,2),SGWST1);
SGWSA3:=SGWSI2=0 AND IFELSE(REFX(SGWSI2,4)>0,1,0);
SGWSI3:=IFELSE(SGWSA3,REFX(SGWSI2,4),SGWSI2);
SGWSP3:=IFELSE(SGWSA3,REFX(SGWSP2,4),SGWSP2);
SGWSD3:=IFELSE(SGWSA3,REFX(SGWSD2,4),SGWSD2);
SGWST3:=IFELSE(SGWSA3,REFX(SGWST2,4),SGWST2);
SGWSA4:=SGWSI3=0 AND IFELSE(REFX(SGWSI3,8)>0,1,0);
SGWSI4:=IFELSE(SGWSA4,REFX(SGWSI3,8),SGWSI3);
SGWSP4:=IFELSE(SGWSA4,REFX(SGWSP3,8),SGWSP3);
SGWSD4:=IFELSE(SGWSA4,REFX(SGWSD3,8),SGWSD3);
SGWST4:=IFELSE(SGWSA4,REFX(SGWST3,8),SGWST3);
SGWSA5:=SGWSI4=0 AND IFELSE(REFX(SGWSI4,16)>0,1,0);
SGWSI5:=IFELSE(SGWSA5,REFX(SGWSI4,16),SGWSI4);
SGWSP5:=IFELSE(SGWSA5,REFX(SGWSP4,16),SGWSP4);
SGWSD5:=IFELSE(SGWSA5,REFX(SGWSD4,16),SGWSD4);
SGWST5:=IFELSE(SGWSA5,REFX(SGWST4,16),SGWST4);
SGWSA6:=SGWSI5=0 AND IFELSE(REFX(SGWSI5,32)>0,1,0);
SGWSI6:=IFELSE(SGWSA6,REFX(SGWSI5,32),SGWSI5);
SGWSP6:=IFELSE(SGWSA6,REFX(SGWSP5,32),SGWSP5);
SGWSD6:=IFELSE(SGWSA6,REFX(SGWSD5,32),SGWSD5);
SGWST6:=IFELSE(SGWSA6,REFX(SGWST5,32),SGWST5);
SGWSA7:=SGWSI6=0 AND IFELSE(REFX(SGWSI6,64)>0,1,0);
SGWSI7:=IFELSE(SGWSA7,REFX(SGWSI6,64),SGWSI6);
SGWSP7:=IFELSE(SGWSA7,REFX(SGWSP6,64),SGWSP6);
SGWSD7:=IFELSE(SGWSA7,REFX(SGWSD6,64),SGWSD6);
SGWST7:=IFELSE(SGWSA7,REFX(SGWST6,64),SGWST6);
SGWSA8:=SGWSI7=0 AND IFELSE(REFX(SGWSI7,128)>0,1,0);
SGWSI8:=IFELSE(SGWSA8,REFX(SGWSI7,128),SGWSI7);
SGWSP8:=IFELSE(SGWSA8,REFX(SGWSP7,128),SGWSP7);
SGWSD8:=IFELSE(SGWSA8,REFX(SGWSD7,128),SGWSD7);
SGWST8:=IFELSE(SGWSA8,REFX(SGWST7,128),SGWST7);
SGWSA9:=SGWSI8=0 AND IFELSE(REFX(SGWSI8,256)>0,1,0);
SGWSI9:=IFELSE(SGWSA9,REFX(SGWSI8,256),SGWSI8);
SGWSP9:=IFELSE(SGWSA9,REFX(SGWSP8,256),SGWSP8);
SGWSD9:=IFELSE(SGWSA9,REFX(SGWSD8,256),SGWSD8);
SGWST9:=IFELSE(SGWSA9,REFX(SGWST8,256),SGWST8);
SGWSA10:=SGWSI9=0 AND IFELSE(REFX(SGWSI9,512)>0,1,0);
SGWSI10:=IFELSE(SGWSA10,REFX(SGWSI9,512),SGWSI9);
SGWSP10:=IFELSE(SGWSA10,REFX(SGWSP9,512),SGWSP9);
SGWSD10:=IFELSE(SGWSA10,REFX(SGWSD9,512),SGWSD9);
SGWST10:=IFELSE(SGWSA10,REFX(SGWST9,512),SGWST9);
SGWSA11:=SGWSI10=0 AND IFELSE(REFX(SGWSI10,1024)>0,1,0);
SGWSI11:=IFELSE(SGWSA11,REFX(SGWSI10,1024),SGWSI10);
SGWSP11:=IFELSE(SGWSA11,REFX(SGWSP10,1024),SGWSP10);
SGWSD11:=IFELSE(SGWSA11,REFX(SGWSD10,1024),SGWSD10);
SGWST11:=IFELSE(SGWSA11,REFX(SGWST10,1024),SGWST10);
SGWSA12:=SGWSI11=0 AND IFELSE(REFX(SGWSI11,2048)>0,1,0);
SGWSI12:=IFELSE(SGWSA12,REFX(SGWSI11,2048),SGWSI11);
SGWSP12:=IFELSE(SGWSA12,REFX(SGWSP11,2048),SGWSP11);
SGWSD12:=IFELSE(SGWSA12,REFX(SGWSD11,2048),SGWSD11);
SGWST12:=IFELSE(SGWSA12,REFX(SGWST11,2048),SGWST11);
SGWSA13:=SGWSI12=0 AND IFELSE(REFX(SGWSI12,4096)>0,1,0);
SGWSI13:=IFELSE(SGWSA13,REFX(SGWSI12,4096),SGWSI12);
SGWSP13:=IFELSE(SGWSA13,REFX(SGWSP12,4096),SGWSP12);
SGWSD13:=IFELSE(SGWSA13,REFX(SGWSD12,4096),SGWSD12);
SGWST13:=IFELSE(SGWSA13,REFX(SGWST12,4096),SGWST12);
SGWSA14:=SGWSI13=0 AND IFELSE(REFX(SGWSI13,8192)>0,1,0);
SGWSI14:=IFELSE(SGWSA14,REFX(SGWSI13,8192),SGWSI13);
SGWSP14:=IFELSE(SGWSA14,REFX(SGWSP13,8192),SGWSP13);
SGWSD14:=IFELSE(SGWSA14,REFX(SGWSD13,8192),SGWSD13);
SGWST14:=IFELSE(SGWSA14,REFX(SGWST13,8192),SGWST13);
SGWSA15:=SGWSI14=0 AND IFELSE(REFX(SGWSI14,16384)>0,1,0);
SGWSI15:=IFELSE(SGWSA15,REFX(SGWSI14,16384),SGWSI14);
SGWSP15:=IFELSE(SGWSA15,REFX(SGWSP14,16384),SGWSP14);
SGWSD15:=IFELSE(SGWSA15,REFX(SGWSD14,16384),SGWSD14);
SGWST15:=IFELSE(SGWSA15,REFX(SGWST14,16384),SGWST14);
SGWSA16:=SGWSI15=0 AND IFELSE(REFX(SGWSI15,32768)>0,1,0);
SGWSI16:=IFELSE(SGWSA16,REFX(SGWSI15,32768),SGWSI15);
SGWSP16:=IFELSE(SGWSA16,REFX(SGWSP15,32768),SGWSP15);
SGWSD16:=IFELSE(SGWSA16,REFX(SGWSD15,32768),SGWSD15);
SGWST16:=IFELSE(SGWSA16,REFX(SGWST15,32768),SGWST15);
SGWSA17:=SGWSI16=0 AND IFELSE(REFX(SGWSI16,65536)>0,1,0);
SGWSI17:=IFELSE(SGWSA17,REFX(SGWSI16,65536),SGWSI16);
SGWSP17:=IFELSE(SGWSA17,REFX(SGWSP16,65536),SGWSP16);
SGWSD17:=IFELSE(SGWSA17,REFX(SGWSD16,65536),SGWSD16);
SGWST17:=IFELSE(SGWSA17,REFX(SGWST16,65536),SGWST16);
SGWSA18:=SGWSI17=0 AND IFELSE(REFX(SGWSI17,131072)>0,1,0);
SGWSI18:=IFELSE(SGWSA18,REFX(SGWSI17,131072),SGWSI17);
SGWSP18:=IFELSE(SGWSA18,REFX(SGWSP17,131072),SGWSP17);
SGWSD18:=IFELSE(SGWSA18,REFX(SGWSD17,131072),SGWSD17);
SGWST18:=IFELSE(SGWSA18,REFX(SGWST17,131072),SGWST17);
SGWSA19:=SGWSI18=0 AND IFELSE(REFX(SGWSI18,262144)>0,1,0);
SGWSI19:=IFELSE(SGWSA19,REFX(SGWSI18,262144),SGWSI18);
SGWSP19:=IFELSE(SGWSA19,REFX(SGWSP18,262144),SGWSP18);
SGWSD19:=IFELSE(SGWSA19,REFX(SGWSD18,262144),SGWSD18);
SGWST19:=IFELSE(SGWSA19,REFX(SGWST18,262144),SGWST18);
SGWSA20:=SGWSI19=0 AND IFELSE(REFX(SGWSI19,524288)>0,1,0);
SGWSI20:=IFELSE(SGWSA20,REFX(SGWSI19,524288),SGWSI19);
SGWSP20:=IFELSE(SGWSA20,REFX(SGWSP19,524288),SGWSP19);
SGWSD20:=IFELSE(SGWSA20,REFX(SGWSD19,524288),SGWSD19);
SGWST20:=IFELSE(SGWSA20,REFX(SGWST19,524288),SGWST19);
SGWSA21:=SGWSI20=0 AND IFELSE(REFX(SGWSI20,1048576)>0,1,0);
SGWSI21:=IFELSE(SGWSA21,REFX(SGWSI20,1048576),SGWSI20);
SGWSP21:=IFELSE(SGWSA21,REFX(SGWSP20,1048576),SGWSP20);
SGWSD21:=IFELSE(SGWSA21,REFX(SGWSD20,1048576),SGWSD20);
SGWST21:=IFELSE(SGWSA21,REFX(SGWST20,1048576),SGWST20);
SGWSA22:=SGWSI21=0 AND IFELSE(REFX(SGWSI21,2097152)>0,1,0);
SGWSI22:=IFELSE(SGWSA22,REFX(SGWSI21,2097152),SGWSI21);
SGWSP22:=IFELSE(SGWSA22,REFX(SGWSP21,2097152),SGWSP21);
SGWSD22:=IFELSE(SGWSA22,REFX(SGWSD21,2097152),SGWSD21);
SGWST22:=IFELSE(SGWSA22,REFX(SGWST21,2097152),SGWST21);
SGWSA23:=SGWSI22=0 AND IFELSE(REFX(SGWSI22,4194304)>0,1,0);
SGWSI23:=IFELSE(SGWSA23,REFX(SGWSI22,4194304),SGWSI22);
SGWSP23:=IFELSE(SGWSA23,REFX(SGWSP22,4194304),SGWSP22);
SGWSD23:=IFELSE(SGWSA23,REFX(SGWSD22,4194304),SGWSD22);
SGWST23:=IFELSE(SGWSA23,REFX(SGWST22,4194304),SGWST22);
SGWSA24:=SGWSI23=0 AND IFELSE(REFX(SGWSI23,8388608)>0,1,0);
SGWSI24:=IFELSE(SGWSA24,REFX(SGWSI23,8388608),SGWSI23);
SGWSP24:=IFELSE(SGWSA24,REFX(SGWSP23,8388608),SGWSP23);
SGWSD24:=IFELSE(SGWSA24,REFX(SGWSD23,8388608),SGWSD23);
SGWST24:=IFELSE(SGWSA24,REFX(SGWST23,8388608),SGWST23);
SGWSA25:=SGWSI24=0 AND IFELSE(REFX(SGWSI24,16777216)>0,1,0);
SGWSI25:=IFELSE(SGWSA25,REFX(SGWSI24,16777216),SGWSI24);
SGWSP25:=IFELSE(SGWSA25,REFX(SGWSP24,16777216),SGWSP24);
SGWSD25:=IFELSE(SGWSA25,REFX(SGWSD24,16777216),SGWSD24);
SGWST25:=IFELSE(SGWSA25,REFX(SGWST24,16777216),SGWST24);
SGWSA26:=SGWSI25=0 AND IFELSE(REFX(SGWSI25,33554432)>0,1,0);
SGWSI26:=IFELSE(SGWSA26,REFX(SGWSI25,33554432),SGWSI25);
SGWSP26:=IFELSE(SGWSA26,REFX(SGWSP25,33554432),SGWSP25);
SGWSD26:=IFELSE(SGWSA26,REFX(SGWSD25,33554432),SGWSD25);
SGWST26:=IFELSE(SGWSA26,REFX(SGWST25,33554432),SGWST25);
SGWSA27:=SGWSI26=0 AND IFELSE(REFX(SGWSI26,67108864)>0,1,0);
SGWSI27:=IFELSE(SGWSA27,REFX(SGWSI26,67108864),SGWSI26);
SGWSP27:=IFELSE(SGWSA27,REFX(SGWSP26,67108864),SGWSP26);
SGWSD27:=IFELSE(SGWSA27,REFX(SGWSD26,67108864),SGWSD26);
SGWST27:=IFELSE(SGWSA27,REFX(SGWST26,67108864),SGWST26);
SGWSA28:=SGWSI27=0 AND IFELSE(REFX(SGWSI27,134217728)>0,1,0);
SGWSI28:=IFELSE(SGWSA28,REFX(SGWSI27,134217728),SGWSI27);
SGWSP28:=IFELSE(SGWSA28,REFX(SGWSP27,134217728),SGWSP27);
SGWSD28:=IFELSE(SGWSA28,REFX(SGWSD27,134217728),SGWSD27);
SGWST28:=IFELSE(SGWSA28,REFX(SGWST27,134217728),SGWST27);
SGWSA29:=SGWSI28=0 AND IFELSE(REFX(SGWSI28,268435456)>0,1,0);
SGWSI29:=IFELSE(SGWSA29,REFX(SGWSI28,268435456),SGWSI28);
SGWSP29:=IFELSE(SGWSA29,REFX(SGWSP28,268435456),SGWSP28);
SGWSD29:=IFELSE(SGWSA29,REFX(SGWSD28,268435456),SGWSD28);
SGWST29:=IFELSE(SGWSA29,REFX(SGWST28,268435456),SGWST28);
SGWSA30:=SGWSI29=0 AND IFELSE(REFX(SGWSI29,536870912)>0,1,0);
SGWSI30:=IFELSE(SGWSA30,REFX(SGWSI29,536870912),SGWSI29);
SGWSP30:=IFELSE(SGWSA30,REFX(SGWSP29,536870912),SGWSP29);
SGWSD30:=IFELSE(SGWSA30,REFX(SGWSD29,536870912),SGWSD29);
SGWST30:=IFELSE(SGWSA30,REFX(SGWST29,536870912),SGWST29);
SGWSA31:=SGWSI30=0 AND IFELSE(REFX(SGWSI30,1073741824)>0,1,0);
SGWSI31:=IFELSE(SGWSA31,REFX(SGWSI30,1073741824),SGWSI30);
SGWSP31:=IFELSE(SGWSA31,REFX(SGWSP30,1073741824),SGWSP30);
SGWSD31:=IFELSE(SGWSA31,REFX(SGWSD30,1073741824),SGWSD30);
SGWST31:=IFELSE(SGWSA31,REFX(SGWST30,1073741824),SGWST30);
SGWSI:=IFELSE(ISLASTBAR,0,REFX(SGWSI31,1));
SGWSP:=IFELSE(ISLASTBAR,0,REFX(SGWSP31,1));
SGWSD:=IFELSE(ISLASTBAR,0,REFX(SGWSD31,1));
SGWST:=IFELSE(ISLASTBAR,0,REFX(SGWST31,1));
SGWSDRAW:=SGWSI>SGBN AND SGBN=SGWSI-SGWSD;
SGWSSLOPE:=(SGWSP-SGPP)/MAX(SGWSD,1);
// 绘图:蓝色笔;红色上行线段、绿色下行线段;尾部虚线。
// 从真实起点向右画有限长度;不依赖负长度参数。
DRAWSL(SGSP=1 AND SGWPDRAW AND SGWPT=1,SGPP,SGWPSLOPE,SGWPD,0,COLORBLUE),LINETHICK1;
DRAWSL(SGSP=1 AND SGWPDRAW AND SGWPT=2,SGPP,SGWPSLOPE,SGWPD,0,COLORBLUE),LINETHICK1,POINTDOT;
DRAWSL(SGSS=1 AND SGWSDRAW AND SGWST=1 AND SGWSP>SGPP,SGPP,SGWSSLOPE,SGWSD,0,COLORRED),LINETHICK3;
DRAWSL(SGSS=1 AND SGWSDRAW AND SGWST=1 AND SGWSP<SGPP,SGPP,SGWSSLOPE,SGWSD,0,COLORGREEN),LINETHICK3;
DRAWSL(SGSS=1 AND SGWSDRAW AND SGWST=2 AND SGWSP>SGPP,SGPP,SGWSSLOPE,SGWSD,0,COLORRED),LINETHICK1,POINTDOT;
DRAWSL(SGSS=1 AND SGWSDRAW AND SGWST=2 AND SGWSP<SGPP,SGPP,SGWSSLOPE,SGWSD,0,COLORGREEN),LINETHICK1,POINTDOT;
// 分型箭头:同一根K线上的短竖线拼接,颜色和粗细区分箭头形状。
// WH6 不使用 STICK;DRAWLINE 两个条件相同,只画当根的竖线。
SGAU:=MAX(ABS(SGMH)*0.0004,0.000001);
SGBU:=MAX(ABS(SGML)*0.0004,0.000001);
DRAWLINE(SGSF=1 AND SGFT,SGMH,SGSF=1 AND SGFT,SGMH+SGAU,COLORRED),LINETHICK1;
DRAWLINE(SGSF=1 AND SGFT,SGMH+SGAU,SGSF=1 AND SGFT,SGMH+2*SGAU,COLORRED),LINETHICK2;
DRAWLINE(SGSF=1 AND SGFT,SGMH+2*SGAU,SGSF=1 AND SGFT,SGMH+3*SGAU,COLORRED),LINETHICK3;
DRAWLINE(SGSF=1 AND SGFT,SGMH+3*SGAU,SGSF=1 AND SGFT,SGMH+6*SGAU,COLORRED),LINETHICK1;
DRAWLINE(SGSF=1 AND SGFB,SGML,SGSF=1 AND SGFB,SGML-SGBU,COLORGREEN),LINETHICK1;
DRAWLINE(SGSF=1 AND SGFB,SGML-SGBU,SGSF=1 AND SGFB,SGML-2*SGBU,COLORGREEN),LINETHICK2;
DRAWLINE(SGSF=1 AND SGFB,SGML-2*SGBU,SGSF=1 AND SGFB,SGML-3*SGBU,COLORGREEN),LINETHICK3;
DRAWLINE(SGSF=1 AND SGFB,SGML-3*SGBU,SGSF=1 AND SGFB,SGML-6*SGBU,COLORGREEN),LINETHICK1;
// 中枢上下沿固定,左右边界按成员;不填充、不跨矩形接线。
DRAWSL(SGWLEFT,SGWZU31,0,SGWZI31-SGBN,0,COLORMAGENTA),LINETHICK1;
DRAWSL(SGWLEFT,SGWZD31,0,SGWZI31-SGBN,0,COLORMAGENTA),LINETHICK1;
DRAWLINE(SGSZ=1 AND SGWZLAST,SGZGH,SGSZ=1 AND SGWZLAST,SGZDL,COLORMAGENTA),LINETHICK1;
DRAWLINE(SGWLEFT,SGWZU31,SGWLEFT,SGWZD31,COLORMAGENTA),LINETHICK1;

文华财经与新浪财经仅用于说明运行环境,与本产品无隶属或合作关系。

画线规则与参数总览 · 新浪财经缠论自动画线支持说明 · 安装说明 · 缠论自动画线软件怎么选

Struct Guide 用于结构识别、学习与复盘,不提供投资建议,不预测行情,也不承诺任何投资收益。