专利名称：：用于设计可配置处理器的自动处理器生产系统及方法
技术领域：
：本发明涉及计算机处理器以及开发计算机处理器的系统及技术，更具体地讲涉及其功能可按用户的选择配置的处理器，以及相关的开发系统和技术。
背景技术：
：现有技术的处理器通常都是相当坚硬的物体，很难被修改或扩展。在现有技术的某些系统中已经具有对处理器及其支持软件的有限的扩展能力，包括增加寄存器对寄存器的计算指令以及简单状态(但是不是寄存器文件)的能力。这种有限的扩展能力是技术的重要进步，许多使用这种改进的应用可以提高其速度及效率达四倍甚至更多。然而，这些现有技术系统在可扩展性上的有限性，意味着其它应用不能充分利用它。具体讲，要使用已有的核心寄存器文件，由于其固定的32位宽度的寄存器，一般就阻碍了将这些改进用于需要额外的精度或复制功能单元的应用中，其中数据操作数的组合宽度超过了32位。此外，核心处理器文件经常缺少执行某个指令的充足的读或写端口。由于这些原因，在该技术中需要支持增加新的宽度及读、写端口的数量可配置的寄存器文件。由于寄存器文件的增加，带来了在这些文件和存储器之间传送数据的需求。核心指令集包括对核心寄存器文件的装入和存储指令，但是增加的寄存器文件需要额外的装入和存储指令。这是因为可扩展寄存器文件的有理数之一将允许按需要的数据类型和带宽确定寄存器文件的大小。具体地讲，寄存器文件数据的宽度可以比指令集的其它部分支持的宽度宽。因此，通过将数据传送给核心提供的寄存器来装入和存储数据是不合理的；应该从新的寄存器文件直接装入和存储值。此外，虽然现有技术系统支持增加处理器状态，但是状态的数量一般是较小的。因此，在现有技术中需要增大便于添加到处理器体系结构中状态位的数量。这个状态经常需要被操作系统上下文切换。一旦状态的数量增加了，就需要有最小化上下文切换时间的新方法。这些方法已经在现有技术处理器(如MIPR2000协同处理器允许位)中使用了。但是，在该技术中需要通过从输入规范自动地生成代码序列和逻辑进一步扩展该方法，以支持实时操作系统(RTOSes)和其它需要了解并以一种及时的方式使用新状态的软件。此外，现有技术不允许在核心处理器实现和指令扩展之间的逻辑共享。对于装入和存储指令扩展，在核心和扩展之间共享数据缓存是重要的。这样新配置的指令的存储能够被核心的装入所发现，反之亦然，从而保证缓存一致——分离的缓存需要特定的结构以保持它们的一致；这是一种可能的但不理想的方案。同样，数据缓存是核心处理器中较大的电路，那么共享它就可以减少核心处理器的尺寸。增加寄存器文件还需要实现支持将高级语言变量分配给这些寄存器。现有技术处理器使用核心寄存器文件，现有技术编译程序已经支持对它的用户变量分配。因此，希望而且应该支持对于用户定义的寄存器文件编译程序分配。为了将变量分配给寄存器，支持用户定义的寄存器文件的编译程序需要有关于如何溢出、恢复和移动这些寄存器的知识，从而可以执行传统的编译程序功能。一个有关的但是更为常见的现有技术处理器系统的限制是编译程序支持的水平。通常，将指令添加给处理器以支持适用于新的应用(如许多DSP应用需要处理器执行饱和运算以替代更为传统的通常为处理器所支持的二进制补码运算)的数据类型。现有技术系统允许指令支持要添加的新的数据类型，但是，在写使用了这些扩展的高级语言代码时，需要将这些新的指令变换(映射)为现有语言数据类型。在某些情况下，某个适当的内部数据类型可能并不存在。例如，考虑饱和算法的例子。如上所述，许多DSP算法利用这样的算法，即所使用的位的数量在下溢状态的最小值或在溢出状态的最大值饱和，而不换行，比如在传统的二进制补码系统中。然而，没有具备这些语义的C数据类型——C语言需要的inta；intb；intc＝a+b；具有换行语义。可以写为inta；intb；intc＝SATADD(a，b)；这用新的内部函数代替了使用内置类型，但是这是笨拙的并且使算法难以理解(编写人简单地将STADD函数视为+)。另一方面，增加新的数据类型使得+运算符所起的作用不同于C语言已经用于整数加法和浮点加法运算的不同运算的类型所起的作用，所以扩展是自然的。因此，使用新的数据类型的饱和加法可以编码为dsp16a；dsp16b；dsp16c＝a+b；其中dsp16定义了一个饱和数据类型。因此，最后一行表示一饱和加，因为它的两个操作数都是饱和数据类型。大多数编译程序都要调度指令以使流水线停止最小化。然而，现有技术系统没有办法将指令规范用于扩展编译程序的数据结构调度。例如，装入指令流水线为一个两周期执行时间。因此，如果参考的装入的结果是以装入后的下一个指令为基准的，则将会有一个一周期的停止，因为装入还没有完成。因此，序列loadr1，addr1storer1，addr2loadr2，addr3storer2，addr4将有两个停止周期。如果编译程序将其重新安排为loadr1，addr1loadr2，addr3storer1，addr2storer2，addr4则序列的执行就不会有停止。这是称为指令调度的常用优化技术。现有技术指令调度需要一个给出指令使用它们的输入和输出的管道阶段的表，但是不能对新增加的指令使用这些信息。现有技术的另一个限制就是，增加的指令的计算部分必须在流水线的单个周期中执行。某些计算，如大操作数的乘法，有一个要比典型的RISC流水线阶段长的逻辑延迟。使用现有技术，实现包括这样的运算，就需要降低处理器时钟速率以提供更多的时间来保证完成计算。因此需要支持可以计算分散到几个流水线阶段的指令。除了允许计算在几个周期中执行外，允许操作数在不同的流水线阶段中消耗和产生也是有用的。例如，一个乘法/加法运算一般需要两个周期。在第一周期，乘法器产生进位保留形式的结果；在第二周期，使用一单级进位保留加法将进位保留结果及加法器从三个值降为两个值，然后在一个进位传送加法器中相加。因此，最简单的说明就是，乘/加指令从任何源操作数到目的操作数都使用两个周期；然而，以后就不可能进入同一累加器寄存器中做背对背的乘法/累加，因为两周期执行时间会有一单周期的停止。实际上，该逻辑只需要从累加器进到累加器出的一个周期，因此更好的方法是提供一种更为有力的描述，例如D←A+B*C被描述为，在第一阶段取B和C，在第二阶段取A，并且在第三阶段产生D。因此，从B或C到D的执行时间周期是3-1＝2，而从A到D的执行时间周期是3-2＝1。增加多周期指令后，还有必要生成适用于所增加指令的目标流水线的互锁逻辑。这是因为对于一个每个周期发出的指令，没有执行时间可以供一个指令产生一个能够引起对下一周期的互锁的结果，因为下一周期总是晚一个周期。通常，如果只按每K个中周期发出指令，这些指令的的执行时间周期是L个周期，并且L大于等于K，那么那些指令不能引起对它们的目的操作数(如果它们的源操作数是由一个象装入指令这样的两周期指令产生的，则指令仍然能够对它们的源操作数互锁)的互锁。如果可以有重新配置的两个周期的指令，就不需要后面的对新配置的指令的结果互锁的指令。大多数的指令集结构具有对于不同处理器结构的多种执行。现有技术系统将指令语义的规范与指令的执行逻辑相结合并且不分开它们，这可允许将一套参考语义用于多种执行。参考语义是一组指令集文档。通常以英语和更为精确的符号来说明指令集。英语经常是不明确的或容易出错，但是容易读懂。因此，它可用于指令的介绍、目的及松散定义。更为正式的定义对于指令作用的精确理解是有用的。参考语义的目的之一就是提供精确定义。其它组成部分包括指令字、汇编语法和文本描述。现有技术系统在其扩展语言中具有充分的信息，用以生成指令字和汇编语法。增加参考语义后，只是没有了文本描述，而且需要包括指令描述的规范，这能够转换为格式化的用于制作常规的ISA说明书的文档。具有以上特征的处理器开发技术，由于其适应性和能力的增加，将使现有技术的设计验证方法不再有效。结合上述特征，就需要验证生成的处理器的许多方面的正确性，包括—输入的参考指令语义的正确性；—输入的实现指令语义的正确性；—由指令语义编译程序完成的向应用程序设计语言的转换；—由指令语义编译程序完成的向硬件描述语言(HDL)的转换；—由指令语义编译程序完成的向指令集模拟器程序设计语言的转换；—由指令语义编译程序产生的对于寄存器文件、互锁、旁路、核心接口和异常的HDL。—在过程中产生的任何系统功能抽象层，如由指令语义编译程序产生的硬件抽象层(HAL)代码。(见上述Songer等人的专利申请获得有关HAL的更为详细的说明)；—在程序设计语言编译程序中支持的内部类型和数据类型。参考语义也可用于上述某些方面。最后，所有的硬件功能性必须被指令集所支持。
发明内容考虑到现有技术中的上述问题，本发明的一个目的是提供一个处理器开发系统，能实现多种处理器功能的可扩展性，包括增加新的寄存器文件，在宽度以及读端口和写端口的数量方面，可以进行配置。本发明的另一个目的是提供一个处理器开发系统，该系统支持增加指令，以在这些新的寄存器文件和内存之间传输数据。本发明的另一个目的是提供一个处理器开发系统，该系统支持在核心处理器实现和指令扩展之间共享逻辑，特别是在核心和扩展指令之间共享数据高速缓存。本发明还有一个目的是提供一个处理器开发系统，该系统支持编译程序将高级语言变量分配给扩展的寄存器文件，包括能够溢出、恢复和移动这些寄存器。本发明还有一个目的是提供处理器开发系统，该系统支持这样一些指令，其中的计算在几个流水线阶段展开。本发明另外一个目的是提供一个处理器开发系统，该系统允许在不同的流水线阶段占用和产生操作数。本发明进一步的目的是提供一个处理器开发系统，该系统支持对增加的多周期指令产生适于目标流水线的互锁逻辑。本发明另外的目的是提供一个处理器开发系统，该系统使用指令规范来扩展其编译程序的数据结构调度，以使流水线停止最小化。本发明另外还有一个目的是支持指令语义规范和指令的实现逻辑，以允许将一个参考语义集合用于多个指令实现。本发明另外的目的是提供一个处理器开发系统，该系统可以利用转换到格式化文档的指令描述的规范。本发明另外还有一个目的是提供一个处理器开发系统，该系统能够验证处理器设计的各种可扩展功能。本发明还有一个目的是提供一个处理器开发系统，该系统能生产代码序列，以及用于从输入规范自动进行的时间最短上下文切换的逻辑。本发明还有一个目的是提供一个处理器开发系统，该系统包括一个指令集模拟器，可以支持上述多种可扩展功能。结合附图，通过阅读下面有关优选实施例的详细描述，可以更好地理解本发明的所有目的、特征以及优点。在附图中图1和图2表示根据本发明的一个优选实施例的与一个四阶段流水线可扩展寄存器相关的控制逻辑；图3表示一个图1和2的寄存器的两阶段流水线方案；图4表示根据第一具体实施例的一个核心加法器的接口信号；图5表示一个现有的装入调整器；图6表示一个根据本优选实施例的装入调整器；图7表示一个根据本优选实施例的语义块输出接口信号；图8(a)-(c)表示根据本优选实施例的流水线寄存器优化；图9表示在本优选实施例中的异常处理；图10表示在本优选实施例中的进一步异常处理；图11表示在本优选实施例中的参考语义信息；图12表示根据本优选实施例的自动生成指令文档；图13表示根据本优选实施例的TIE验证过程；图14表示在本优选实施例中的共同模拟过程。本优选实施例详细说明本发明在某种程度上是建立在Killian等人和Wilson等人的申请中说明的技术之上的，在这两个申请中说明了Tensilica指令集扩展(TIE)语言及其编译程序和其它工具。本发明的一个优选实施例以新的结构及讨论的象编译程序这样的支持该结构的软件工具，扩展了TIE语言。扩展的寄存器文件本优选实施例提供的新功能性之一是支持寄存器文件。在现有的处理器技术中，寄存器文件就是一系列每个B位的N个存储单元。指令中的一个字段选择系列中成员作为指令结果的源操作数值或目的操作数值。典型地，一个寄存器文件被设计为支持并行地读N个成员中的R个，并且并行地写N个成员中的W个，这样指令能够有一个或更多的源操作数和目的操作数，并且仍然只需要一个周期进行寄存器文件访问。用于声明一个新的寄存器文件的TIE语言结构是regfile<rfname><eltwidth><entries><shortname>其中<rfname>是一个用于在后续的TIE结构中引用寄存器文件的句柄；<eltwidth>是一个寄存器文件元素(“register”)的位宽度；<entries>是寄存器文件中的元素数量；<shortname>是一个用于为汇编语言创建寄存器名的短前缀(通常为单个字母)。寄存器名为带有附加寄存器号的<shortname>。Regfile结构不声明读、写端口的数量；这些物理实现细节留到下面将要更为详细地说明的TIE编译程序部分进行说明，因此尽可能保持TIE为独立的实现，并且保持TIE为一个高级规范说明。作为Regfile声明的结果，生成的处理器将包括一个附加的程序员可视状态的<eltwidth>*<entries>位，以及读、写多个该状态的<eltwidth>值的逻辑。逻辑生成算法将在下面说明了其它相关的TIE语言结构之后进行更为详细地说明。TIE语言结构操作数<oname><filedname>{<rfname>[<fieldname>]}声明<oname>为一个用于读或写由指令字的字段<filedname>指定的寄存器文件的<rfname>元素的句柄。除了<rfname>可以指定一个Regfile公开的核心寄存器文件(称为“AR”)以外的寄存器文件外，这个结构与Killian等人的申请中说明的结构相同。如Killian等人申请中所说明的，句柄<oname>在iclass声明中用于描述寄存器文件的指令操作数in、out和inout。作为一个例子，TIE规范opcodeGFADD8op2＝4′b0000CUST0opcodeGFMULX8op2＝4′b0001CUST0opcodeGFRWMOD8op2＝4′b0010CUST0stategfmod8user_register0{gfmod}regfilegf816goperandgrr{gf[r]}operandgss{gf[s]}operandgtt{gf[t]}iclassgfrrr{GFADD8}{outgr，ings，ingt}{}{}iclassgfrr{GFMULX8}{outgr，ings}{ingfmod}{}iclassgfr{GFRWMOD8}{inoutgt}{inoutgfmod}{}semanticgf1{GFADD8}{assigngr＝gs^gt；}semanticgf2{GFMULX8}{assigngr＝gs[7]？({gs[60]，1′b0}^gfmod){gs[60]，1′b0}；}semanticgf3{GFRWMOD8}{wire[70]t1＝gt；wire[70]t2＝gfmod； assigngfmod＝t1； assigngt＝t2；}实现一个简化的8位数据值的伽罗瓦字段算术单元(执行该例子的整个TIE文件集见附录A)。创建了一个16入口，8位的寄存器文件(每个寄存器保持一个有关GF(2)的模的多项式，该末被多项式存储于gfmod中)，并且定义了两条指令来对这些寄存器进行操作。GFADD8将由指令字的s字段(“gs寄存器)指定的寄存器中的多项式与由指令字的t字段(“gt寄存器)指定的寄存器中的多项式相加，并且将结果写入由指令字的r字段(“gr寄存器)指定的寄存器中。GFMULX8将gs寄存器中的多项式与x个模gfmod相乘并将结果装入gr寄存器。GFMULX8用于读和写gfmod多项式寄存器。从这些简单TIE代码中生成的逻辑更为复杂，因为它需要控制逻辑处理并将种操作分配到不同流水线阶段。TIE是在一个对指令集的用户来讲比较熟悉的层面上来描述指令集的高级规范，不象指令集实现者(如处理器设计者)写的那样低级。一个由TIE代码生成的寄存器流水线控制逻辑的例子可见图1。这个例子说明了一个四阶段的流水线寄存器，在图的左侧包括一个由四个流水线寄存器组成的读数据管道以及它们相应的输入多路复用器。从上面开始，在读端口的每对流水线寄存器勾画出C0(R)、C1(E)、C2(M)、C3(W)以及C4流水线阶段的边界。每个流水线寄存器的输出，rd0_dataC1---rd0_dataC4，都被提供给插入在读和写端口之间的寄存器数据通路(为了简化未示出)。这些输出，以及所有的读端口中的后续的流水线寄存器的输出，都作为输入提供给下一级多路复用器。有关读端口多路复用器控制信号的生成将在下面详述。在该图的右侧也显示了一个由四个流水线寄存器组成的写端口及其它们相应的用于三个最近的流水线阶段的输入多路复用器。来自寄存器数据通路的四个信号w0_dataC1---w0_dataC4，被直接或通过对前面的写端口流水线寄存器的一个输出wr0_resultC2---wr0_resultC4的多路复用，提供给写端口寄存器中几个对应的输入。这些输出信号被与寄存器文件xregfleRF的输出进行多路复用，并且馈送给读端口流水线的C0阶段多路复用器。用于读和写端口中的多路复用器的控制信号是随着可以写xregfleRF而产生，并且对于本领域的技术人员来讲，在阅读了下面有关寄存器文件的编译程序生成的讨论后，使用如图2这样的电路的一个延迟信号stall_R是显而易见的。为了便于理解，图3给出了一个结合图1和图2的电路的两阶段方案的一个两阶段寄存器文件。生成寄存器文件对于每个由refile语句声明的寄存器文件，编译程序必须产生—寄存器文件存储单元；—读端口；—写端口；—源操作数互锁逻辑；—源操作数旁路逻辑；—目的操作数写逻辑。读和写端口生成一个寄存器文件的第一步就是确定读和写端口的数量、给端口分配流水线阶以及向端口分配操作数。有许多的算法可以用来进行这些操作，每种算法会导致不同的速度和区域折衷。下面的算法用于本优选实施例中。对于每个用于从寄存器文件中选择源操作数的字段都生成了一个读端口。在某些情况下，这将会生成比需要的多的读端口，但是由于它允许寄存器读与指令译码并行开始，所以通常会产生更快的寄存器读。考虑到前面的伽罗瓦字段算术单元的例子，其中iclassgfr{GFRWMOD8}{inoutgt}{inoutgfmod}{}已经被变为iclassgfr{GFRWMOD8}{inoutgr}{inoutgfmod}{}上面算法的将产生三个寄存器读端口(分别为了指令字的的r、s和t字段)，即使没有指令会使用两个以上的GF寄存器文件来同时读。然而，如果只产生了两个读端口，则需要在其中一个读端口前面设置一个2∶1多路复用器，用以在r和s字段或r和t字段间进行选择。这个多路复用器必须由用于区分GFRWMOD和GFADD指令的的解码逻辑来控制。在一个复杂的例子中，该逻辑可能也比较复杂，从而使得寄存器文件读时间增加较多。在优选实施例中算法所需要的额外区域可以通过指令集设计者设置指令的寄存器文件访问区域而得以避免，这样用于读每个寄存器文件的，不同区域的数量就与任何指令使用的读的最大数量相等。这就是为什么在上述例子中使用操作数gt代替iclassgfr中的gr的原因。对于上述算法的可能的改进是跟踪schedule语句(在下面的“TIE中的多周期指令”中进行详细解释)中规定的对于每个字段的最小的阶段数。如果最小阶段数比指令解码执行中的阶段数大，则可以使用字段多路复用以降低读端口的数量。对于所有最小阶段数出现在指令解码阶段的字段，则对每个用于读寄存器文件的字段使用分离端口。考虑下面的例子 regfileSR324r operandsxx{SR[x]} operandsyy{SR[y]} operandszz{SR[z]} operandsuu{SR[u]} operandsvv{SR[v]} iclassstu{inst1}{outsz，insx，insy，insu} iclassstv{inst2}{outsz，insx，insy，insv} schedulestu{inst1}{ insx1； insy1； insu2； outsz2； } schedulestv{inst2}{ insx1； insy1； insv2； outsz2； }其中有四个寄存器文件SR的输入操作数sx、sy、su及sv。根据调度信息，su和sv都被用于第二流水线阶段，并且因此能够被变换(映射)到一个单一的读端口而且不影响周期时间。这样，就不需要创建四个SR寄存器文件的读端口。在这种情况下，将三个读端口的地址信号设为read_addr_0、read_addr_1及read_addr_2，这样三个地址的逻辑就是read_addr_0＝x；read_addr_1＝y；read_addr_2＝inst1？uv；写端口对时间要求的苛刻性要低些。即使非常短的流水线也要在周期0中读寄存器文件，在周期1中执行计算，在周期2中写寄存器文件。因此就有充足的时间在所有的用于写寄存器文件的字段之间进行解码和多路复用。一个较为苛刻的时间通路是互锁；在周期0中读完寄存器文件之后，需要知道什么寄存器文件正在周期1的起点被写，以便于随后的要读寄存器文件的指令根据需要可以停止。然而，通常一个周期的时间对于解码和多路复用目的寄存器字段是充裕的，所以这种算法节省了区域且不影响速度。寄存器读和写端口与处理器流水线的接口因核心处理器流水线结构而改变。在本优选实施例中，核心处理器流水线总是使用在固定的流水线阶段的读和写端口，有关这些的说明见美国专利申请序列号中Dixit等人的09/192,395和Killian等人的09/322,375，两者都作为这里的参考；其中读端口总是在第一阶段之前被使用，写端口在一个四阶段流水线的寄存器文件的最后(第四)阶段之后被使用。每个读端口都在任何将其作为源操作数的指令的最早阶段被读；在后续阶段使用这种源操作数的指令在先前读了该寄存器文件，并且继续将数据登台到确定的阶段。这种登台也包括旁路多路复用，以便在寄存器文件被读以后产生需要的元素的指令仍然是可用的。对于写端口，写发生在任何将其用作指令提交阶段目的操作数的指令的最近阶段，如W阶段(如果该阶段到来的较晚的话)。图1表示在本优选实施例中的寄存器读和写端口的逻辑概要。旁路逻辑旁路逻辑说明于图1，它通过多路复用器的在读端口的逻辑实现。例如，如果一个指令在第三阶段(wr0_data_C3)产生一个结果，并且后续的指令需要利用阶段1的数据，则对有关读端口逻辑的第一多路复用器的控制信号就要被设置，这样来自左侧的第四输入就可以被选择。因此，在下一时钟周期，指令就可以使用数据(rdo_data_C1)。互锁逻辑互锁逻辑说明于图2。在调度信息的基础之上，指令解码逻辑为每个读端口生成一个defN，为每个将要发出的指令的写端口产生一个useN信号。useN指示指令将在N阶段需要其输入寄存器操作数。defN指示指令将在N阶段产生其结果。此外，指令的defN信号与指令一起被传输给流水线。停止信号通过检查所有的defN和useN的信号的组合而生成。随后的例子说明了一个具有两个读端口(rd0和rd1)及一个写端口(wd0)的4阶段流水线寄存器文件的停止逻辑。信号名(_Cn)的后缀表示信号存在于流水线的第n阶段。所以 assignStall_R＝ ((wr0_addr_C1＝＝rd0_addr_C0)&amp;( (rd0_use1_C0&amp;(wr0_def2_C1|wr0_ns_def3_C1|wr0_ns_def4_C1)) | (rd0_use2_C0&amp;(wr0_def3_C1|wr0_ns_def4_C1))| (rd0_use3_C0&amp;(wr0_def4_C1))))| ((wr0_addr_C2＝＝rd0_addr_C0)&amp;( (rd0_use1_C0&amp;(wr0_def3_C2|wr0_ns_def4_C2))| (rd0_use2_C0&amp;(wr0_def4_C2))))| ((wr0_addr_C3＝＝rd0_addr_C0)&amp;( (rd0_use1_C0&amp;(wr0_def4_C3))))| ((wr0_addr_C1＝＝rd1_addr_C0)&amp;( (rd1_use1_C0&amp;(wr0_def2_C1|wr0_ns_def3_C1|wr0_ns_def4_C1)) | (rd1_use2_C0&amp;(wr0_def3_C1|wr0_ns_def4_C1))| (rd1_use3_C0&amp;(wr0_def4_C1))))| ((wr0_addr_C2＝＝rd1_addr_C0)&amp;( (rd1_use1_C0&amp;(wr0_def3_C2|wr0_ns_def4_C2))| (rd1_use2_C0&amp;(wr0_def4_C2))))| ((wr0_addr_C3＝＝rd1_addr_C0)&amp;( (rd1_use1_C0&amp;(wr0_def4_C3))))；下面的perl代码在本优选实施例中用于开发停止代码。Wfield()和rfield()是用于将简单信号名、端口名和阶段号构造为信号名的函数。表达式写为有效带因数的形式。print＂assignStall_R＝\n＂；foreach$write_port(@{$rf-＞{WRITE_PORT}}){foreach$read_port(@{$rf-＞{READ_PORT}}){for($s＝1；$s＜＝$write_port-＞{MAX_DEF}-1；$s++){my($waddr)＝wfield(＂addr＂，$write_port，$s)；my($raddr)＝rfield(＂addr＂，$read_port，0)；print＂(($waddr＝＝$raddr)&amp;(\n＂；for($i＝1；$i＜＝$write_port-＞{MAX_DEF}-$s；$i++){ my($use)＝rfield(＂use$i＂，$read_port，0)； print＂($use&amp;(＂； for($j＝$i+$s；$j＜＝$write_port-＞{MAX_DEF}；$j++){ my($ns_def)＝wfield(＂ns_def$j＂，$write_port，$s)； print＂$ns_def″ if($j！＝$write_port-＞{MAX_DEF}){ print＂|＂； } } print＂))＂； if($i＝＝$write_port-＞{MAX_DEF}-$s){ print＂))|\n＂； }else{ print＂|\n＂； }}}}}print＂1′b0；\n＂；print＂\n＂；写逻辑因为在本优选实施例中写端口地址被多路复，用以降低与每个写端口有关的硬件成本，所以需要有一种算法来决定哪个操作数使用哪个端口。对于这种多路复用的一个标准就是，将所需的逻辑最少化。在目标流水线中主逻辑的消耗是将数据登台到写端口的消耗。如果所有的写都发生在同一流水线阶段，则在这一逻辑的消耗上就没有差别，但是，如果写发生在多个阶段，则可以通过将目的操作数与相似的写阶段进行组合而节省逻辑。考虑下面的例子 regfileSR328s operandsxx{SR[x]} operandsyy{SR[y]} operandszz{SR[z]}<dpn="d15"/> operandsuu{SR[u]} operandsvv{SR[v]} iclassi1{inst1}{outsx，outsy，insu，insv} iclassi2{inst2}{outsz，insu，insv} schedules1{inst1}{ outsx8； outsy3； } schedules2{inst2}{ outsz9； }这里，inst1为SR产生两个结果，一个为3周期的，另一个为8周期的。Inst2为SR产生一个9周期的结果。因为inst1需要两个写端口，inst2需要一个写端口，所以寄存器文件SR只需要有两个写端口。设端口为wr0和wr1。对于inst1，操作数向写端口转换(映射)就是sx->wr0sy->wr1这表示wr0需要有8个阶段，wr1需要有3个阶段。对于inst2，可以选择sz->wr0或sz->wr1之一。然而，两个选择具有不同的逻辑消耗。将sz转换为wr0表示向wr0增加了一个阶段(从8级增加到9级)，而将sz传送给wr1表示向wr1增加了6个阶段(从3级增加到9级)。本优选实施例使用以下算法。对于每条指令，按阶段数降序将操作数排序，并且将它们顺序地分配给写端口0到写端口n-1。因此，写端口0将具有最长的数据链，而端口n-1具有最短的数据链。对于具有m个操作数的指令，其中m小于n，操作数将以类似的按阶段数降序的顺序把操作数转换为m个端口的第一个。下面的例子用于说明写端口分配的过程。 regfileSR328s operandsxx{SR[x]} operandsyy{SR[y]} operandszz{SR[z]} operandsuu{SR[u]} operandsvv{SR[v]} operandsww{SR[w]} iclassi1{inst1}{outsx，outsy，insu，insv} iclassi2{inst2}{outsz，insu，insv} iclassi3{inst3}{outsw，insu，insv} schedules1{inst1}{ outsx8； outsy3； } schedules2{inst2}{ outsz9； } schedules3{inst3}{ outsw2； }分配过程将产生如下的分配对于inst1sx->wr0sy->wr1对于inst2sz->wr0对于inst3sw->wr0即使上述五端口分配程序最小化了数据登台开销，它还是可以被进一步改进以优化其它的开销标准，如电能消耗。在上述例子中，inst3的sw可以在一点不增加登台开销的情况下转换为wr1。但是，这样做就有在阶段2的末尾，在数据被写入寄存器sr后流水线掉电的可能性。将sw分配给wr0需要流水线保持活动达9个周期。下面的程序可以用作在考虑到象电力消耗这样的附属开销的情况下进一步改进端口分配的第二途径。对于每个具有m个操作数的指令(这里m＜n)以及对于每个相反顺序的操作数，将操作数的分配移动给一个新的写端口i，这里i是在不增加登台开销的情况下的尽可能大的数。为了使用前面的例子说明这一程序，没有inst1的操作数可以被移动，因为它已经使用了所有的写端口。对于inst2，不能在不增加登台开销的情况下将sz再分配给wr1。对于inst3，可以在不增加分级开销的情况下将sw从wr0再分配给wr1在寄存器文件读和写端口分配的算法上有许多可能的变化。例如，在某些环境下，为了减少电力消耗，提供比严格要求的数量多的端口以最小化数据登台是较为恰当的。为了进一步降低与读和写端口有关的硬件开销，提供比某些指令要求的更少的端口也是可能的；对于读端口这意味着使用多个周期来读寄存器操作数，对于写端口这意味着要缓存一些要写的寄存器，以等待一个不使用写端口的周期。另一个可能性是，允许TIE编码确定寄存器文件读和写端口分配，以处理自动算法的结果不理想的情况。上述扩展寄存器执行的概念被用于附录B，即一个用于生成一个N-读，M-写，B-位，S-入口的寄存器文件的perl程序。装入/存储指令如在“
背景技术：
”中所说明的，TIE装入和存储指令需要提供将数据直接传输给存储器和将数据从TIE寄存器文件直接传输给存储器的方法。所以根据这种需要，它们必须共享核心流水线的存储器(M)阶段的本地存储器，如，数据缓存、数据RAM、数据ROM等。除了共享本地存储器，只要有可能，还需要共享其它用于核心装入/存储的硬件资源。资源的共享产生了在区域和定时方面更为优化的方案。下面将会说明，地址计算逻辑及数据排列逻辑是在核心及TIE装入/存储之间共享的两套资源。下面的接口信号在本实施例中被用于执行TIE装入/存储。 interfaceVaddrOffset32coreout interfaceVaddrBase32coreout interfaceVaddrIndex32coreout interfaceLSIndexed1coreout interfaceLSSize5coreout interfaceMemDataOut＜n＞＜n＞coreout interfaceVaddrIn32corein interfaceMemDataIn＜n＞＜n＞corein大多数的这些信号说明于图4；图6说明LSSize927，MemDataOut<n>901和MemDataIn<n>938。LSSize给出参考的数据字节大小(在本优选实施例中为1，2，4，8，或16)。MemDataOut<n>提供从TIE语义向核心存储数据，MemDataIn<n>提供从核心向TIE语义装入数据。在本优选实施例中<n>可以是8，16，32，64，或128。在计算TIE装入/存储的存储器地址过程中，在TIE的装入和存贮指令的格式与核心的格式相匹配的情况下，可以共享地址加法器。复制地址加法器是不合算的，并且会引入地址计算通路内的额外延迟。接口信号代表向图4所示的核心地址加法器的输入。该地址逻辑会支持下面的地址模式IAR[s]+immediateXAR[s]+AR[t]在两种模式之间的选择是通过LSInndexed接口信号实现的。I-模式使用的immediate是在VaddOffset输入中提供，X-模式使用的AR[t]值是在VaddIndex输入中提供。VaddrBase用于提供AR[S]。而除AR[t]及AR[S]以外的其它值可以由TIE语义块在VaddBase和VaddrIndex中提供。提供这些值允许优化逻辑以简化结果逻辑，并且因此降低地址生成的时间严酷性。这是因为逻辑优化将可以辨认出，来自TIE逻辑的VaddrBase(AR[s])与核心的基本地址相同，从而将其降低为同一信号。TIE可以从对其提供了某些更改的核心中的装入和存储对准逻辑中获益。因为对准需要实现大量的逻辑，而避免对TIE的复制可以节省大量区域。此外，由于复制迫使本地存储器输出和对准及数据选择信号来产生繁重的装入，这可能引起时间关键通路。为了实现对准资源的共享，需要进行如图5及6中所示的更改。这些更改首先与TIE装入/存储需要/提供多种装入/存储宽度的事实有关，这与32位的核心装入/存储相反。这意味着所有对准逻辑中的数据通路必须增加宽度以相匹配TIE或核心数据宽度中的最大值。其次，TIE装入可能需要一种更为通用的对准功能，而非核心需要的简单右移。图5说明现有技术的用于128位访问宽度的三路关联数据缓存803-805和并行数据RAM的806的核心装入对准逻辑。在这个例子中，为了缓存再填充的方便，非缓存的数据输入808也被选择为128位宽；并且数据RAM访问为32位宽，这是因为它只通过最大宽度为32位的核心装入/存储被访问。当存储的数据必须被旁路给后续装入时，也要使用一个32位宽的存储数据输入807。使用的主要对准机制是后面跟有也执行符号扩展814-819的字节级右移的4∶1多路复用器809-812。移动的数量由装入地址813，821和一热one-hot解码coreSize信号820给出。存储和数据RAM数据不需要4∶1多路复用器，因为它们已经是32位宽了。32位宽校准的数据由一系列后续的多路复用器822-833选择，以产生最后的核心装入数据834。图6表示在本实施例中的一个装入校准执行。主要的区别是，所有的装入数据源906-911现在都是128位宽，以支持128位宽的TIE装入指令，并且装入校准结果也是128位宽。在本例子中，校准自己是使用后面跟有一个符号扩展器921-925的字节级转换器914-918实现的。之所以需要一个字节级的旋转器是因为在本例中，TIE语义碰巧需要数据旋转(再次说明，除了核心装入校准需要的简单右移)。移动或旋转的数量是由装入地址919和一热解码LSSize927或coreSize926信号给出的。装入校准的最后输出可以被TIE协处理器使用—整个宽度位128位的938提供所有的LSSize确定的多个装入宽度的；或者由核心—只是最少的重要的32位部分939提供coreSize确定的三个32/16/8位核心装入宽度。核心提供向后对除存储器数据以外的语义块的虚拟地址。对于装入数据的附加处理有时需要虚拟地址。此外，这允许装入和存储指令被定义为，更改用于组成虚拟地址的积寄存器。例如，核心ISA的“更新”模式执行如下IUvAddr<-AR[s]+offsetAR[s]<-vAddrXUvAddr<-AR[s]+AR[t]AR[s]<-vAddr对于基本地址寄存器AR[s]的绑定的写，避免了在许多内部循环中的分离的增量指令。这只要简单地在TIE中将“in”转变为“inout”并增加一个分配就可以完成。为了理解对于基本地址寄存器绑定的写的好处，首先看一个不使用这一功能的软件循环。 for(i＝0；i＜n；i++){ x＝tie_loadi(px，0)； y＝tie_loadi(Py，0)； z＝inst1(x，y)； tie_storei(z，pz，0)； px＝px+8； py＝py+8； pz＝pz+8； }这个例子在两个输入阵列(px和py)上进行循环，其中的元素为8字节宽，执行一个计算(inst1)，并将结果存储于另一个阵列中(pz)。在这个循环中的七条指令中的三条被用于提升装入和存储指令的基本指示字。使用绑定的写、装入和存储指令，本例子将会更为高效。见下面说明的编码 px＝px-8； py＝py-8； pz＝pz-8；<dpn="d21"/> for(i＝0；i＜n；i++){ x＝tie_loadiu(px，8)； y＝tie_loadiu(py，8)； z＝inst1(x，y)； tie_storeiu(z，pz，8)； }现在，tie_loadiu(tie_storeiu)将计算出虚拟地址为p+8，写(存储)存储器数据并且在一个指令中将p改变为p+8。开始的减法需要更正px、py和pz，因为现在第一开始于px+8、py+8，而第一存储开始于px+8。核心信号的阶段数，如这里说明的装入/存储接口，被核心流水线所固定，且没有在schedule声明中规定。然而，在上述流水线插入算法中使用了适当的值。例如，下面将装入和存储指令增加到上述伽罗瓦域算术GF单元例子opcode LGF8.Ir＝4′b0000LSCI opcodeSGF8.Ir＝4′b0001LSCI opcodeLGF8.IUr＝4′b0010LSCI opcodeSGF8.IUr＝4′b0011LSCI opcodeLGF8.Xop2＝4′b0000LSCX opcodeSGF8.Xop2＝4′b0001LSCX opcodeLGF8.XUop2＝4′b0010LSCX opcodeSGF8.XUop2＝4′b0011LSCX interfaceVaddrOffset32coreout interfaceVaddrBase32coreout interfaceVaddrIndex32coreout interfaceLSIndexed1coreout interfaceLSSize5coreout interfaceMemDataIn88corein interfaceVaddrIn32corein interfaceMemDataOut88coreout iclassgfloadi{LGF8.I}{outgt，inars，inimm8}{}{ outLSSize，outLSIndexed，outVAddrOffset，outVAddrBase，inMemDataIn8} iclassgfstorei{SGF8.I}{ingt，inars，inimm8}{}{ outLSSize，outLSIndexed，outVAddrOffset，outVAddrBase，outMemDataOut8} iclassgfloadiu{LGF8.IU}{outgt，inoutars，inimm8}{}{ outLSSize，outLSIndexed，outVAddrOffset，outVAddrBase，inMemDataIn8，inVAddrIn} iclassgfstoreiu{SGF8.IU}{ingt，inoutars，inimm8}{}{ outLSSize，outLSIndexed，outVAddrOffset，outVAddrBase，outMemDataOut8，inVAddrIn} iclassgfloadx{LGF8.X}{outgr，inars，inart}{}{ outLSSize，outLSIndexed，outVAddrIndex，outVAddrBase，inMemDataIn8} iclassgfstorex{SGF8.X}{ingr，inars，inart}{}{ outLSSize，outLSIndexed，outVAddrIndex，outVAddrBase，outMemDataOut8} iclassgfloadxu{LGF8.XU}{outgr，inoutars，inart}{}{<dpn="d22"/> outLSSize，outLSIndexed，outVAddrIndex，outVAddrBase，inMemDataIn8，inVAddrIn} iclassgfstorexu{SGF8.XU}{ingr，inoutars，inart}{}{ outLSSize，outLSIndexed，outVAddrIndex，outVAddrBase，outMemDataOut8，inVAddrIn} semanticlgf{LGF8.I，LGF8.IU，LGF8.X，LGF8.XU}{ assignLSIndexed＝LGF8.X|LGF8.XU； assignLSSize＝1； assignVAddrBase＝ars； assignVAddrIndex＝art； assignVAddrOffset＝imm8； assigngt＝MemDataIn8； assigngr＝MemDataIn8； assignars＝VAddrIn； } semanticsgf{SGF8.I，SGF8.IU，SGF8.X，SGF8.XU}{ assignLSIndexed＝SGF8.X|SGF8.XU； assignLSSize＝1； assignVAddrBase＝ars； assignVAddrIndex＝art； assignVAddrOffset＝imm8； assignMemDataOut8＝SGF8.X|SGF8.XU？grgt； assignars＝VAddrIn； } schedulegfload{LGF8.I} { useimm80； usears1； defgt2； } schedulegfloadu{LGF8.IU} { useimm80； usears1； defars1； defgt2； } schedulegfloadx{LGF8.X} { usears1； useart1； defgr2； } schedulegfloadxu{LGF8.XU} { usears1； useart1； defart1； defgr2； }下面是一个用于为本发明产生调整程序的tpp输入 moduleloadalign(out，in，va，vamask，TIEload，L16SI，L16UI，L8UI)； ；useUtilities； ；my$bits＝$pr-＞dcache-＞accessBits； ；my$bytes＝$bits＞＞3； ；my$mux＝log2($bytes)； outputout[`$bits-1`0]； inputin[`$bits-1`0]； inputva[`$mux-1`0]； inputvamask[`$mux-1`0]； inputTIEload； inputL16SI； inputL16UI； inputL8UI； wireL8or16＝L8UI|L16UI|L16SI； wirevam[`$mux-1`0]＝TIEload ？va&amp;vamask {va[`$mux-1`2]，va[1]&amp;L8or16，va&amp;L8UI}； ；subrot{ ；my($bits，$n，$step，$in，$out，$sel)＝@_； ；my@muxin＝map($_＝＝0 ；？$in ；′{′.$in.′[′.($_*$step-1).′0]，′.$in.′[′.($bits-1).′′.($_*$step).′]}′， ；0..($n-1))； xtmux`$n`e#`$bits`(`$out`， `join(＂，\n\t\t＂，@muxin)`， `$sel`)； ；) ；my$in＝′input′； ；if($mux&amp;1){ ；#rotateisdonewith41muxesandone21mux ；#combinethelast21muxwiththesignextend ；for(my$i＝$mux-2；$i＞＝1；$i-＝2){ ；my$out＝′t′.($temp++)； wire[`$bits-1`0]`$out`； ；rot($bits，4，8*(1＜＜$i)，$in，$out，′vam[′.($i+1).′′.$i.′]′)； ；$in＝$out； ；} ；if($bits＞32){ xtmux2e#`$bits-32`(output[`$bits-1`32]， `$in`[`$bits-1`32]， {`$in`[70]，`$in`[`$bits-1`40]}， vam)； ；} xtmux4e#16(output[3116]， `$in`[3116]， ；if($bits＞32){ `$in`[3924]}， ；}else{ {`$in`[70]，`$in`[3124]}， ；}<dpn="d24"/> {16{`$in`[15]&amp;L16SI}}， 16′b0，//shouldneverhappenbecausevam //isforced0ifL8orlsis3et {L8or16，vam})； xtmux4e#8(output[158]， `$in`[158]， `$in`[2216]， 8′b0， 8′b0， {L8UI，vam})； xtmux2e#8(output[70]， `$in`[70]， `$in`[158]， vam)； ；}else{ ；#rotateisalldonein41muxes， ；#sosignextendmustbedoneinseparate21 ；for(my$i＝$mux-2；$i＞＝0；$i-＝2){ ；my$out＝′t′.($temp++)； wire[`$bits-1`0]`$out`； ；rot($bits，4，8*(1＜＜$i)，$in，$out，′vam[′.($i+1).′′.$i.′]′)； ；$in＝$out； ；} assignout＝{ ；if($bits＞32){ `$in`[`$bits-1`32]， ；} L8or16？{16{`$in`[15]&amp;L16SI}}`$in`[1632]， `$in`[158]&amp;～{8{L8UI}}， `$in`[70]}； ；} endmoduleloadalign下面是为128宽度的输出 moduleloadalign(out，in，va，vamask，TIEload，L16SI，L16UI，L8UI)； outputout[1270]； inputin[1270]； inputva[30]； inputvamask[30]； inputTIEload； inputL16SI； inputL16UI； inputL8UI； wireL8or16＝L8UI|L16UI|L16SI； wirevam[30]＝TIEload ？va&amp;vamask {va[32]，va[1]&amp;L8or16，va&amp;L8UI}； wire[1270]t0； xtmux4e#128(t0，<dpn="d25"/> input， {input[310]，input[12732]}， {input[630]，input[12764]}， {input[950]，input[12796]}， vam[32])； wire[1270]t1； xtmux4e#128(t1， t0， {t0[70]，t0[1278]}， {t0[150]，t0[12716]}， {t0[230]，t0[12724]}， vam[10])； assignout＝{ t1[12732]， L8or16？{16{t1[15]&amp;L16SI}}t1[1632]， t1[158]&amp;-{8{L8UI}}， t1[70]}；endmoduleloadalign下面是为64宽度的输出 moduleloadalign(out，in，va，vamask，TIEload，L16SI，L16UI，L8UI)； outputout[630]； inputin[630]；<dpn="d26"/>inputva[20]；iuputvamask[20]；inputTIEload；inputL16SI；inputL16UI；inputL8UI；wireL8or16＝L8UI|L16UI|L16SI；wirevam[20]＝TIEload ？va&amp;vamask {va[22]，va[1]&amp;L8or16，va&amp;L8UI}；wire[630]t0；xtmux4e#64(t0， input， {input[150]，input[6316]}， {input[310]，input[6332]}， {input[470]，input[6348]}， vam[21])；xtmux2e#32(output[6332]， t0[6332]， {t0[70]，t0[6340]}， vam)；xtmux4e#16(output[3116]， t0[3116]， t0[3924]}， {16{t0[15]&amp;L16SI}}， 16′b0′//shouldneverhappenbecausevam //isforced0ifL8or16isset {L8or16，vam})； xtmux4e#8(output[158]， t0[158]， t0[2316]， 8′b0， 8′b0， {L8UI，vam})； xtmux2e#8(output[70]， t0[70]， t0[158]， vam)； endmoduleloadalign下面是为32宽度的输出 moduleloadalign(out，in，va，vamask，TIEload，L16SI，L16UI，L8UI)； outputout[310]； inputin{310]；<dpn="d27"/>inputva[10]；inputvamask[10]；inputTIEload；inputL16SI；inputL16UI；inputL8UI；wireL8or16＝L8UI|L16UI|L16SI；wirevam[10]＝TIEload ？va&amp;vamask {va[12]，va[1]&amp;L8or16，va&amp;L8UI}；wire[310]t0；xtmux4e#32(t0， input， {input[70]，input[318]}， {input[150]，input[3116]}， {input[230]，input[3124]}， vam[10])；assignout＝{ L8or16？{16{t0[15]&amp;L16SI}}t0[1632]， t0[158]&amp;-{8{L8UI}}， t0[70]}；endmoduleloadalign对核心的接口装入和存储典型地，在处理器流水线中使用一个数据缓存或一个小数据RAM进行处理。为了开销和正确性，新的装入和存储指令也必须使用这个数据缓存/RAM以保持被TIE及核心指令所处理的缓存/RAM数据的完整。在现有技术系统中，增加到核心的指令不与核心共享逻辑。本优选实施例提供了用于进行这种共享的结构。TIE结构interface<sname><width><mname>[in|out]声明了一个对模块<mname>有接口的信号<sname>TIE。该信号为<width>字节宽，并且根据最后一个参数，要么是TIE码的输出要么输入给该TIE码。对于对核心的接口，<mname>是core。TIEiclass结构被进行了扩展以列出指令使用的接口信号。其语法是iclass<classname>{<iname>，...}{<operandspec>，...}{<statespee>，...]{<interfacespec>，...}这里，<interfacespec>要么是in<sname>，要么是out<sname>，其中<sname>要么是接口信号名，要么是异常语句中声明的异常信号名。异常信号名只可以用作输出，而不能用作输入。此外，schedule结构被进行了扩展以允许通过使用“in”(对于输入)或“out”(对于输出)将流水线阶段数给予接口信号名。每个来自语义块的输出接口信号与指令的一热指令解码信号的“或”(OR)相“与”(AND)，这些指令的输出被列表在其iclass的接口部分的。然后来自所有的语义块的被“与”(AND)的接口信号被“或”(OR)在一起以形成对核心的输出信号。图7说明TIE编译程序的输出接口信号sname的实现。SnamesenI代表由第i个语义块产生的sname的值。iN1和iN2是单字节指令解码信号，并且SnamesenIsel是一个代表第i个语义产生sname时的条件的信号。每个输入接口信号被直接馈送给使用该信号的模块。TIE中的编译程序/操作系统支持目前TIE结构已经允许定义状态和指令，但是还不提供有关这些指令如何被软件自动使用的途径。在现有系统中，所有的指令的使用都是通过参考被写入到应用中内部语句实现的；因此，编译程序只需要将指令变换为内部语句，而不需要知道如何使用指令本身。增加用户定义的寄存器文件后，需要编译程序将程序变量分配给寄存器文件的元素。在寄存器分配期间，编译程序将程序值分配给寄存器文件中包含的寄存器。在程序中的某一存储单元，不可能将所有的值分配给存器。在这些存储单元中，必须将一个或多个值移动到存储器。将一个来值从寄存器移动到存储器需要一个存储，而将一个值从存储器移动到寄存器需要一个装入。因此，至少编译程序必须知道如何将一个值从存储器装入到寄存器，以及如何将一个值从寄存器存储到存储器。在寄存器分配期间，还需要编译程序将一个值从一个寄存器移动到另一个寄存器。例如，由一个函数产生的值可能在寄存器A中返回，而下一条指令可能需要从寄存器B使用该值。编译程序能够通过先将寄存器A存储到一个临时存储器存储单元，然后从该存储器存储单元装入到寄存器B，从而实现将该值从寄存器A移动到寄存器B。但是，将该值从寄存器A直接移动到寄存器B可能效率会更高。因此，理想情况下(但并非必须)编译程序应该知道如何将一个值从一个寄存器移动到另一个寄存器。保存及恢复序列可能比单个寄存器的存储及恢复序列的简单连接更为复杂。在作整个寄存器文件时，与溢出指令的显而易见的连接相比，可能有机会提高性能及/或节省空间。这也可以包括不在寄存器文件中的协处理器状态。每个协处理器的状态由各种不同且潜在地彼此相关的组件构成。用于保存和恢复这些组件的指令序列可能依赖于该彼此相关性。这个相关性信息能够被表示为一个图形。如果图形为循环的，则状态不能及时在任意一点被成功保存。但是如果图形是非循环的(一个DAG)，则有一个方式可以将组件的保存和恢复进行排序，以便所有协处理器的状态能够在任意一点被及时保存和恢复。TIE编译程序使用标准图形结构及分析算法来产生和分析这个相关性信息，并且要在为某一给定协处理器生成保存和恢复序列时考虑到这些信息。例如，考虑一个具有两个寄存器文件regfile_a和regfile_b的协处理器，regfile_a具有四个32位寄存器，regfile_b具有十六个128位的值。增加的状态是一个位字段，其寄存器已经被触发，称作reg_touched，而一个将寄存器推向regfile_a的后寄存器0的位字节称作reg_back。该协处理器提供下面的装入和存储指令以保存和恢复协处理器状态 rur/wur--foraccesstoreg_touchedandreg_back push_a--copiesregfile_aregister0intoreg_back pop_a--copiesregfile_aregister0fromreg_back<dpn="d30"/> s128breg_a_register，reg_b_register-storestheregisterfileregfile_bintotheaddressspecifiedbyregfile_a＇sregister l128breg_a_register，reg_b_register-loadstheregisterfileregfile_bfromtheaddressspecifiedbyregfile_a′sregister s32areg_a_register，reg_a_register-storestheregisterfileregfile_aintotheaddressspecifiedbyregfile_a′sregister l32areg_a_register，reg_a_register-loadstheregisterfileregfile_aintotheaddressspecifiedbyregfile_a＇sregister在这种情况下，对于这个保存状态独立性的DAG表示为reg_touched<--regfile_a，regfile_b，reg_back因为该协处理器的TIE使然，这样reg_touched将在regfile_a、reg_b或reg_back被触发的任何时间发生改变。regfile_a<----reg_back因为在regfile_a中的寄存器保存需要一个在regfile_a中的空闲寄存器。为了获得一个regfile_a中的空闲寄存器，需要通过reg_back移动寄存器的值。这就破坏了reg_back的当前值。regfile_a<----regfile_b因为regfile_b的存储指令使用一个regfile_a中的寄存器作为要存储的地址。这意味着一旦regfile_a已经被存储了，则regfile_b就只能被存储了—实际上只是regfile_a中的一个寄存器。为了例子的简化，这一点被掩盖了。因此，保存序列可以确保状态是按适当的顺序被保存的。这种情况下其顺序为reg_touched，reg_back，regfile_a，regfile_b此外，因为本优选实施例允许寄存器文件的定义，该寄存器文件的元素不能表示为标准编程语言的内置类型(如C语言或上述的饱和算法中的64+位)，所以需要有一个机构用于增加新类型以匹配所定义的硬件。编程语言类型对于决定一个变量可以被分配给哪个寄存器是有用的。例如，因为整数计算指令只取它们在整数寄存器文件中的操作数，浮点指令只取它们在浮点寄存器文件中的操作数，所以在许多ISA中通常将整数值变换为一个寄存器文件及将浮点值变换为另一个寄存器文件。为了实现创建新数据类型的功能，需要有一个结构用于规定在内置类型和新类型间，以及不同的新类型间进行允许的转换。例如，在C编程语言中允许在char类型变量和short类型变量间的转换(通过符号或零扩展char类型)。TIE结构ctype<tname><size><alignment><rfname>创建了一个编程语言类型<tname>，并且声明其为<size>位，在存储器中的一个<alignment>位边界对准，并且被分配给<rfname>。例如，还是伽罗瓦字段算法GF单元，表达式ctypegf888gf声明了一个名为“gf8”的新类型(对于本优选实施例中的C编程语言)，它具有8位的在8位的存储器边界上对准的值，并且这些值是按需要被寄存器分配给“gf”寄存器文件的。TIE结构proto<pname>{<ospec>，...}{<tspec>，...}{<inst>...}被用于规定执行编译程序必须知道的各种功能的指令序列，获用于给出有关内部语句的操作数的类型信息。<ospec>是操作数类型规范，<tspec>是指令序列需要的临时寄存器规范，而<inst>是序列的指令。<ospec>的语法是[in|out|inout]<typename>[*]<oname>其中<oname>是一个可以被代入序列的指令(<inst>)的操作数名。<typename>是操作数的名称(如果星号给出则是指向该类型的指示字)。临时寄存器规范<tspec>的语法是<rfname><oname>其中<oname>是一个可以被代入序列的指令(<inst>)的操作数名。<typename>是一个类型名称，它用于识别应该从哪个寄存器文件为这个序列将<oname>临时分配。在序列<inst>中的指令语法是<iname>[<oname>|<literal>]，...；其中<iname>是指令名称，<oname>是一个在<ospec>或<tspec>中声明的操作数名称，<literal>是一个常数或字符串，它可以在生成proto规定的指令序列时不可改变地被编译程序使用。Proto的一个用途是，为了定义内部语句，简单地将类型与指令操作数结合。在这种情况中，<pname>是指令名；<ospec>与iclass操作数规范相匹配(除了增加了类型名)；<tspec>列表应该为空；并且<inst>序列应该由单个指令组成。一个可能的例子protoGFADD8{outgf8r，ingf8s，ingf8t}{}{GFADD8r，s，t；}proto的另一个用途是定义多指令内部语句。这里<tspec>可以是非空。例如protoGFADDXSQ8{outgf8r，ingf8s}{gf8tmp}{GFMULX8tmp，s；GFMULX8r，tmp；}proto的一个附加用途是指示编译程序如何装入和存储用ctypeTIE结构声明的编程语言类型的值。如上面讨论的，为了使编译程序执行寄存器分配，以及允许寄存器文件的内容在某个任务转移时被保存和恢复，需要能够向存储器和从存储器中装入和存储值。对于每个ctype<tnamr>声明，必须有下面形式的proto声明。 proto＜tname＞_loadi {out＜tname＞＜x＞， in＜tname＞*＜y＞， inimmediate＜z＞} {＜tspec＞，...} { ＜inst＞...//sequenceofinstructionsthatloads //register＜x＞fromtheaddress＜y＞+＜z＞ } proto＜tname＞_storei {in＜tname＞＜x＞， in＜tname＞*＜y＞， inimmediate＜z＞} {＜tspec＞，...} { ＜inst＞...//sequenceofinstructionsthatstores //register＜x＞fromtheaddress＜y＞+＜z＞ }<tname>_loadi_proto告诉编译程序用于将类型<tname>的值从存储器装入寄存器的指令序列。<tname>_storei_proto告诉编译程序用于将<tname>的值从寄存器存储到存储器的指令序列。如上所述，需要编译程序知道如何将一个值从一个寄存器移动到另一个寄存器。在进行装入和存储时，proto用于指示编译程序如何在寄存器间移动值。对于每个ctype<tname>声明，可能有如下形式的proto声明。 proto＜tname＞_move {out＜tname＞＜x＞， in＜tname＞＜y＞} {＜tspec＞，...} { ＜inst＞...//sequenceofinstructionsthatmoves //register＜y＞toregister＜x＞ }例如，还是伽罗瓦算法GF单元，proto声明protogf8_loadi{outgf8t，ingf8*s，inimmediateo}{}{ LGF8.It，s，o；}protogf8_storei{ingf8t，ingf8*s，inimmediateo}{}{ SGF8.It，s，o；}protogf8_move{outgf8r，ingf8s}{}{ GFADD8Ir，s，o；}需要输入到本优选实施例中，以使编译程序执行gf8变量的寄存器分配；还需要输入它们，以来为gf寄存器文件生成任务状态转移序列。最后一个proto的用途就是定义在内置的和增加的类型之间的，以及不同的新类型之间的允许的转换。转换原型不是必需的；如果，例如，没有规定一个在新类型A和新类型B之间的转换，则编译程序就不允许类型A的变量转换为类型B的变量。对于每对新的或内置的类型<t1name>和<t2name>(其中至多有一个内置类型；这个结构不允许两个内置类型之间的转换的规范，因为这个转换已经被编程语言定义了)，能够有三个如下形式的proto声明proto＜t1name＞_rtor_＜t2name＞ {out＜t2name＞＜x＞， in＜t1name＞＜y＞} {＜tspec＞，...} { ＜inst＞...//sequenceofinstructionsthatconverts //type＜t1name＞inregister＜y＞totype //＜t2name＞inregister＜x＞ } proto＜t1name＞_rtom_＜t2name＞ {in＜t1name＞＜x＞， in＜t2name＞*＜y＞， inimmediate＜z＞}<dpn="d35"/> {＜tspec＞，...} { ＜inst＞...//sequenceofinstructionsthatstores //type＜t1name＞inregister＜x＞as //type＜t2name＞attheaddress＜y＞+＜z＞ } proto＜t1name＞_mtor_＜t2name＞ out＜t2name＞＜x＞， in＜t1name＞*＜y＞， inimmediate＜z＞} {＜tspec＞，...} { ＜inst＞...//sequenceofinstructionsthatloads //type＜t1name＞fromtheaddress＜y＞+＜z＞ //astype＜t2name＞intoregister＜x＞ }例如，还是伽罗瓦字段算法GF单元，proto声明 protogf8_rtom_char{ingf8t，inchar*s，inimmediateo}{}{ SGF8.It，s，o； } protochar_mtor_gf8{outgf8t，inchar*s，inimmediateo}{}{ LGF8.It，s，o； }将允许存储器中的类型char和寄存器中的类型gf8之间的转换。对于这些proto，下面的例子说明了如何利用GFADD内部语句将chars的两个矢量相加。 void gfadd_vector(char*char_vector0，char*char_vector1，intsize) { for(inti＝0；i＜size；i++){ gf8p0＝char_vector0[i]； gf8p1＝char_vector1[i]； gf8res＝GFADD(p0，p1)； charvector0[i]＝res； } }在现有技术系统(如GNU编译程序)中，编译程序保持每个程序变量和编译程序生成的临时变量的类型信息。这些内置变量类型与高级语言(如C语言中的cnar，short，int，float，double等)相对应。对于每个内置类型，编译程序必须知道类型需要的类型的名称，大小及对准，以及必须向哪个寄存器文件分配类型的值。对于新类型，这个信息是由ctype语言结构提供的。使用ctype信息，编译程序生成一个内部类型结构来代表该类型，并且将该类型用于程序变量和按与内置类型相同的方式由编译程序生成的临时变量。现有技术的GUNC语言编译程序使用枚举类型machine_mode在内部表达类型。相关的类型按类分组在一起，由枚举类型machine_class进行描述。要支持新的类型，本领域的技术人员可以向machine_class增加一个枚举器来表示代表用户定义的类型的类，并且可以利用ctypeTIE语言结构为每个声明的新类型向machine_mode增加一个枚举器。例如，假定代表新类型的类称作MODE_USER，在machmode.h文件中的mode_class的定义为enummode_class{MODE_RANDOM，MODE_INT，MODE_FLOAT，MODE_PARTIAL_INT，MODE_CC，MODE_COMPLEX_INT，MODE_COMPLEX_FLOAT，MODE_USER，MAX_MODE_CLASS}；通过在文件machmode.def中插入行而向machine_mode增加了枚举器。每行定义一个新类型，它的名称，它的类以及它的大小(以8位字节给出)。用户定义的类型的枚举器名为U<n>mode，其中0<n>是界于0和用户定义的类型的总个数之间的一个数。例如，在上面的例子中，要增加一个内部类型来代表以前例子种的用户定义的类型gf8，需要增加下面一行DEF_MACHMODE(Uomode，＂U0＂，MODE_USER，1，1，VOIDmode)本领域的技术人员可以更改GUNC编译程序使用的分析和优化逻辑，以使其正确执行于MODE_USER类的类型。在现有技术编译程序中，代码选择器(或代码生成器)负责为每个内部表达的低级指令替换一低级指令序列(有些相当于汇编指令)。代码选择器通过检查由内部指令及指令操作数的类型执行的操作，决定以哪个指令序列替换。例如，代表add的一个内部指令可以有两个int类型的值作为输入，一个int类型的值作为输出；或者可以有两个float类型的值作为输入，有一个float类型的值作为输出。在输入和输出值类型的基础之上，代码选择器要么选择执行整数加的指令的序列，要么选择执行浮点加的指令的序列。对于用户定义的类型，装入、存储、移动和转换proto定义，描述了用于替换具有一个或多个用户定义类型的操作数的内部指令的指令序列。还是伽罗瓦算法GF单元的例子，如果内部指令代表一个gf8值的装入，则代码选择器询问gf8_loadiproto以决定要为该指令的指令序列。在现有技术GNUC编译程序中，在目标处理器中可用的指令是利用指令模式进行描述的；请见，例如Stallman，“UsingandPortingGNUCC”(1995)获得更多信息。这些指令模式描述指令，包括操作数的个数及类型。要在编译程序中支持用户定义的类型，要将装入、存储、移动及转换proto转换为编译程序支持的指令模式。例如，gf8_loadproto可按下面的模式表示(假定gf8类型已经被变换为machine_mode枚举器U0mode)(define_insn＂＂[(set(match_operandU00＂register_operand＂＂v＂)(match_operandU01＂memory_operand＂＂U＂))]＂＂＂LGF8.I\t％0，％1＂)规定一个临时寄存器的proto被转变为一个覆盖了或“打破(clobber)”了某类型的操作数的指令模式。编译程序将保证被“打破”的操作数在该指令的存储单元不可用，以便于指令可以将其用作一个临时的操作数。例如，下面的对于用户定义类型的tt的装入proto生成了一个包含一个“打破”的指令模式。 protott_loadi{outttx，intt*y，inimmediatez}{chart} { L8UIt，y，z； MVTTx，t； } (define_insn＂＂ [(parallel[(set(match_operandU00＂register_operand＂＂v＂) (match_operandU01＂memoryoperand＂＂U＂)) (clobber(match_operandU02＂registeroperand＂＂a＂))])] ＂＂ ＂L8UI\t％2，％1\nMVTT\t％0，％2＂)内部函数声明在Killian等人的申请中，生成了一个内部函数声明文件，该文件中包含所有类似使用GUNasm语句的功能的TIE指令的定义。特别的，每个指令功能具有Cvolatile的特性，以限制可能发生的优化。这个方法，尽管安全，但是阻碍了某些将TIE指令进行安全地重排序的编译程序优化。本发明通过两种方式改进了现有技术系统。第一，只有装入和存储指令被声明为易失的，因此给予了编译程序在代码优化期间的最大的记录指令的自由度。在第二项改进中，使用特殊的和用户声明的状态的指令，通过一个显式的状态变量进行声明，因此给编译程序更精确的有关指令的副作用的信息。下面的头文件是TIE编译程序生成的，用以将所有在GF例子中的指令声明为内部函数 /*Donotmodify.Thisisautomaticallygenerated.*/ typedefintgf8_attribute_((user(＂gf8＂)))； #defineGFADD8_ASM(gr，gs，gt){\ _asm_(＂gfadd8％0，％1，％2＂＂＝v＂(gr)＂v＂(gs)，＂v＂(gt))；\ } #defineGFADD8I_ASM(gr，gs，imm4){\ _asm_(＂gfadd8i％0，％1，％2＂＂＝v＂(gr)＂v＂(gs)，＂i＂(imm4))；\ }<dpn="d39"/>#defineGFMULX8_ASM(gr，gs){\registeriht_xt_stateasm(＂state＂)；\__asm__(＂gfmulx8 ％1，％2＂＂+t＂(_xt_state)，＂＝v＂(gr)＂v＂(gs))；\}#defineGFRWMOD8_ASM(gt){\registerint_xt_stateasm(＂state＂)；\__asm__(＂gfrwmod8％1＂＂+t＂(_xt_state)，＂＝v＂(gt)＂1＂(gt))；\}#defineLGF8_I_ASM(gt，ars，imm8){\__asm__\volatile(＂lgf8_i％0，％1，％2＂＂＝v＂(gt)＂a＂(ars)，＂i＂(imm8))；\}#defineSGF8_I_ASM(gt，ars，imm8){\__asm__\volatile(＂sgf8_i％0，％1，％2＂＂v＂(gt)，＂a＂(ars)，＂i＂(imm8))；\}#defineLGF8_IU_ASM(gt，ars，imm8){\__asm__volatile(＂lgf8_iu％0，％1，％3＂\＂＝v＂(gt)，＂＝a＂(ars)＂1＂(ars)，＂i＂(imm8))；\}#defineSGF8_IU_ASM(gt，ars，imm8){\__asm__volatile(＂sgf8_iu％1，％0，％3＂\＂＝a＂(ars)＂v＂(gt)，＂0＂(ars)，＂i＂(imm8))；\}#defineLGF8_X_ASM(gr，ars，art){\__asm__volatile(＂lgf8_x％0，％1，％2＂\＂＝v＂(gr)＂a＂(ars)，＂a＂(art))；\}#defineSGF8_X_ASM(gr，ars，art){\__asm__volatile(＂sgf8_x％0，％1，％2＂\＂v＂(gr)，＂a＂(ars)，＂a＂(art)}；\}#defineLGF8_XU_ASM(gr，ars，art){\__asm__volatile(＂lgf8_xu％0，％1，％3＂\＂＝v＂(gr)，＂＝a＂(ars)＂1＂(ars)，＂a＂(art))；\}#defineSGF8_XU_ASM(gr，ars，art){\__asm__Volatile(＂sgf8_xu％1，％0，％3＂\＂＝a＂(ars)＂v＂(gr)，＂0＂(ars)，＂a＂(art))；\}在上述举例的输出中，算术指令如，GFADD8I没有被声明为易失的。装入和存储指令如，LGF8_I被声明为易失的。读或写处理器状态的指令如GFRWMOD8还有一个变量xt_state传送有关这些指令有副作用的信号给编译程序。寄存器分配现有技术系统(如GNUC编译程序)包括为移植性设计的寄存器分配算法。移植性要求编译程序支持多种ISA。即使这些ISA本身不是可配置或可扩展的，一个要满足所有这些的编译程序必须具有普遍的寄存器分配功能。因此，现有技术系统允许多寄存器分配，并且某些系统可能限制对于某个寄存器文件的程序语言类型。现有技术的GNUC编译程序允许通过更改目标的机器描述来支持可以规定任何数量的寄存器文件。本领域的技术人员可以通过“UsingandPortingGNUCC”中说明的，为实现某目标而更改机器描述以向GCC增加对一个或多个寄存器文件的支持。对于每个TIEregfile结构，编译程序被自动配置以向寄存器文件中的寄存器分配值。regfile结构指明了在寄存器文件中的寄存器数量。如上所述，当要分配每个具有用户定义类型的程序值时，TIEctype结构规定了要将某种类型的值分配去的寄存器文件。编译程序就利用这个信息以及寄存器文件中的寄存器数量。还是还是伽罗瓦算法GF单元例子，gf寄存器的regfile结构是regfilegf816g这表示有16个gf寄存器，每个为8字段。Gf8类型的ctype结构是ctypegf888gf，这表示类型gf8的值必须分配给寄存器文件。因此，编译程序要将所有的类型gf8的值分配给寄存器文件，该寄存器文件有16个寄存器。指令调度现有技术(如GNUC编译程序)包括重新对指令排序以通过降低流水线停止来提高性能的指令调度算法。当满足了其它流水线的约束，如发送宽度、功能单元可利用性后，这些算法的运行通过模拟目标处理器的流水线来决定能够产生最少数量的停止周期的指令排序来实现。现有技术的GNUC编译程序，对于任何一对指令来讲，通过确定在一个指令紧跟另一个指令被调度时就会产生的停止周期的数量，来模拟处理器的流水线。在每对指令的停止信息的基础上，编译程序要发现可以使总的停止周期最小化的指令排序。对于新的TIE指令，编译程序通过利用TIE语言调度结构提供的信息来确定停止周期。要确定如果指令B紧跟指令A被调度就会发生的停止周期，编译程序将每个A中的输出操作数的写的流水线阶段与每个相应的B中的输入操作数的读流水线阶段相比较。对于每个操作数，将这些值的差加1(因为定义的操作数流水线阶段值的调度结构的语义)，就表是必须将A与B分开以避免停止的最小周期数。值1表示B可以紧跟A后被调度而不会发生停止，值2表示紧跟A后调度B将产生一个停止周期，等等。有关由A写的所有操作数的最大停止值，是B紧跟A被调度时的停止周期数。考虑以下调度结构的例子 scheduleaload{ALD}} { useimm80； usears1； defxt2； } } scheduleaadd{AADD} { usexa1； usexb2； defxc2； }在下面的代码序列中，在ALD指令中的操作数xt，x3，与AADD指令中的xa操作数相同。因此，AADD指令必须在ALD之后的(defxt)-(usexa)+1＝2-1+1＝2个周期才被调度，以避免停止。如果AADD在ALD之后立即被调度，则就会有一个周期的停止。ALDx3，a0，0AADDx0，x3，x1在下面的代码序列中，在ALD指令中的xt操作数，x3，与AADD指令中的xb操作数相同。因此，AADD指令必须在ALD之后的(defxt)-(usexb)+1＝2-2+1＝1个周期才被调度，以避免停止。这种情况下，如果AADD在ALD之后立即被调度，就没有停止。ALDx3，a0，0AADDx0，x1，x3延迟状态切换向处理器增加寄存器文件会增加状态的数量，这些状态必须被保存和恢复为多数实时操作系统使用的多任务环境中的任务切换的一部分。因为增加的状态经常对应某个在一个任务子集中被执行的计算，不应该对每个任务切换保存和恢复这些增加的状态，因为这样作会不必要地增加了任务切换周期的数量。在不可扩展处理器中这也是一个问题，但是在现有技术中有对这一问题的解决方案。例如，MIPSR2000CPENABLE位允许协处理器寄存器从一个任务到另一个任务的“延迟”切换。本优选实施例允许将延迟切换用于由处理器扩展(TIEstate和regfile声明)所创建的状态。这是最复杂的保存和恢复操作之一。它因几个原因而复杂它在比上下文切换延迟的点发生；运行时间必须管理每个处理器文件的有效性；当异常出现时，核心自身就在改变协处理器的有效性。为了说明这是如何被处理的，假定有一个有两个任务A和B的系统。还有两个协处理器寄存器，cp_0和cp_1。系统的状态由核心保持的有效位和由运行时间所保持寄存器文件所有者记录所组成。考虑表I中的事件序列。在本例中，协处理器状态假定被存储在每个任务的堆栈的底部。表I0有效1有效0所有者1所有者事件注释X1X1X无X无初始化核心启动，状态不明。首先系统将所有的寄存器00010001无无无A无无无无任务A创建任务B创建任务A使用cp_0任务B调入文件设为有效。然后调用init程序为每个文件建立状态。在初始化的最后，系统声明所有的寄存器文件对使用无效，并且寄存器文件还没有所有者。在任务A创建期间，操作系统确保使用init_mem调用以使任务A的堆栈的底初始化为“安全”值，作为起始存储。任务A的堆栈指针在这个保存区域后设为开始。协处理器的状态未受影响。任务B的创建与A类似寄存器文件的使用引起了异常。异常建立了有效位。因为没有cp_0的先前所有者，所以没有执行数据的保存。由于任务A访问了协处理器，所以任务A的数据被装入cp_0.cp_0的所有关系分配给A。00110100AAAA无BBB任务B使用cp_1任务A调入任务A使用cp_0调动之后，运行时间将A的状态留在cp_0寄存器文件中。寄存器文件被标记为无效，但是A成为所有者。同前，当A使用cp_0时，异常设置了有效位。运行时间中cp_1以前没有被使用过，所以没有进行存储。运行时间将B的状态装入cp_1并将所有者设给B。在这个调动中有更多的工作要作。因为B正调出并且是cp_1的所有者，所以运行时间清除了cp_1的有效位。在A正在调入时，它为cp_0设置有效位。任务A可以无异常地使用cp_0。注意这只是这个过程的一个实现。所有有效位都可以被关闭并且如果触发协处理器，在异常时，运行时间可以识别A的状态已经被装入了into_cp，并且避免在这一点的恢复。异常已经设置了有效位。因为A的状态已经在cp_0100111AAAAAB任务A使用cp_1任务B调入任务B使用cp_1中，运行时间已经建立了有关上下文切换的有效位。由于建立了有效位，所以不会有异常出现，并且运行时间不必采取行动。任务A使用cp_1引起了异常。这个异常为cp_1建立了有效位。运行时间发现cp_1属于任务B，将cp_1的内容存入任务B的堆栈。然后恢复任务A的状态给cp-1。所有属于任务A的有效为都被关闭。没有属于任务B的协处理器，因此没有开着的有效位。任务B使用cp_1引起了异常。异常打开了cp_1的有效位。运行时间发现cp_1目前属于任务A，将当前的状态存入任务A的保存区域。然后运行时间恢复任务B的状态给cp_1。过程继续延迟切换结构要求将状态分组为可以访问和不能访问的集，访问不能访问的状态会引起异常，异常处理器可以决定必须转换到哪个状态，并且异常处理器能够将状态保存到存储器并从存储器恢复从而重新能够访问。在本优选实施例中，TIE结构coprocessor<came><cumber>{<sname>，...}声明了名为<sname>的位等是一组用于延迟切换的。这个组被给予名称<came>以及一个范围为0-7的数<cumber>。如果任何的<sname>在不止一个的协处理器陈述中被命名则是错误的。给出了上述结构，则在iclass的内/外/内外列表中就创建了一组具有<sname>的指令。之后创建了一个信号，该信号是指令一热解码对于这些指令的“或”。这个信号被与CPENABLE位的“补”相“与”。这些为每个处理器产生的信号接着将与TIE源代码产生的异常相结合，在下面的“异常部分“将对异常进行更为详细的介绍。所有协处理器解除的异常比任何来自TIE源代码的异常具有更高的优先权。在协处理器解除的异常中，最低数值的异常具有优先权。在本优选实施例的核心处理器中，不同的异常都使用同样的向量并且通过被异常写入到EXCCAUSE寄存器中的代码进行区分。核心处理器为这些异常保留了8个触发代码。相应于协处理器语句，TIE编译程序向CPENABLE寄存器增加了<cumber>位，向处理器增加了逻辑，为的是如果<cunber>是清晰的并且任何访问<sname>等的指令执行了则引起一个异常，向处理器增加逻辑从而在异常被核心识别出时将32+<cnumber>写入EXCCAUSE寄存器。TIE中的多周期指令在现有技术中，需要多周期计算的指令需要附加逻辑将结合的计算逻辑放入流水线，并防止依赖于尚未计算出的结果的指令流出。此外，对于这种处理器的编译程序应该包括记录指令以最小化流水线停止的算法。第一项内容一般是通过处理器设计者使流水线寄存器在小心选择的位置插入的协逻辑实现的。第二项内容一般是这样实现的，比较流水中的一个将要发出给所有尚未计算的目的操作数的指令的源操作数，并且如果有一个匹配的则保持该指令。第三项内容必须是协同的。如果计算逻辑的流水线操作与发出逻辑的变化不匹配，则处理器可能会产生错误的结果。如果为了最小化流水线停止的重新排序与计算逻辑的流水线操作不一致，则就会导致次优化性能。(如在一个结果准备好之前调度它的使用将导致流水线停止)。看下面的例子MULa3，a4，a5/*a3＝a4*a5，a2-cycleinstruction*/ADDa6，a3，a7/*a6＝a3+a7，asinglecycleinstruction*/SUBa2，a0，a1/*a2＝a0-a1，asinglecycleinstruction*/如果MUL逻辑在两个周期中实现，但是控制逻辑在每个周期发出一条指令，由于在ADD指令需要的时间a3还没有正确的值，所以a6将会出现错误的结果。为了正确，发出逻辑必须知道MUL被流水线达两个周期，并且在发出ADD指令前要停止一个中期。即使通过停止ADD指令一个周期导致了正确的逻辑，但是它没有提供优化的性能。通过切换ADD指令和SUB指令的次序，在本例子中就不需要停止任何指令，并且因此可以产生优化的性能。这只能通过在MUL逻辑的执行、指令发出逻辑的执以及指令重排序(调度)之间的协同来实现。在现有技术系统中，这三项内容(流水线逻辑、流水线停止及指令调度)经常是分别实现的，这就使得协同更为困难并且增加了设计验证的要求。本发明的优选实施例提供一种方法用以规定被这些特征要求的信息的，并且实现规范中处理器生成程序中的这三项内容。此外，本优选实施例的指令集仿真程序使用同样的时间模型中的调度信息的规范。这允许应用开发者使用所有的本优选实施例的特性，在硬件制造前就获得好的性能预期，而不需要在一个运行很慢的HDL仿真程序上运行他们的应用。这里参考了由Killian和Warthman所著的《Xtensa指令集结构参考手册(XtensaInstructionSetArchitecture(ISA)ReferenceManual)的第十章，它公开了一种描述流水线硬件的方法，该方法已经用于处理器流水线性能建模，并且已经在现有技术中被用于最小化流水线停止。在本优选实施例中，只是将这个描述辅助用于上述三项内容种的前两项。具体地，TIE语言目前包括声明schedule＜schedulename＞{＜iname＞，...} in＜oname＞＜stage＞； . . . out＜oname＞＜stage＞； . . . }其中<iname>是指令名；<oname>是一个操作数或状态名；<stage>是一个表示流水线阶段的序号。TIE使用的缺省阶段号比由Killian和Warthman所著的《Xtensa指令集结构参考手册(XtensaInstructionSetArchitecture(ISA)ReferenceManual)的第十章中说明的值小1，因此，指令间的间距最大值是(SA-SB+1，0)而非(SA-SB，0)。在本规范的基础之上，在Killian等人和Wilson等人申请中描述的TIE编译程序被扩展，以向语义逻辑规范中插入流水线寄存器。向每个对语义块的输入分配了一个阶段号。指令解码信号及立即操作数被分配了“实现特定”的号(在本优选实施例中为0)。寄存器源操作数，状态寄存器及接口信号(下面说明)被分配了来自TIE调度声明(在本优选实施例中为“实现特定”缺省值—1)的阶段号。下一步，每个语义块的节点在后根序(即语义块的处理器节点都被访问过后)中被访问。接点NS的阶段号是节点输入所有阶段号中最大的。对于每个具有阶段号IS＜NS的输入，编译程序在输入和节点间插入NS-IS个流水线寄存器。最后，输出寄存器操作数，状态寄存器及接口信号被访问。如果来自语义块IS的阶段号比在调度语句中声明的阶段号OS大，则输入的TIE规范就错了。否则，如果OS＞IS，则要在输出前插入OS减IS个流水线寄存器。通过下例说明这一过程 states11 states232 states332 iclasscomplex{example}{outarr，inars，inart}{ins1，in ins3} semanticcomplex{example}{ wire[310]temp1＝s1？arsart； wire[310]temp2＝s2-temp1； assignarr＝s3+temp2； } schedulecomplex{example}{ inars1；/*usingoperandarsinstage1*/ inart1；/*usingoperandartinstage1*/ ins12；/*usingstates1instage2*/ ins22；/*usingstates2instage2*/ ins31；/*usingstates3instage1*/ outarr3；/*definingoperandarrinstage3*/ }这个例子规定指令“example”使用操作数ars、art且在阶段1使用状态s3，在阶段2使用状态s1和s2。它在阶段3产生结果操作数arr。对于这个描述，上面的寄存器插入程序将产生图8(a)中的电路。因为最大输入阶段是2，所以节点“？”的NS是2。因为ars和art的IS是1，所以在节点“？”的各个输入中插入一个寄存器。类似地，在节点“+”，s3输入被延迟了一个阶段以与其它输入相匹配。最后，节点“+”的输出在被分配给arr前被延迟了一个周期。如果在上述例子的调度描述中声明arr为“outarr1”，则流水线插入程序将产生图8(b)中的电路。既然节点“？”的NS是2且arr的OS是1，由于不满足输入调度要求，所以程序将发出一个错误信息。上述算法可以根据需要正确地插入了流水线寄存器，但是这些寄存器的排列离优化还较远。在初始插入以生成用于合成的可接受的逻辑之后，有必要使用一个流水线寄存器优化算法，如在《Synopsys’DesignCompiler》建立的算法。这一般是通过在组合逻辑中移动寄存器，以平衡寄存器两侧的逻辑延迟实现的。使用上述例子，寄存器优化将产生一个如图8(c)中的电路，其中在节点“+”的输出处的寄存器被移动到输入处以平衡延迟和降低周期时间。在某些情况下，可能需要有一个为一个指令在一流水线阶段使用或定义一个寄存器操作数语义块，而在另一个阶段为一个不同的指令使用或定义一个寄存器操作数语义块，这是因为两个指令可能共享一些共同的逻辑。规定指令在两个分离的语义块会需要不必的逻辑复制。这是在有关本实施例的一个变型中的可能的扩展。通过在为两个操作数，如<operand>@<stage>而不只是<operand>，的语义块中使用分离信号名，就可以支持这个能力。一旦这个更改实现了，上述算法即使在多系统环境中也能正确运行。例如，如果要实现下面的两条指令inst1arr＝ars+artinst2arr＝ars+art+s1而由于某些原因，s1必须为阶段1输入，且周期时间要求只能在一个周期中执行一个加法。使用上述扩展，语义描述将如下semantictwo{inst1，inst2}{wire[310]temp＝ars+(inst1？arts1)；assignarr＝temp；assignarr@2＝temp+art@2；}通过用两个扩展信号名ars@2和art@2来描述在一个单一语义块中两个指令，这两个指令可以通过两个加法器被执行，而不是要求两条指令在两个分离的语义块中说明的三个加法器。异常大多数处理器都具有让指令在某些条件下引起异常而不是全部完成的结构。例如，一条除法指令可以在除数为零时引起一个异常。本优选实施例通过首先声明下面的新的异常来支持TIE的这种能力exception<ename><exceptioncode>{<exc1>，...}<string>其中<ename>是在语义块中使用的引起异常的指令及信号的名称；<exceptioncode>是传递给软件异常处理器以将该异常区别于其它异常的值；<exc1>等是低优先权异常；<string>是将用于文档的描述性字符串。一旦声明，异常信号可以列表于上述的ielass声明中。利用该声明，一个具有异常名的单一位的信号就由包含定义的指令的TIE语义块创建，且这个信号必须被指派。图9表示由TIE编译程序产生的用于结合来自多个TIE块的异常信号，并且用于在单一指令发出一个以上的异常信号时对异常进行优先权排列。异常信号也可以在调度声明中给予一个阶段号。然而，在本优选实施例中，核心处理器在其M流水线阶段处理所有的异常。对于这种实现，要检查由调度声明规定的阶段号以确保其比M阶段的阶段号小或与其相等，并且如果不是这样，则在编译时间产生一错误信号。如果确定的阶段号比M阶段的阶段号小或与其相等，则就使用M阶段的阶段号。因此，图9的逻辑在第M阶段被得出的。如图9所示，由每个语义块产生的异常信号被与在接口部分声明异常信号的一热指令解码信号的“或”相“与”(这使得TIE代码在引起异常的指令被执行时，只产生一个有效异常信号)。然后，所有的异常信号被“或”，以产生一个指示某些异常正在发生的单一信号。与现有技术一样，这个信号被核心所处理。最后，使用一个优先权编码器，用以确定哪个优先权代码将被写入核心处理器的EXCCAUSE寄存器。低优先权异常的列表被用于组成一个有向图(如果检查到一个周期，则认为是一个编译时间错误)。创建了一个这种图表的拓扑排序(如在Unix中的tsort程序)，且将得出的次序用于产生各种异常信号的优先权编码。优先权编码的结果然后被用于选择在多路复用器中的相应的异常代码。然后这个信号，象在现有技术中那样，被核心所处理。作为例子，图9表示了下面三个划分了优先权的全部出现在周期N的异常信号的TIE描述的逻辑。 iclassi1{inst1}{...}{...}{outexc1} iclassi2{inst2}{...}{...}{outexc2} iclassi3{inst3}{...}{...}{outexc3} iclassi4{inst4}{...}{...}{outexc1} exception＜exc1＞＜exccode1＞{}“Lowlevelexceptioncondition” exception＜exc2＞＜exccode2＞{}“Mediumlevelexceptioncondition” exception＜exc3＞＜exccode3＞{}“Highlevelexceptioncondition” schedules1{inst1}{defexc11；} schedules2{inst2}{defexc13；} schedules3{inst3}{defexc12；} schedules4{inst4}{defexc13；}在这种情况下，异常exc1可以在C1中由inst1和在C3中由inst4引发，exc2可以在C3中由inst2引发，exc3可以在C2中由inst3引发。在本具体实施例中，所有的异常信号都是在它们的声明阶段生成的，并且继续流水线至提交阶段，在该阶段，通过按在上述TIE说明中规定的异常信号的优先权选择异常代码，来计算异常引发值。该异常信号Exception及引发信号ExcCause被馈送给核心。一旦一个异常开始被处理了，核心将发回一个信号给TIE逻辑以消除所有在流水线中的指令，并有效地清除剩余的未处理的异常。另一个例子，图10表示由代码描述的电路，该代码将有两个异常及一些产生一个异常的指令和一个产生两个异常的指令。在本例中，“溢出”的优先权比“被零除”的优先权低(实际上在一个除法中两者可能同时发生，因此相对优先权是不相关的)。在图中，注意到每个描述的语义块都会产生一些全部的TIE异常集的子集；因此，精确的布线是有赖于输入的。此外，在语义块中，异常输出被通过TIE调度结构流水线到分解阶段。 exceptionOverflow40{}＂IntegerOverflow＂ exceptionDivZero41{Overflow}＂IntegerDividebyZero＂ iclassov{ADDO，SUBO，MULO，DIVO}{outarr，ars，art} {outOverflow} referenceADDO{ wire[320]t＝{ars[31]，ars}+{art[31]，art}； assignOverflow＝t[32]！＝t[31]； assignarr＝t[310]； } referenceSUBO{ wire[320]t＝{ars[31]，ars}-{art[31]，art}； assignOverflow＝t[32]！＝t[31]； assignarr＝t[310]； } referenceMULO{ wire[630]t＝{{32{ars[31]}，ars}*{{32{art[31]}，art}； assignOverflow＝t[6332]！＝{32{t[31]}}； assignarr＝t[310]； } semantic{ADDO，SUBO}{ wire[320]t＝{ars[31]，ars}+({ars[31]，art}^ {{33}SUBO})+SUBO； assignOverflow＝t[32]！＝t[31]； assignarr＝t[310]； } semantic{DIVO}{ assignDivZero＝art＝＝32′b0； assignOverflow＝(ars＝＝32′h80000000)&amp;(art＝＝ 32′hffffffff)； assignarr＝...； }图10表示一个排列，其中所有的TIE异常都具有一个单一的固定的相对于所有核心异常的优先权。一个直接扩展允许TIE异常语句显式地引用各种核心异常。这样TIE编译程序将能够产生一个优先权解码，而不是将TIE异常与核心异常相结合。参考语义类似那些在Killian等人和Wilson等人的申请中描述的系统，每个指令具有一个单一的语义定义。这个语义定义用于生成代表指令的硬件和软件。这些系统允许将多个指令定义在一起，由一热指令解码输入信号进行区分(如“加”及“减”指令能够共享一个加法器)。使用这些特性对于生成高效的硬件是必要的。随着本优选实施例定义的指令复杂性的提高，一套有效率的实现语义就变得越来越难以读、写、检验和理解。它们也变得更多为流水线调整，且缺少抽象性。这是因为描述必须考虑流水线效果，并创建流水线寄存器在其中能够被移动的信号。例如，给定一个TIE中的浮点实现，为了实现相对于3周期或4周期的一个2周期的浮点加操作，可能写出不同的代码。因为程序员经常以牺牲清晰性为代价来优化代码，以便产生更少的门，这就缺乏抽象性。例如，一个人可能用参考语义清楚地写出assignx＝y*3；但是以实现语义写出则是assignx＝y+{y[300]，1′b0}；因为软件开发工具不处理常数相乘的情况，以及类似的能够手工处理的情况。另一个例子说明一个参考语义的乘法累加指令，该例如下acc＝a*b+acc；但是在语义描述中，必须考虑到这条指令必须通过两个流水线阶段执行。一个熟练的硬件设计人员会知道a*b的部分结果需要在第一阶段使用一个进位保留加法器树进行计算，并且将两个部分结果与acc相加的最终结果是在第二阶段计算出的。最后，实现语义在被翻译为仿真软件时会变慢，这是因为失去了与本地机器指令的对应。使用先前的指令，参考描述能够使用两条指令进行仿真。在这种情况下要仿真语义描述将使用成百条的指令。由于上述原因，本优选实施例允许两套语义的规范。一套被称为参考语义。每条指令有一个参考语义，而且在指令间没有语义的共享。写这样的语义定义通常是为了清晰地定义期望的指令的操作。第二套语义是实现语义，它用于硬件执行。这些指令保持了现有技术系统的特性，从而允许硬件被多个指令所共享，并且通常通过在头脑中的门级合成，以更低的级别写出。这可以通过一个定义两个指令“ADD”和“SUB”的简单的TIE例子说明如下 iclassrrr{ADD，SUB}{outarr，inars，inart} iclassrr{NEG}{outarr，inars} referenceADD{ assignarr＝ars+art； } referenceSUB{ assignarr＝ars-art； } referenceNEG{ assignarr＝-ars； } semanticalu{ADD，SUB，NEG}{ wire[310]l，r； assignl＝SUB？-artNEG？-arsart； assignc＝(SUB|NEG)？10； assignr＝NEG？0ars； assignarr＝l+r+c； }参考描述简单而直接。而语义描述必须关心其自身的实现效率，特别是在共享三个指令需要的地址的情况下。要作到这一点，它要依据一个数学恒等，即减去一个数与将该“逐位补”数与常数1相加。参考语义也也允许一个指令集通过参考被定义一次，然后以不同的实现语义集执行多次。在工业上通常使用带有多个实现的单一ISA定义，即使通常参考语义只在ISA文档中定义而不是正式的定义。本优选实施例与这些典型的程序正相反，正式地定义参考语义，并且从TIE规范得出这些文档，而不是从相反。参考及实现语义的分离需要验证它们的等价性。在现有技术系统中，参考语义位于文档，等价是通过人为阅读文档和写测试程序来验证的。这个程序费时，并且由于参考语义是用精确语言规定的，所以可以利用逻辑等价工具将参考语义比作实现语义。本优选实施例以两种方式，通过产生对等价检查工具的必要输入来使这一过程自动化，一种方式用于检查参考和实现语义对于特定指令的等价，另一种方式用于检查使用参考语义的整个实现的电路与使用实现语义实现的电路等价。第一种方法帮助发现实现语义描述的缺陷，第二种方法将从整体上验证设计，不仅包括由语义确定的逻辑，而且包括用于结合所有语义的粘合逻辑。从参考和实现语义产生的电路通常是不等价的。对于某条给定的指令，只能设置输出信号的一个子集。对于其它输出信号，参考和实现语义可能考虑到成本或描述的简单而选择分配不同的值，因为它们逻辑上“不在乎”，也就是它们是不被使用过的。本优选实施例通过创建附加逻辑来解决这些问题，这样由某个特定的指令产生的输出信号不变，而其它的输出信号被强制为个特定的逻辑值，如0，说明见图11的。该图表示每个由参考描述(x_ref)产生的输出信号和每个由语义描述(x_impl)产生的输出信号被与另一个信号ignore_x相“与”，以便当x不是一条指令的部分输出时，被强制为0，因而避免来自等价检查工具的错误的否定结果。从ICLASS陈述中，我们可以了解设置x的指令集，因此，ignore_x只不过是不设置x的指令的逻辑“或”。内置模块某些通常使用的计算没有被语言定义的操作数。但是，如果使用其它语言结构，则不是描述冗长就是难以高效执行。TIE提供了见于下面的表II的用于这些计算的内置操作数。表II格式描述结果定义TIEmul(a，b，sign)由符号和无符号的乘法{{m{a[n-1]&s}}*{{n{a[m-1]&s}}，b}，其中n是a的长度，m是b的长度。TIEmac(a，b，sign，negate)乘法累价n？c-a*bc+a*bTIEadd(a，b，cin)与输入相加a+b+cinTIEcsa(a，b，c)进位保留加法器{a&b|a&c|b&c，a^b^c}作为一个例子，下面的描述在ADD和SUB指令间共享一个加法器。assignarr＝TIEadd(ars，SUB？-artart，SUB)；下面的语义描述使用一个后面跟有全加器的进位保留加法器(CSA)阵列将四个数相加。wire[310]s1，c1，s2，c2；assign{s1，c1}＝TIEcsa(d1，d2，d3)；assign{s2，c2}＝TIEcsa(c1<<1，s1，d4)；assignsum＝(c2<<1)+s2；使用象这些内置模块的优点是，TIE编译程序能够识别内置模块并且用一个模块生成器来为模块产身更高效率的执行。文档参考语义也是指令集文档的一个重要元素。一个典型的指令集参考手册(图12为其一示例页)可以包括每条指令的机器代码格式、包、汇编语法、摘要(指令的一行文本描述)、指令的全文本描述、指令的更精确的操作定义、以及如汇编注释和与指令有关的异常等附加信息。由于TIE规范包含操作码位和操作数字节，因此所有的对于生成机器代码格式所需的信息都已经在其中。类似地，汇编语法可以从助记符号和操作数名得出。TIE参考语义就成为精确定义。只是没有摘要和文本描述。本优选实施例因此向TIE增加了结构以允许指令集设计者规定摘要和文本描述。TIEpackage规范具有格式package<pname><string>endpackage<pname>包名<pname>与所有的在package和endpackage之间定义的指令有关。包具有除对文档以外的其它更多用途，下面将说明。参数<string>给出用于文档的package的名称(它可以有空格)。TIEsynopsis规范具有格式synopsis<iname><string>其中<string>是指令的一个短(大约半行)的描述。在文本中没有格式控制。这个文本一般用于书中的标题以及指令列表中的附加材料。TIEdescription规范具有格式description<iname><string>其中<string>是一个包含描述指令的操作的文本的长(通常为几段)字符串，且为英语或其它自然语言表述。在这个文本中要有文本格式命令。本优选实施例使用类似HTML的语言(HTML的规范可以在如，http//www.w3.org/TR/REC-html40上找到)。此外，还有两个可选择的文档字符串可以支持assembly_note<iname><string>implementation_note<iname><string>这些可选规范可提供附加的每条命令的文本。象HTML，支持两种格式控制元素和字符结构。目的是规定数据的属性而不是精美的外在表现。数据将根据输出媒介的属性被进行适当的修饰。字符实体&<name>规定在ASCII中没有的字符或应该使用特殊修饰的字符。Element(元素)代表HTML定义的实体，如段落、列表、代码例子等。引用HTML4.0规范，“每个元素类型声明要描述三个部分开始标记、内容及结束标记。元素名出现在开始标记(写作<ELEMENT-NAME>)及结束标记(写作</ELEMENT-NAME>)中；在结束标记的元素名前标注斜线。”换句话说，<ELEMENT-NAME>DOCUNMENTATION</ELEMENT-NAME>规定了一种应用于DOCUMENTATION的格式。不象HTML，结束标记(</ELEMENT-NAME>)永远不是可选择的。有两种标记块标记及直接插入标记。块标记规定类似段落的结构，而直接插入标记用于确定段落内文本的格式。直接插入TADs(标记)可以是嵌套的。块标记可能不是嵌套的，除了UL内的LI。这些结构容易被转换为HTML，以创建作为附录C的程序的一部分的HTML文档，附录C为每条指令以及指令的索引配有一个HTML页。这个HTML文档能够被用于建立一个在线的处理器用户的参考手册。在本优选实施例中用Perl程序设计语言写出了一个用于做这个工作的程序，通过创建一个带有两列的HTML表格的index.html文件而工作，一个列用于助记符号，另一列用于摘要字符串。表的行的内容填写按分类次序处理指令。指令助记符号是连向为每个指令创建的页的HTML链接。每条指令页开始于一个给出助记符号和摘要的HTML一级标题(“H1”)。以后，通过HTML二级标题(“H2”)中的固定名称引入各个部分。第一部分，标为“InstructionWord”，给出了由每“位”一列的HTML表格表示的机器码格式。操作码“位”(’0’或’1’)被插入相应的表元中。操作数字段以字段名填写。跨越多个相临位的字段使用HTML表格的COLSPAN特性来避免重复。使用上面的表的行对机器码逻辑框的位进行编码，而字段的宽度在下面一行给出。第二部分，标为“AssembleSyntax”，给出用于定义指令的TIE包名。使用一个简单的散列将包名从一个识别符转换为文档串。包名自身在HTML段落块元素(“p”)内给出。第三部分，标为“AssemblerSyntax”，给出用于对指令编码的汇编语言格式。这由指令助记、空格以及由逗号隔开的操作数名组成。寄存器操作数名通过将寄存器文件的短名与字段名连接而形成。立即操作数名就是TIE中的立即数名。汇编程序语法在一使用HTML代码直接插入元素(“CODE”)的HTML段落块级元素(“p”)内给出。代码直接插入元素以一种与编程语言被修饰的方式类似的固定宽度字体来修饰文本。第四部分，标为“Description”，包含被从TIE转换为HTML的文本描述。因为TIE格式的代码与HTML格式的相似，因此这个转换非常简单。主要需要将INSTREF元素转换为连向指定的指令的HTML链接。可选择的第五部分，标为“Assemble”，包含从TIE转换为HTML的文本。第六部分，标为“Exceptions”，包含一列指令可能引起的异常。Load和Store指令自动地通过TIE编译程序将LoadStoreError异常增加到列表中。如果其它的相应的异常信号被列在指令的iclass的信号列表部分，则这些异常就被列出。异常是按优先权次序被列出的(拓扑排序的结果上面已经描述)。可选择的第七部分，标为“ImplementationNotes”，包含从TIE转换为HTML的文本。可以将检测实例列表从下面描述的TIE规范拷贝到文档中，因为有时这对读者是有用的。下面给出处理器指令文档的一个例子。 ＜html＞ ＜head＞ ＜title＞ GFADD8-GaloisField8-bitAdd ＜/title＞ ＜/head＞ ＜body＞ ＜h1＞ GFADD8&amp;#8212；GaloisField8-bitAdd ＜/h1＞ ＜h2＞ InstructionWord ＜/h2＞ ＜tableframe＝＂void＂rules＝＂groups＂cellspacing＝0cellpadding＝0＞ ＜colgroupcolspan＝8＞＜colwidth＝28＞＜colwidth＝28＞＜colwidth＝28＞＜colwidth＝28＞＜colwidth＝28＞＜colwidth＝28＞＜colwidth＝28＞＜colwidth＝28＞＜colgroupcolspan＝4＞＜colwidth＝28＞＜colwidth＝28＞＜colwidth＝28＞＜colwidth＝28＞＜colgroupcolspan＝4＞＜colwidth＝28＞＜colwidth＝28＞＜colwidth＝28＞＜colwidth＝28＞＜colgroupcolspan＝4＞＜colwidth＝28＞＜colwidth＝28＞＜colwidth＝28＞＜colwidth＝28＞＜colgroupcolspan＝4＞＜colwidth＝28＞＜colwidth＝28＞＜colwidth＝28＞＜colwidth＝28＞ ＜thead＞ ＜tr＞ ＜tdwidth＝28align＝＂center＂＞ ＜small＞23＜/small＞ ＜/td＞ ＜tdwidth＝28align＝＂center＂＞ ＜/td＞ ＜tdwidth＝28align＝＂center＂＞ ＜/td＞. ＜tdwidth＝28align＝＂center＂＞ ＜/td＞ ＜tdwidth＝28align＝＂center＂＞ ＜/td＞ ＜tdwidth＝28align＝＂center＂＞ ＜/td＞ ＜tdwidth＝28align＝＂center＂＞ ＜/td＞ ＜tdwidth＝28align＝＂center＂＞ ＜small＞16＜/small＞ ＜/td＞ ＜tdwidth＝28align＝＂center＂＞ ＜small＞15＜/small＞ ＜/td＞ ＜tdwidth＝28align＝＂center＂＞ ＜/td＞<dpn="d62"/>＜tdwidth＝28align＝＂center＂＞＜/td＞＜tdwidth＝28align＝＂center＂＞ ＜small＞12＜/small＞＜/td＞＜tdwidth＝28align＝＂center＂> ＜small＞11＜/small＞＜/td＞＜tdwidth＝28align＝＂center＂＞＜/td＞＜tdwidth＝28align＝＂center＂＞＜/td＞＜tdwidth＝28align＝＂center＂＞ ＜small＞8＜/small＞＜/td＞＜tdwidth＝28align＝＂center＂＞ ＜small＞7＜/small＞＜/td＞＜tdwidth＝28align＝＂center＂＞＜/td＞＜tdwidth＝28align＝＂center＂＞＜/td＞＜tdwidth＝28align＝＂center＂＞ ＜small＞4＜/small＞＜/td＞＜tdwidth＝28align＝＂center＂＞ ＜small＞3＜/small＞＜/td＞＜tdwidth＝28align＝＂center＂＞＜/td＞＜tdwidth＝28align＝＂center＂＞＜/td＞＜tdwidth＝28align＝＂center＂＞ ＜small＞0＜/small＞＜/td＞＜/tr＞＜/thead＞＜tbody＞＜tr＞＜tdwidth＝28align＝＂center＂bgcolor＝＂#FFF0F5＂＞ 0＜/td＞＜tdwidth＝28align＝＂center＂bgcolor＝＂#FFF0F5＂＞ 0＜/td＞＜tdwidth＝28align＝＂center＂bgcolor＝＂#FFF0F5＂＞ 0＜/td＞＜tdwidth＝28align＝＂center＂bgcolor＝＂#FFF0F5＂＞ 0＜/td＞＜tdwidth＝28align＝＂center＂bgcolor＝＂#FFF0F5＂＞ 0＜/td＞<dpn="d63"/>＜tdwidth＝28align＝＂center＂bgcolor＝＂#FFF0F5＂＞ 1＜/td＞＜tdwidth＝28align＝＂center＂bgcolor＝＂#FFF0F5＂＞ 1＜/td＞＜tdwidth＝28align＝＂center＂bgcolor＝＂#FFF0F5＂＞ 0＜/td＞＜tdcolspan＝4width＝112align＝＂center＂bgcolor＝＂#FFE4E1＂＞ r＜/td＞＜tdcolspan＝4width＝112align＝＂center＂bgcolor＝＂#FFE4E1＂＞ s＜/td＞＜tdcolspan＝4width＝112align＝＂center＂bgcolor＝＂#FFE4E1＂＞ t＜/td＞＜tdwidth＝28align＝＂center＂bgcolor＝＂#FFF0F5＂＞ 0＜/td＞＜tdwidth＝28align＝＂center＂bgcolor＝＂#FFF0F5＂＞ 0＜/td＞＜tdwidth＝28align＝＂center＂bgcolor＝＂#FFF0F5＂＞ 0＜/td＞＜tdwidth＝28align＝＂center＂bgcolor＝＂#FFF0F5＂＞ 0＜/td＞＜/tr＞＜/tbody＞＜tfoot＞＜tr＞＜tdcolspan＝8width＝224align＝＂center＂＞ ＜small＞8＜/small＞＜/td＞＜tdcolspan＝4width＝112align＝＂center＂＞ ＜small＞4＜/small＞＜/td＞＜tdcolspan＝4width＝112align＝＂center＂＞ ＜small＞4＜/small＞＜/td＞＜tdcolspan＝4width＝112align＝＂center＂＞ ＜small＞4＜/small＞＜/td＞＜tdcolspan＝4width＝i12align＝＂center＂＞ ＜small＞4＜/small＞＜/td＞＜/tr＞＜/tfoot＞＜/table＞＜h2＞Package<dpn="d64"/> ＜/h2＞ ＜P＞ ＜/P＞ ＜h2＞ AssemblerSyntax ＜/h2＞ ＜P＞ ＜code＞GFADD8gr，gs，gt＜/code＞ ＜/P＞ ＜h2＞ Description ＜/h2＞ ＜P＞＜CODE＞GFADD8＜/CODE＞performsa8-bitGaloisField additionofthe contentsofGFregisters＜CODE＞gs＜/CODE＞and＜CODE＞gt＜/CODE＞and writestheresulttoGFregister＜CODE＞gr＜/CODE＞.＜/P＞ ＜h2＞ Operation ＜/h2＞ ＜pre＞ gr＝gs^gt； ＜/pre＞ ＜h2＞ Exceptions ＜/h2＞ ＜P＞ None ＜/P＞ ＜/body＞ ＜/html＞尽管在本优选实施例中使用HTML用作文档格式语言，但是本领域的技术人员可以发现其它同等规范的语言，如Adobe公司的FrameMakerMIF格式也是可以用的。子字段在本发明的具体实施例中，一个使得对改变程序执行特性的处理器结构的配置选项的敏感性降低的进步就是，将一个字段定义为另一个字段的子字段的能力。这与现有的可配置处理器系统形成对比，现有的系统限制对指令字的规定部分的字段的定义，并且不允许将它们定义为其它字段的一部分。将字段定义为其它字段的子字段的能力允许软件部分地独立于可配置处理器的endianess。例如，在现有技术系统中，一个对应于t字段的前两位的新字段t10只能被定义为下面两中TIE语句之一fieldt10inet[54}/*forfieldmemoryorder*/或fieldt10inst[15；14]/*forbigendianmemoryorder*/在这种排列下，不可能独立于存储器次序定义t10。通过允许使用子字段，本发明允许t10定义如下fieldt10t[10]因为t被处理器核心定义为短endian的inst[74]，定义为长endian的inst[1714]，t10就独立于存储器次序。检测实例用户确定的TIE有两个方面要验证。第一方面是确保核心与TIE块及用户定义的状态及寄存器文件之间的接口的正确性。第二方面是验证将用户语义转换为硬件的正确性，换而言之，就是TIE编译程序的正确性。第一方面不依赖于TIE指令语义，并且能够从TIE规范的特性中得到。不可能写出任何针对用户确定的TIE的直接的预定的测试或诊断程序。这个问题通过在TIE的硬件和软件生成的同时，从用户TIE规范得出测试程序而得以初步解决。TIE编译程序生成对于用户指令的ISA描述。TIE的诊断程序生成器读TIE指令的ISA描述。这也包括有关用户规定的状态和寄存器文件的知识。这个信息被生成器利用，以创建一些针对用户TIE的有意义的诊断程序。参考语义提供对实现语义验证的方法。通过在目标应用使用参考语义可以验证它们。如在Killian等人和Wilson等人的申请中所述，应用被设计者通过经内部语句使用新的指令而更改。更改的应用和指令定义在仿真程序或本机上被测试。本机执行由TIE编译程序的能力实现(象在现有技术中)，以创建作为函数的内部语句的会话式编程语言(如C)的定义。在目标应用中的使用通常是对指令定义的最好的测试。TIE编译程序产生C代码的正确性是通过这个过程检查的，但是从TIE代码向HDL的转换不是，除非应用也运行于HDL仿真程序中。然而，HDL仿真程序对很多应用来讲都太慢。因此，需要有一些其它的方式用于测试将输入语义转换为HDL的正确性。可能设计者不确信应用是否覆盖了指令必须处理的所有情况。如果在处理器生成之后应用发生变化；或者新的应用将使用这个处理器，则这一点就是重要的。在这种情况下，最好有其它方式测试指令。在现有技术系统中，处理器的指令通常通过这种方式进行测试的，即将一系列选择的源操作数值运于行手工编写的执行指令的诊断程序中，并检查具有预期值的结果操作数。本优选实施例通过利用从TIE规范中得到的附加信息而使这一过程自动化。无论是寄存器文件操作数、立即数还是处理器状态寄存器，TIEiclass规范都列出了每条指令的输入和输出。TIE结构 test＜iname＞{ in{＜oname＞＝＞＜value＞，...} out{＜oname＞＝＞＜value＞，...} in{＜oname＞＝＞＜value＞，...} out{＜oname＞＝＞＜value＞，...} ... }提供了一个有关指令<iname>的源操作数值和预期的结果列表。这里，<oname>是操作数或状态寄存器的名称，<value>是相应的输入值(对于in或inout操作数或在测试in列表中的寄存器)或者预期值(对于in或inout操作数、寄存器或在测试out列表中的异常信号)。TIE编译程序产生一个会话编程语言(如C)的测试程序，即对应测试中的in列表中的值的in和inout处理器寄存器使用WUR内部指令，而数值用Wilson等人的申请中描述的TIEuser_register结构声明。然后它使用由用于装入寄存器的proto声明规定的内部指令建立in和inout寄存器文件操作数。在核心寄存器文件(如本优选实施例中的AR的)中的操作数使用内置语言类型。然后，TIE编译程序调用具有按iclass规定的次序排列的操作数的内部语句。然后，读在测试中的out列表中规定的out和inout操作数，并且与给定的预期值比较。最后，使用RUR内部指令及user_register结构的寄存器数，读在测试中的out列表中的处理器寄存器，并且将这些值被与给定的值进行比较。这个自动生成的程序设计语言诊断程序可以运行在指令集仿真程序上，或在硬件RTL模型上，或本机使用由TIE编译程序通过转换为目标程序设计语言产生的内部仿真函数。作为一个例子，规范 testGFADD8{ in{gs＝＞8′xFF，gt＝＞8′xA5} out{gr＝＞8′x5A} } testGFMULX8{ in{gs＝＞8′xFF，gfmod＝＞8′xA5} out{gr＝＞8′x5B} }产生C诊断程序unsignedcharGFADD8_0[1]＝{255}； unsignedcharGFADD8_1[1]＝{165}； unsignedcharGFADD8_2[1]＝{90}； unsignedcharGFMULX8_0[1]＝{255}； unsignedcharGFMULX8_1{1]＝{91}； unsignedcharGFMULX8_2[1]＝{165}； int main(intargc，char*argv[1] { for(i＝0；i＜1；i+＝1){ gfgr； gfgs； gfgt； unsignedchart0； LGF8_I(gs，&amp;GFADD8_0[i]，0)； LGF8_I(gt，&amp;GFADD8_1[i]，0)； GFADD8(gr，gs，gt)； SGF8_I(gr，&amp;t0，0)； if(t0！＝GFADD8_2[i]) fail()； } for(i＝0；i＜1；i+＝1){ gfgr； gfgs； unsignedchart0； LGF8_I(gs，&amp;GFMULX8_0[i]，0}； WUR(GFMULX8_1[i]，0)； GFMULX8(gr，gs)； SGF8_I(gr，&amp;t0，0)； if(t0！＝GFMULX8_2[i]) fail()； } return0；}产生检测实例的测试向量的自动例子在运行的应用对于测试输入指令语义正确性已经充分的情况下，还需要有在HDL仿真程序中运行的用于测试输入语义的TIE转换的实例。HDL仿真程序在很多情况下对于运行应用太慢。因此需要有一种用于从本机运行的应用中，或在指令集仿真程序中精选的方法。因此TIE编译程序应该具有随着输入语义对应用编程语言的转换情况而改变的选项，这可以通过将指令的输入和输出操作数写入文件而实现。通过消除复制和利用统计样本精选一些在HDL仿真程序中进行合理仿真的检测实例，能够对这个文件进行后处理。以后可以将这些记录转换为上述的TIE测试结构，以便将其实现作用于过程的其余部分。下面使用这个生成结构的微结构的测试的方法论的目的，就是提供一系统的对用户TIE的实现的验证过程。这是非常重要的，因为用户的应用对TIE执行的微结构的测试可能不充分。为了从TIE描述中生成这些诊断程序，我们使用一种从ISA描述和TIE编译程序产生的流水线信息中导出需要的信息的方法。这个方案描述如下。TIE指令的ISA描述为了能够根据用户的要求配置处理器核心，使用了一个配置。一个配置基本上是一个能够使用户通过一个Web形式的接口进行定制的处理器核心的元件和属性的列表。这些处理器属性被引用为配置参数。全部的配置参数列表以及它们的缺省值和这些值的取值范围，定义了处理器核心的配置空间。处理器核心的具体示例，也就是说，一个所有的配置参数都被分配了具体的值的示例，就是一个核心配置。目前，配置空间和具体的核心配置都表示为列出配置参数及其值的文本文件。即使所有文本文件中列举的所有配置参数及其值的单调的列表也具有便于阅读的优点，它使得配置单个硬件和软件段的过程变得复杂。由于这个原因，开发了一套用于阅读配置信息和创建处理器的各个元件和配置参数值的一个面向对象的表达的工具。这个工具和配置的表达，被大家共同称为配置环境和配置数据库。在软件和硬件的配置期间，tpp提供使开发者能够程序化地访问配置信息，并方便地计算源代码的一元件的配置环境的句柄。此外，因为计算是在配置环境中进行的，因此它共享所有的配置资源，这样开发可配置的源代码就被简化了。已经开发了用于描述ISA的PERL语言库。对于TIE，TIE编译程序的运行用于为用户定义的指令创建PERL对象，并将这些增加到核心ISA。从这里开始，所有的验证工具都通过调用这些PERL对象来获得ISA以及用户定义的TIE的流水线信息。下面的例子说明这是如何做的。从一个简单的TIE描述开始，opcodeaccop2＝0CUST0stateaccum32user_register100accumiclassacc{acc}{inars，inart}{inoutaccum}referenceacc{ assignaccum＝accum+ars+art；}TIE编译程序产生如下关于TIE用户状态的信息以及使用它的指令的语义。 Stateaccummappedtouserregister100，bits310 opcodeacc，packageUserDefined，size20， RegisterOperands Nameasinput， regfileAR，shortnamea，size32bits，entries64 Nameatinput， regfileAR，shortnamea，size32bits，entries64从上述信息中可以产生TIE指令acc的汇编代码。众所周知，该指令有两个寄存器操作数，都是AR类型，在此基础上可以进行一些随机的寄存器分配，或者更好地，既然输出和输入字节已知，可以进行一些智能的寄存器分配。因此可以自动地生成这个指令的汇编代码，如acc$a7，$a13其中，a7和a13是由一有关AR的regfiIe的定义的寄存器分配算法产生的acc指令的s和t字段。更多的TIE指令的ISA描述的例子opcodei128l，packageUserDefined，size24，loadRegisterOperands Namei128toutput， regfilei128，shortnamei128，size128bits，entries16 Nameasinput， regfileAR，shortnamea，size32bits，entries64ImmediateOperands Nameoffset128bits8，Tableopcodewur0，packageUserDefined，size24，RegisterOperands Nameatinput， regfileAR，shortnamea，size32bits，entries64opcodei128s，packageUserDefined，size24，storeRegisterOperands Namei128tinput regfilei128，shortnamei128，size128bits，entries16 Nameasinput regfileAR，shortnamea，size32bits，entries64ImmediateOperands Nameoffset128bits8，shift0，Table既然不可能得到有关指令的预期结果的足够信息，也就不可能检查TIE指令的正确性。例如，如果acc指令的结果在测试中是正确的，则就不可能检查。然而，如果硬件在状态累加器中产生了错误结果，这可以通过比较所有位于所有指令的边界的RTL和ISS之间的用户状态和寄存器文件的共同仿真结构而检查出(后面将详述)。下面的部分使用一些类似PERL的伪代码来解释算法。诊断程序生成器大部分是PERL程序。用于产生正确的TIE指令的诊断生成器使用的算法如下 subroutinegen_tieinstr {tie_opcode，address_reg，index_reg} { //address_regisacoreregister //containingavalidaddressincase //theTIEinstructiondoesaload/store， //samefortheindexregister，ifthe //load/storeisaindexedload<dpn="d71"/>foreachoperand(tie_inst-＞regoperands()){ fld＝operand-＞field()； reg＝&amp;register_allocate(tie_inst，operand)； if((isLoad(tie_inst)||isStore(tie_inst)) &amp;&amp;operand-＞name()eq′as′){ overridewithvalidaddress reg＝address_reg； } if((isLoad(tie_inst)||isStore(tie_inst)) &amp;&amp;operand-＞name()eq′at′){ reg＝index_reg； } push(operand_list，reg)；}foreachoperand(tie_inst-＞immoperands()){ //specificationofimmediateoperand //asatableofvaluesorarange range＝operand-＞range()； table＝operand-＞table()； legal＝tie_inst-＞legals(operand-＞field()-＞name)； if(legal){ imm＝legal[randomindex]； }elsif(range){ imm＝randomvaluebetweenrange.loandrange.hi； }elsif(table){ imm＝table[randomindex]； } push{operand_list，imm)；}}subroutineregister_alloecate(tie_inst，register_operand){name＝register_operand-＞shortname()；numentries＝register_operand-＞entries()；legalrange＝ tie_inst-＞legals(register_operand-＞field()-＞name())；if(legalrange){ register_num＝legalrange[randomindex]；}else{ register_num＝random(0，numentries-1)；}returnconcatenate(name，register_num)；}此外，在可以开始执行TIE指令之前，需要初始化TIE状态几寄存器文件。这是通过下面的方式完成的subroutineinitTieState(address_reg，data_reg){ //Iterateoverallstateandgetthevaue //foreachuserregisterthat //thestatesaremappedto states＝(tie-＞states()， map($_-＞states()，tie-＞coprocessors()))； foreachstate(states){ UserRegMask{state-＞userReg}＝getMask； } foreachureg(keysofthehashtableUserRegMask) maskthedataregisterwiththemaskvalue doaWURtotheureg } //Initializeregisterfilesbyloadingfroma //validmemorylocation regfiles＝(tie-＞regfiles()， map($_-＞regfiles()，tie-＞coprocessors())＞ foreachregf(regfiles){ for(i＝0；i＜regf-＞entries()；i++){ generatetheloadinstructionorinstructionsequence usingtheaddr_regthathasthevalidaddresstoload indexiofregisterfileregf. } }TIE的流水线信息为了生成测试TIE中的测试旁路和互锁逻辑的微结构诊断程序，需要TIE指令的流水线信息。这提供了一个有关阶段的知识，在这个阶段TIE指令读和写寄存器和状态等这些资源。再一次，TIE编译程序提供这个信息，并且这个信息表达为PERL对象，且被验证工具所利用。下面的例子包含一用户定义的寄存器文件以及简单地在流水线的不同阶段移动数据的指令集，注意约定1代表E阶段，2代表M阶段，3代表W阶段 regfilei12812816i128 operandi128ss{i128[s]} operandi128tt{i128[t]} operandi128rr{i128[r]} opcodeI128Lr＝0LSCI opcodeI128Sr＝1LSCI opcodeI128ANDop2＝0CUST0 scheduleload{I128L}{ defi128t2； }这转换为下面的PERL数据库中内容Regfilei128width128entries16instructions Writes stage2Insti128andFieldr stage3Insti128lFieldt Reads stage1Insti128sFieldt Insti128andFields Insti128andFieldt在下面的部分可以看出这个信息是如何用于生成诊断程序的。TIE的微结构测试本部分的目的是在TIE与核心的接口的实现知识以及TIE状态和寄存器文件基础上，生成TIE逻辑的微结构诊断程序。使用了ISA及TIE自身的流水线描述，然而，如上所述，TIE指令的实现的“正确性”不是在测试中直接验证的。生成了一套MVP诊断程序用以测试下面的实现的各个特征。—在核心和TIE接口中的控制逻辑；—用户状态和寄存器文件的实现，包括装入/存储以及旁路和互锁逻辑。在核心和TIE之间的控制信号测试异常，中断和中继信号的测试程序是这样生成的，即通过核心(如一分支)、异常和中继信号中的控制流的变化来删除每个用户指令。指令应该在其执行的所有阶段被删除，一直到完成阶段。产生这些测试程序的算法就是将所有的TIE操作码在TIE编译程序产生的ISA描述中进行迭代，并构成了如下的实例情况a)被流的改变所删除的TIE指令foreachtie_opcode(tie_opcode_list)branchinstr(branchtaken)tie_opcodeend//foreach情况b)被一个异常所删除的TIE指令 foreachtie_opcode(tie_opcode_list) for(stage＝0； stage＜completionstageoftie_opcode； stage++) syscallorbreakinstr(thatgeneratesanexception) ＜stage＞numberofnops tie_opcode end//for end//foreach可以看出，产生异常的指令间无操作的数量以及TIE指令控制TIE控制执行的删除阶段。情况c)在流水线中中继的TIE指令foreachtie_opcode(tie_opcode_list)isyncinstrtieopcodeend用户状态和寄存器文件的旁路逻辑这些测试程序将通过对读/写TIE状态和寄存器文件的指令进行“配对”检查其旁路逻辑。测试将保证没有因为取指令和数据导致的停止，然后(如果配置许)检查指令序列前后的周期计算寄存器，以寻找任何被视为错误的不必要的停止和标志。该算法如下生成对特定的寄存器文件或状态的所有读/写阶段一个[指令，字段]的列表。检查对于这个状态/寄存器文件的最大的完成阶段。对写和读指令进行配对，改变无操作的阶段的数值，直到最大的完成阶段。 foreachregf(tie-＞regfiles()){ //listofthestagesatwhichregfisread //possibly(1，2) readstages＝getReadStages(regf)；， //listofstagesatwhichregfiswritten //possibly(2，3) writestages＝getDefStages(regf)； foreachwstage(writestages){ writelist＝Generatelistof[instr，field]pairs thatwriteregfinstagewstage max_nops＝ maximum_completion_stageforregf-wstage； foreachrstage(readstages){ readlist＝Generatelistof[instr，field] pairsthatreadregfinstagerstage } foreachwrite_instr(writelist){ foreachread_instr(readlist){ for(i＝0；i＜max_nops；i++){ stalls＝ (wstage-rstage-1)if(wstage＞rstage)else0； ccount_before＝readcyclecount write_instr I-nops read_instr ccount_after＝readcyclecount if((ccount_after-ccount_before) ！＝(stalls+nops+3)) ERROR！！ } } } }需要通过执行这些指令序列两次，以保证没有I$和D$漏失。在第二次重复中，要检查周期计数。周期的预期值依赖于读/写的阶段和无操作阶段。上述例子的一些实例如下 #(i128lfieldtstage3)-＞(i128andFieldsStage1)， #nops＝0，stall1cycles Test_11<dpn="d76"/> rsr$a3，234＜--readcyclecountbefore i128l$i1280，$a10，0 |-＞ | i128and$i1285，$i1280，$i12811 rsr$a4，234＜---cyclecountafter addi$a3，$a3，4 beqa4，a3，PASS_11 jFAIL PASS_11 #(i128andfieldrstage2)-＞(i128andFieldsStage1)， #nops＝0，stall0cycles， Test_12 rsr$a3，234 i128and$i1280，$i1288，$i1284 |-＞ | i128and$i1286，$i1280，$i1285 rsr$a4，234 addi$a3，$a3，3 bega4，a3，PASS_12 jFAIL PASS_12 #(i128andfieldrstage2)-＞(i128andFieldsStage1)， #nops＝1，stall0cycles， Test_13 rsr$a3，234 i128and$i1280，$i1288，$i1284 nop.n i128and$i1286，$i1280，$i1285 rsr$a4，234 addi$a3，$a3，4 bega4，a3，PASS_13 jFAIL PASS_13互锁和冒险这个测试用于“写后读”、“写后写”和(可能有)“读后写”的冒险情况中的停止的正确性。得出对于冒险情况的算法类似于得出上述旁路情况的算法。有两条在阶段2和3写同一文件的指令，且跟随着一条在阶段1读该文件的指令。第三条指令因第二个写的结果而停止。 #(Insti128andr2)-＞ #(Insti128lt3)-＞ #(Insti128ands1) Test_1 rsr$a3，234 i128and$i1280，$i1289，$i1281 i128l$i1280，$a5，0 i128and$i12815，$i1280，$i12813 rsr$a4，234 addi$a3，$a3，5 beqa4，a3，PASS_1 jFAIL PASS_1装入/存储对所有寄存器文件的装入和存储是使用下面的算法对所有对准和未对准的地址进行全面地测试的。 foreachregf(tie-＞regfiles()){ PIFbytes＝PIFWidth＞＞3；//bytes PIFwords＝PIFbytes＞＞2；//words(eg4for128bit) regfw＝regf-＞size()＞＞5； for(k＝0；k＜PIFbytes；k++){ load_address＝PIFWidth-alignedaddress+k； store_address＝PIFWidth-alignedaddress+k； *initializememory *storeknowndataintoloadaddress *storeadefaultvaluetothestoreaddress for(i＝0；i＜PIFwords；i++){ *storedatawordtoloadaddress+i *storedefaultwordtostoreaddress+i } *dotheloadfromloadaddress *dothestoretostoreaddress expected_result＝ expected_tie_load_result(load_address，data)； for(i＝0；i＜PIFw；i++){ result＝loadawordfromstoreaddress+i if(i＜regfw){ checkresult＝＝expected_result }else{ checkresult＝＝default_word } } } }装入的预期的结果依赖于装入算法，尽管在大多数下它是可以确定的，但是不可能对所有可能的语义做到，在这些情况下需要将检查留给状态与存储器的比较。对于配置支持数据断点的情况，也要对TIE装入/存储指令得数据断点进行测试。有关数据断点是如何对TIE指令起作用的细节见装入/存储结构部分。生成的诊断，对数据中断地址寄存器、控制掩码寄存起以及装入/存储的虚拟地址的所有可能的组合测试数据断点。 foreachregf(tie-＞regfiles()){ regfw＝regf-＞size()＞＞5； writedbreakregisterwithanaddressalignedtoregfw foreachmask(setofmasksforregfw){ *writedbreakcontrolmask *setaddressregisterbased onmaskanddbreakaddress *doaload/storetoregfthat takesadatabreakpointexception *checkifexceptionwastaken end end匹配的数据断点将引起调试异常。上述测试的调试异常处理器将更新一个计数器，该计数器将被检查以验证异常真的发生了。此外，构建了更为复杂的情况，其中带有数据断点的读/写与溢出/下溢异常相符合(对于寄存器开窗口)以确保这些异常的优先权正确。TIE指令的随机诊断生成器随机诊断在核心ISA及执行的微结构的验证中起着主要作用。指令的随机序列可能碰到边界情况及其它不可能被直接测试覆盖的情况。为了设计验证，还将随机测试添加到了覆盖标准中。通过增加一些属性，已经向这些随机测试生成器增加了额外的智能。例如，可以为特定的目标情况创建指令序列模板。这样的一个例子可以是填满写缓存器的背对背存储，或具有单一指令的零开销环路。属于每个指令类型或指令序列的相对概率判断人们想要生成特定种类指令的频率，例如，如果一个分支指令具有高的相对概率(或权重)，生成的测试将具有更多的分支。用户控制的参数能够调整生成的测试的特性。例如，命令行自变量能够控制某个指令的相对权重，测试的长度，嵌套函数调用的次数等等。随机诊断生成器也能够生成用户定义的TIE指令。下面的结构与微结构测试的结构类似。随机生成器读包括TIE指令及核心ISA的ISA描述。有效TIE指令通过检查特定TIE指令的ISA描述并使用一些寄存器分配结构而构成。foreachoperand(tie_instr-＞operands()){if(operandisTIEregisterfile){ doarandomregisterallocation random(0，#entriesinregisterfile) }elsif(operandisacoreregisterfile){ if(thisisaload/storeinstr){ thisistheaddressregister fortheload/storeoperation. Findacoreregisterthatcanbewritten， andwriteavalidaddress }else{ randomcoreregister } }elsifimmediatefield{ generatearandomimmediatevaluebasedonthe instruction′simmediatetableorrange }}随机生成器优选情况下是不能够被配置系统的最终用户访问的，但是可用于内部验证以及用于象上述的TIE描述的整个范围，更包括各种宽度(如8、16、32、64、128位)和状态的穷举情况。此外，最终用户还可访问随机生成器以便在进一步的验证中使用。TIE验证的覆盖度量如上所述，验证的一个目的是确保核心和TIE的接口、用户定义的状态和寄存器文件及相关的逻辑的实现的正确性，以及TIE指令向硬件的正确转换。这些区域的一些覆盖标准是必需的。这不意味着引用TIE编译程序生成的RTL的基本设计覆盖，而是引用在上面提到的区域内的功能覆盖。尽管对TIE进行这些覆盖评估是非常困难，但是已经开发了一些方式，用于生成一些与RTL一起运行的功能覆盖模块并报告一些覆盖的度量。例如，一个重要的区域，是位TIE寄存器文件和状态之间的所有的旁路路径。生成的用于测试旁路的诊断程序应该覆盖所有可能的旁路路径，但是目的是获得一个RTL中的旁路路径的独立验证。为了实现这个，从TIE描述和流水线信息自动生成了一些Verilog/VERA模块。这些模块在RTL仿真程序时间运行，以报告哪个旁路路径被覆盖了。举一个前面的部分已经见过的128位寄存器文件i128的例子，图13表示这样一个通用目的寄存器文件，及其在硬件中的实现。该图表示一个读端口Rd0和一个写端口Wd。典型地，有两个寄存器文件的读端口和一个写端口。信号的命名约定是<port_name>_<signal_name>_<stage_name>其中port_name寄存器端口(Rd0、Rd1、Wd)的名称signal_name信号名，是read_portmux多路复用器的输出，data通往TIE的数据通路单元的触发器的输出write_portmux一个多路复用器的输出data数据通路单元的输出result触发器的输出stage_name这表示流水线的阶段。如前面的部分所述，这里约定C0R阶段，C1E阶段，C2M阶段，C3W阶段为了简化的原因，下面的讨论限制所有的指令要在M阶段结束前写寄存器文件。框图表示这些阶段的不同的旁路路径。对于被数据通路在阶段1和2读的读端口Rd0(这在前面的部分表现为寄存器文件的使用)，下面跟踪或解释框图阶段C0Rdo_mux_C0＝selectfrom(Wd_data_C2由instr在流水线中最后产生的结果Wd_data_C1由instr在流水线最后之前产生的结果Rd0_data_C0在流水线中的当前数据)阶段C1Rd0_data_Cl<＝Rd0_mux_C0其中<＝表示在一个时钟周期之后Rdo_mux_C1＝selectfrom(Wd_data_C2阶段C2由inster在流水线的最后产生的结果Rd0_data_C1前一阶段的结果)阶段C2Rd0_data_C2<＝Rd0_mux_Cl在阶段2和3被写的写端口Wd具有类似的旁路路径阶段C2Wd_result_C2<＝Wd_mux_C1＝Wd_data_C1(在E阶段的指令的输出是C1阶段的写端口的唯一源)Wd_mux_C2＝selectfrom(Wd_result_c2Wd_data_C2M阶段的当前instr的结果)阶段C3Wd_result_C3<＝Wd_mux_C2Wd_result_C3被写入寄存器文件。旁路路径的覆盖本优选实施例的一个目的是，如果所有的上面框图中的旁路路径已经被检查了，生成一个检查用的监控器。在图13中用虚线描绘了一个旁路路径的例子。监控器通过路径跟踪数据，因此需要进行一个重要的假设，即在TIE的数据通路单元中的数据保持不变。这意味着能够执行下面的检查Wd_data_C1＝＝Rd0_data_C1按照该假设，一个在E阶段(C1)读数据，而在E阶段输出数据的TIE指令保持数据不变。这对任何实际的TIE指令当然是不真实的。但是，为了测试，引入了一些用户TIE中的“恒等”指令(在生成真实的硬件时将消除)。这些指令，只用于测试，基本上是拷贝数据。在这个例子中，得到了两个恒等指令。恒等1useC1，defC1读E阶段的寄存器文件，并在E阶段产生同样的数据；恒等2useC1，defC2在一个周期延迟后产生数据。已经描述了监控器生成的前提，现在描述生成在所有的旁路路径都被测试后进行测试的Vera模块的算法。再次，使用了由TIE编译程序产生的信息，并且上述信号名约定如下 foreachregf(寄存器文件列表){ foreachwriteport(regf的写端口){ foreachwritestage( 阶段写端口列表被写){ foreachreadport(regf的读端口){ foreachreadstage( 阶段读端口列表被读){ skdpifwritestage＜readstage generate_the_signal_list(regf-＞name，<dpn="d83"/> writeport-＞name，writestage， readport-＞name，readstage， list_of_write_stages_for_writeport }//读阶段 }//读端口 }//写阶段 }//写端口 }//regf为了简化，生成信号列表的子程序的工作被省略了，但是对本领域的技术人员是显而易见的。重要的一点是要注意，在信号的列表中数据通路是如何表达的。如果数据通路的写阶段大于读阶段(如上面的Identity2指令)，则就将消耗于数据通路单元的周期数(与本公开中我们对于TIE指令的两周期的限制相一致，该周期数为1)简单相加。以虚线表示于图13中的路径是作为信号列表或来自上述算法的的跟踪生成的，如下 i128_wd_data_C2-＞ i128_rd0_mux_C0-＞ i128_rd0_data_C1-＞ waitcyclesl-＞ i128_wd_data_C2-＞ i128_wd_mux_C2-＞ i128_wd_result_C3其中i128是寄存器文件名。从Xtensa的高级到寄存器文件i128的路径预计为这样。注意，图13中的数据通路Rd0_data_C1->Wd_data_C2中的虚线，已经在信号跟踪中表示为等待周期1。为所有的旁路路径生成了一系列这种信号跟踪。在信号跟踪的基础之上，在Verilog/Vera中生成了一个小的监控模块，如果这条路径已经被跟踪了，则用该模块进行检查。如果这样，则在仿真的末尾为该路径报告1。每个监视器基本上是由下面的算法生成的一个小的状态机a)确定状态机中的状态数状态数＝信号跟踪中的阶段号(从E)+在状态m/c的数据通路中的周期数。b)根据状态对信号分组c)生成代码srtate＝0foreachstate(FSM中的状态){if(list中的最后状态){*从新设状态*设标志为1用于转换}else{if(在这个状态的信号){如果表示进行到下一状态则生成}else{进行到下一阶段}}}为举示例的旁路路径生成的这个状态机为case(state) {<dpn="d85"/> 0 { if(＜hierarchy＞.i128_rd0_mux_C0＝＝ ＜hierarchy＞.i128_wd_data_C2){ state＝1； } } 1 { if(＜hierarchy＞.i128_rd0_data_C1 ＜hierarchy＞.i128_rd0_mux_C0){ state＝2； } } 2 { int_state＝3；//waitcycles1 } 3 { if(＜hierarchy＞.i128_wd_result_C3 ＜hierarchy＞.i128_wd_mux_C2){ state＝0； result_flag＝1′b1； } } }验证摘要要测试输入的指令语义的正确性，TIE编码器更改了应用，以使用新的使用内部语句的指令，然后或者(1)将其编译为机器代码并使用指令集仿真程序运行应用；或者(2)将其编译为本机代码并通过TIE编译程序使用宏和函数输出，以提供内部的兼容性。应用的正确性通过这两种选择之一验证指令参考语义的正确性。参考语义的转换是通过选择2验证的，而扩展编译程序及仿真程序的正确性是通过选择1验证的。超出应用所提供的，额外的覆盖是通过使用TIE构造的检测实例来生成特殊情况的测试程序的(如不常见的或“边角”的情况)。实现语义的验证，可以通过使用TIE编译程序选择，使用上述同样的方法将其转换为参考语义而实现。实现语义和它们向HDL的转换也可以通过类似于对参考语义的商业上等价的将每条转换为HDL的检查工具进行正式的验证。实现语义及其转换也是通过使用在HDL仿真程序中运行的TIE规定的检测实例进行检查的。由TIE编译程序生成的对寄存器文件、互锁、旁路、核心接口和异常的HDL，是通过在TIE输入的基础上运行自动生成的测试，并使用共同仿真验证结果进行验证的。这些测试使用流水线规范以彻底地测试互锁、旁路和异常的各种组合。由TIE编译程序产生的HAL代码通过在指令集仿真程序中的执行而得到验证。按上述大多数的方式对支持新指令的汇编程序和编译程序进行验证。处理器的共同仿真共同仿真是以并行方式运行RTL和参考模型，并在特定边界处比较的ISA中定义的结构可视状态的过程。共同仿真程序充当RTL仿真程序、ISS及多个其它并行执行的监控器/任务之间的同步装置和信关。一旦在RTL和ISS之间发生不匹配或当验证检查器发出灾难事件信号时，则诊断失败。使用共同仿真有几点好处。第一，它提供失败诊断的更为容易的调试。它使得仿真在问题出现的周期或其附近停止，这有利地降低了调试的时间和付出。第二，它提供更多的状态检查。它允许处理器状态的在程序全过程的可观察性，因此可以在产生了错误的中间结果却可得出正确得最后结果的情况下发出信号。最后，通过共同仿真，不需要自检查。可以运行随机诊断的检查。在本优选实施例中，ISS是参考模型，且边界定义在指令结束和外部事件发生时。要比较的结构可视状态集合是可配置的。对可配置的处理器使用共同仿真的困难之一是缺少对有关比较RTL和ISS的过程的全面的知识。所知道的有关RTL和ISS的比较的知识就是比较要在指令结束的边界和外部事件出现时发生。然而，应该根据用户在其配置中选择的处理器选项在RTL和ISS之间比较处理器状态。当处理器选项不包括在处理器核心的特定配置中时，则共同仿真环境甚至不应该尝试比较该选项引入的状态，因为该状态不会在RTL或ISS中出现。因此，本优选实施例使用可配置的共同仿真，并且与处理器配置期间的软件和硬件一起对其进行定制。共同仿真是如何与TIE一起工作的用户扩展处理器状态的能力以及使用TIE的指令集，使共同仿真的过程变得复杂；因为共同仿真环境要在没有完全的有关现有处理器状态和指令集知识的条件下进行开发。在TIE前面，共同仿真环境需要能够决定应该比较的新的处理器状态，并决定在哪个边界在RTL和ISS之间比较新状态。为了使共同仿真能够实现这两个要求/目标，需要有关TIE中定义的新处理器状态的信息。这些共同仿真需要的信息包括新状态名、状态元素的宽度、定义状态的完全的RTL路径(该状态或是重新设置的定义或不是，它或是单个的状态或是寄存器文件)以及当状态是寄存器文件时的入口的数量。共同仿真需要的信息是从用户的TIE描述中按三步生成的。第一步，入图14所示，TIE编译程序解析TIE描述并生成在输入文件中定义的状态的中间表达。这个中间表达随后被共同仿真预处理器使用以生成新的TIE状态验证必需的共同仿真源代码。最后，生成的共同仿真代码与共同仿真框架的其它部分相集成以产生特定于给定配置的共同仿真环境。优选情况下使用tpp实现这个，以生成如在《VeraSystemVerifierbySynopsys，Inc.ofMountainView，CA》实现的Vera共同仿真语言的代码。下面的部分包含共同仿真预处理器的例子，以及生成的共同仿真源代码。这些源代码与前面出现的伽罗瓦字段TIE的例子有关。CosimInfo.pm #--------------------------------------------------------# #CosimInfo.pmcreatesarrayswhichcontainsstateand# #registerfilesinformationforTIEandthecore.# #--------------------------------------------------------# @CosimInfoEXPORT＝qw(<dpn="d88"/> @RegisterFiles @SpecialRegister @IntrType @TieState @TieRegister @AllRegFiles @AllSpecialRegs)；#--------------------------------------------------------##Foragivenconfiguration##SpecialRegistercontainsallthecore##specialregisters′names##RegisterFilescontainsallthecore##registerfilesnames##--------------------------------------------------------#@SpecialRegister＝map(CoreState($_，1)， grep($_-＞namene′MEM′，$isa-＞state))；@RegisterFiles＝map(CoreState($，0)， grep($_-＞namene′MEM′，$isa-＞state))；#--------------------------------------------------------##Foragiventiedescription##TieStatecontainsalltheTIEstatesnames##TieRegistercontainsalltheTIEregisterfilesnames##--------------------------------------------------------#@TieState＝map(TieState($_，1)， $pr-＞tie()-＞allStates())；@TieRegister＝map(TieState($_，0)， $pr-＞tie()-＞allStates())；@AllRegFiles＝(@RegisterFiles，@TieRegister)；@AllSpecialRegs＝(@SpecialRegister，@TieState)；#--------------------------------------------------------##TieStatesubroutinereadstheTIEstateandregister##informationfromtheconfigurationdatabase.##--------------------------------------------------------#subTieState{ my($state，$tieState)＝@_； my$name＝$state-＞name()； my$entries＝$state-＞entries()； my$width＝$state-＞width()； my$undefonreset＝！($state-＞initialized())； my$regfile＝$state-＞isRegFile()； if($tieState){ returnif($regfile)； [$name，$width＝＝1？1$width，$undefonreset]； }else{ returnif(！$regfile)； [$name，$width＝＝1？1$width，$entries]； }}共同仿真源代码(TIE寄存器文件比较) ；foreach(@TieRegister){ ；my($regName，$regWidth，$regEntries)＝@$_； ；for($i＝0；$i＜$regEntries；$i++){ ；$tn＝$regName.$i； iss_`$tn`＝$iss_read_register_bitvec(`$i`+`$regName`_start)； if(rtl_`$tn`[index]！＝iss_`$tn`){ printf(＂Cosim@cycle％0dPC％h\n\tRTL！＝ISSTIERegFile`$tn`％h％h\n\n＂，currentcycle，rtlspregpc[index]，rtl_`$tn`[index]，iss_`$tn`)； } ；}；}共同仿真源代码(TIE寄存器文件比较) iss_gf0＝$iss_read_register_bitvec(0+gf_start)； if(rtl_gf0[index]！＝iss_gf0){ printf(＂Cosim@cycle％0dPC％h\n\tRTL！＝ISSTIERegFilegf0％h％h\n\n＂，current_cycle，rtl_spreg_pc[index]，rtl_gf0[index]，iss_gf0)； ... iss_gf15＝$iss_read_register_bitvec(0+gf_start)； if(rtl_gf15[index]！＝iss_gf15){ printf(＂Cosim@cycle％0dPC％h\n\tRTL！＝ISSTIERegFilegf15％h％h\n\n＂，current_cycle，rtl_spreg_pc[index]，rtl_gf0[index]，iss_gf15)；共同仿真源代码(TIE状态比较) ；foreach(@TieState){ ；($sreg)＝@$_； //CheckingSpecialRegister`$sreg` iss_`$sreg`＝$iss_read_register_bitvec(`$sreg`_map)； if(rtl_spreg_`$sreg`[index]！＝iss_`$sreg`){ iss_`$sreg`＝$iss_read_register_bitvec(`$sreg`_map)； printf(＂Cosim@cycle％0dPC％h\n\tRTL！＝ISSatTIEState`$sreg`％0h％0h\n\n＂，current_cycle，rtl_spreg_pc[index]，rtl_spreg_`$sreg`[index]，iss_`$sreg`)； } ；}共同仿真源代码(TIE状态比较) //CheckingSpecialRegistergfmod iss_gfmod＝$iss_read_register_bitvec(gfmod_map)； if(rtl_spreg_gfmod[index]！＝iss_gfmod)( iss_gfmod＝$iss_read_register_bitvec(gfmod_map)； printf(＂Cosim@cycle％0dPC％h\n\tRTL！＝ISSatTIEState gfmod％0h％0h\n\n＂，current_cycle，rtl_spreg_pc[index]， rtl_spreg_gfmod[index]，iss_gfmod)； }因此，概括起来，要使Killian等人的申请中描述的仿真程序在本优选实施例中工作，要进行许多主要的通用的对状态的改变。因为TIE状态能够被任意地加宽，所以需要一个对任意大小的寄存器值的接口，但是出于性能的原因，该接口最好不要一直被使用。因为这一点，寄存器被划分为类，而gdb和共同仿真接口被加以更改以便它们能够发现一个类以及从某个整数代码发现类内的一个索引。改变了套接口以便能够传输和接受任意宽度的值。增加了新的存储器接口以支持宽装入和存储。TIE状态的初始化被通用化为支持寄存器文件和寄存器对协处理器的分配。增加了对与TIE状态访问相关的仿真流水线延迟的支持。修改了对TIE状态的接口以便仿真CPENABLE异常。总结概括起来，上面讨论的主要TIE结构，受它们影响的所生成的文件以及它们的通常的目的见下面表III结构生成的文件目的/任务·另一个字段子字段·Libisa-<tie>.a·Libiss-<tie>.a·<tie>.v·customer.isa·支持存储器次序独立子段定义·TIE模块·Libiss-<tie>.a·Cstub-<tie>.c·<tie>.v·Verificationfiles·支持不需要写复杂的语义描述的指令的高效硬件执行·寄存器操作数·Libisa-<tie>.a·Libcc-<tie>.a·Libiss-<tie>.a·Cstub-<tie>.c·Xtensa-<tie>.h·<tie>.v·customer.isa·为了定义具有用户定义的寄存器文件的寄存器操作数的指令·在寄存器文件读/写端口分配中使用的基本实体·Iclass接口子句·Xtensa-<tie>.h·Libiss-<tie>.a·<tie>.v·cstub-<tie>.c·Verificationfiles·在TIE指令和Xtensa核心之间获取交互·接口·Libcc-<tie>.a·Libcc-<tie>.a·Cstub-<tie>.c·Xtensa-<tie>.h·<tie>.v·允许TIE指令访问某个核心功能性·调度·Libcc-<tie>.a·Libiss-<tie>.a·<tie>.v·customer.isa·生成指令的多周期执行·调度代码达到最高效率·按精确的时钟周期计数仿真指令·寄存器文件·Libisa-<tie>.a·Libcc-<tie>.a·Libiss-<tie>.a·Cstub-<tie>.c·Xtensa-<tie>.h·<tie>.v·customer.isa·为实现更高效率的计算使用协处理器寄存器文件·摘要系统·描述·Ipml_note·Assm_note·Customer.isa·为TIE指令生成文档·Ctype·Libcc-<tie>.a·为了方便编程和自动的寄存器分配，在C语言中支持新的数据类型·Proto·Libcc-<tie>.a·Xtensa-<tie>.h·为自动的寄存器分配提供附加的信息·支持C类型的自动转换·支持指令表达方式·参考·Libisa-<tie>.a·Libcc-<tie>.a·Libiss-<tie>.a·Cstub-<tie>.c·Xtensa-<tie>.h·<tie>.v·customer.isa·提供TIE指令的参考定义·检查TIE指令的语义描述的正确性·协处理器·Customer.isa·Libiss-<tie>.a·将寄存器文件和状态分组为协处理器以支持延迟文本切换上面说明的本发明与其中的一个优选实施例相关，然而这只是为了说明的目的，本发明并不局限于此。实际上，对本领域的技术人员来说，本发明的各种变型都是显而易见的，并且都在本发明的范围之内。附录AREADME.gfNotation＜dir＞-pathtothisdirectoryThisisabrieflistofthefilesinthisdirectory.Miscellaneous README.gfthisfile gf.tieacopyofthesourcetiefile default-paramsdefaultparamfiletoconfiguresoftwaretools gf-paramsparamfiletoconfiguresoftwaretoolsforgf.tieNativeCSupport cstub-gf.cfunctionsforthenewinstructions cstub-gf-ref.cfunctionsgeneratedfrom＂reference＂ BR.hsupportforBRregisterfileDesignCompilerSynthesis gf.vVerilogsourcefile gf_check.dcshSyntaxcheckgeneratedverilog gf.dcshTop-levelDesignCompilersynthesisscript Xtensa_cons_generic.dcsupportingscript Xtensa_prim.dcsupportingscript TIE_opt.dcsupportingscript xmTIE_cons.dcsupportingscript prim.vsupportingVerilogsourcefileVerysysVerification verysyssubdirectorysupportingVerysysverification verysys/verify_sem.vVerilogsourcegeneratedfromsemantics verysys/verify_ref.vVerilogsourcegeneratedfromreferenceXtensatoolsupport libisa-gf.sodynamicallylinkedlibraryforxt-gcc libiss-gf.sodynamicallylinkedlibraryforxt-run xtensa-gf.hmacrodefinitionsofnewinstructionsUnknown gf_test.vTocompileyourapplicationinnativemode -includecstub-gf.cinyourapplication -compileyourapplicationusingyournativeccompiler(e.g.，gcc) ThenewTIEinstructionsarereplacedwithequivalentCcode. Ifyoudefineadd＂-DTIE_DEBUG＂totheCcompile，thefunctionnamesfor thetranslatedTIEinstructionswillbeprefixedwith＂TIE_＂Usingthis method，youcanchecktheTIEdescriptionagainsthand-writtenCfunctions forthenewinstructions.Referfortheapplicationnoteformore details.TocompileyourapplicationforXtensa -add＂--xtensa-params＝＜dir＞＂tothecommandlineoraddtheenvironment<dpn="d95"/> variable′XTENSA_PARAMS＝＜dir＞；exportXTENSA_PARAMS＂ -compileyourapplicationusingxt-gccToestimatetheimpactofyourTIEdescriptiononXtensaspeed -SetupyourshellenvironmenttorunSynopsysDesignCompiler -Modifygf.dcshtofillinyourtechnologyinformation -Rundc_shellwithscriptgf.dcsh，e.g.， ＂dc_shell-fgf.dcsh＞&amp;dc.out&amp;＂ -Inspectthesynthesisresults.Lookinreportsectionof theoutputfile＂dc.out＂.Ifthereisanytimingviolation，theXtensa speedwillbeimpacted，roughlybytheviolationamount.Thearea<br/>report sectionwillgiveyoutheareaofyourtieinstructionblock.TocomparereferencedesignsagainstsemanticdesignsusingVerysys -＂cd＜dir＞/verysys；make＂Notesforvl.5user -cstub-gf.ccanbeincludedforxt-gcccompiles；itwillbeignoredNoteforvl.1user -noneedtoregeneratethisdevelopmentkitsfromtheWeb. -noneedtoinclude＜machine/Customer.h＞anymoregf.tieopcodeGFADD8op2＝4′b0000CUST0opcodeGFMULX8op2＝4′b0001CUST0opcodeGFRWMOD8op2＝4′b0010CUST0opcodeGFADD8Iop2＝4′b0100CUST0opcodeLGF8.Ir＝4′b0000LSCIopcodeSGF8.Ir＝4′b0001LSCIopcodeLGF8.IUr＝4′b0010LSCIopcodeSGF8.IUr＝4′b0011LSCIopcodeLGF8.Xop2＝4′b0000LSCXopcodeSGF8.Xop2＝4′b0001LSCXopcodeLGF8.XUop2＝4′b0010LSCXopcodeSGF8.XUop2＝4′b0011LSCXstategfmod8user_register0{gfmod}regfilegf816goperandgrr{gf[r]}operandgss{gf[s]}operandgtt{gf[t]}operandimm4t{t}{imm4}interfaceVAddr32coreoutinterfaceLSSize5coreoutinterfaceMemDataIn88coreininterfaceMemDataOut88coreouticlassgfrrr{GFADD8}{outgr，ings，ingt}{}{}iclassgfrri{GFADD8I}{outgr，ings，inimm4}{}{}iclassgfrr{GFMULX8}{outgr，ings}{ingfmod}{}iclassgfr{GFRWMOD8}{inoutgt}{inoutgfmod}{}<dpn="d96"/>iclassgfloadi{LGF8.I}{outgt，inars，inimm8}{}{outLSSize，outVAddr，inMemDataIn8}iclassgfstorei{SGF8.I}{ingt，inars，inimm8}{}{outLSSize，outVAddr，outMemDataOut8}iclassgfloadiu{LGF8.IU}{outgt，inoutars，inimm8}{}{outLSSize，outVAddr，inMemDataIn8}iclassgfstoreiu{SGF8.IU}{ingt，inoutars，inimm8}{}{outLSSize，outVAddr，outMemDataOut8}iclassgfloadx{LGF8.X}{outgr，inars，inart}{}{outLSSize，outVAddr，inMemDataIn8}iclassgfstorex{SGF8.X}{ingr，inars，inart}{}{outLSSize，outVAddr，outMemDataOut8}iclassgfloadxu{LGF8.XU}{outgr，inoutars，inart}{}{outLSSize，outVAddr，inMemDataIn8}iclassgfstorexu{SGF8.XU}{ingr，inoutars，inart}{}{outLSSize，outVAddr，outMemDataOut8}semanticgf1{GFADD8}{assigngr＝gs^gt；}semanticgf4{GFADD8I}{assigngr＝gs^imm4；}semanticgf2{GFMULX8}{assigngr＝gs[7]？({gs[60]，1′b0}^gfmod){gs[60]，1′b0)；}semanticgf3{GFRWMOD8}{wire[70]t1＝gt；wire[70]t2＝gfmod；assigngfmod＝t1；assigngt＝t2；}semanticlgf{LGF8.I，LGF8.IU，LGF8.X，LGF8.XU}{wireindexed＝LGF8.X|LGF8.XU；assignLSSize＝1；assignVAddr＝ars+(indexed？artimm8)；assigngt＝MemDataIn8；assigngr＝MemDataIn8；assignars＝VAddr；}semanticsgf{SGF8.I，SGF8.IU，SGF8.X，SGF8.XU}{wireindexed＝SGF8.X|SGF8.XU；assignLSSize＝1；assignVAddr＝ars+(indexed？artimm8)；assignMemDataOut8＝SGF8.X|SGF8.XU？grgt；assignars＝VAddr；}referenceGFADD8{assigngr＝gs^gt；}referenceGFADD8I{assigngr＝gs^imm4；<dpn="d97"/>}referenceGFMULX8{assigngr＝gs[7]？({gs[60]，1′b0}^gfmod){gs[60]，1′b0}；}referenceGFRWMOD8{wire[70]t1＝gt；wire[70]t2＝gfmod；assigngfmod＝t1；assigngt＝t2；}referenceLGF8.I{assignLSSize＝1；assignVAddr＝ars+imm8；assigngt＝MemDataIn8；}referenceLGF8.IU{ assignLSSize＝1； assignVAddr＝ars+imm8； assigngt＝MemDataIn8； assignars＝VAddr；}referenceLGF8.X{ assignLSSize＝1； assignVAddr＝ars+art； assigngr＝MemDataIn8； assignars＝VAddr；}referenceLGF8.XU{ assignLSSize＝1； assignVAddr＝ars+art； assigngr＝MemDataIn8； assignars＝VAddr；}referenceSGF8.I{ assignLSSize＝1； assignVAddr＝ars+imm8； assignMemDataOut8＝gt；}referenceSGF8.IU{ assignLSSize＝1； assignVAddr＝ars+imm8； assignMemDataOut8＝gt； assignars＝VAddr；}referenceSGF8.X{ assignLSSize＝1； assignVAddr＝ars+art； assignMemDataOut8＝gr；}referenceSGF8.XU{ assignLSSize＝1； assignVAddr＝ars+art； assignMemDataOut8＝gr； assignars＝VAddr；}ctypegf888gfprotogf8_loadi{outgf8t，ingf8*s，inimmediateo}{}{ LGF8.It，s，o；}<dpn="d98"/>protogf8_storei{ingf8t，ingf8*s，inimmediateo}{}{ SGF8.It，s，o；}protogf8_move{ingf8r，ingf8s}{}{ GFADD8r，s，0；}schedulegfload{LGF8.I}{useimm80；usears1；defgt2；}schedulegfloadu{LGF8.IU}{useimm80；usears1；defars1；defgt2；}schedulegfloadx{LGF8.X}{usears1；useart1；defgr2；}schedulegfloadxu{LGF8.XU}{usears1；useart1；defart1；defgr2；}synopsisGFADD8＂GaloisField8-bitAdd＂synopsisGFADD8I＂GaloisField8-bitAddImmediate＂synopsisGFMUIX8＂GaloisField8-bitMultiplybyX＂synopsisGFRWMOD8＂Read/WriteGaloisFieldPolynomial＂synopsisLGF8.I＂LoadGaloisFieldRegisterImmediate＂synopsisLGF8.IU＂LoadGaloisFieldRegisterImmediateUpdate＂synopsisLGF8.X＂LoadGaloisFieldRegisterIndexed＂synopsisLGF8.XU＂LoadGaloisFieldRegisterIndexedUpdate＂synopsisSGF8.I＂StoreGaloisFieldRegisterImmediate＂synopsisSGF8.IU＂StoreGaloisFieldRegisterImmediateUpdate＂synopsisSGF8.X＂StoreGaloisFieldRegisterIndexed＂synopsisSGF8.XU＂StoreGaloisFieldRegisterIndexedUpdate＂descriptionGFADD8＂＜P＞＜CODE＞GFADD8＜/CODE＞performsa8-bitGaloisFieldadditionofthecontentsofGFregisters＜CODE＞gs＜/CODE＞and＜CODE＞gt＜/CODE＞andwritestheresulttoGFregister＜CODE＞gr＜/CODE＞.＜/P＞＂descriptionGFADD8I＂＜P＞＜CODE＞GFADD8I＜/CODE＞performsa8-bitGaloisFieldadditionofthecontentsofGFregister＜CODE＞gs＜/CODE＞anda4-bitimmediatefromthe＜CODE＞t＜/CODE＞fieldandwritestheresulttoGFregister＜CODE＞gr＜/CODE＞.＜/P＞＂<dpn="d99"/>descriptionGFMULX8＂＜P＞＜CODE＞GFMULX8＜/CODE＞performsa8-bitGaloisFieldmultiplicationofthecontentsofGFregister＜CODE＞gs＜/CODE＞by＜I＞x＜/I＞modulothepolynomialin＜CODE＞gfmod＜/CODE＞.ItwritestheresulttoGFregister＜CODE＞gr＜/CODE＞.＜/P＞＂descriptionGFRWMOD＂＜P＞＜CODE＞GFRWMOD＜/CODE＞readsandwritesthe＜CODE＞gfmod＜/CODE＞polynomialregister.GFregister＜CODE＞gt＜/CODE＞and＜CODE＞gfmod＜/CODE＞arereadthesearewrittento＜CODE＞gfmod＜/CODE＞and＜CODE＞gt＜/CODE＞.＜/P＞＂descriptionLGF8.I＂＜P＞＜/P＞＂descriptionLGF8.IU＂＜P＞＜/P＞＂descriptionLGF8.X＂＜P＞＜/P＞＂descriptionLGF8.XU＂＜P＞＜/P＞＂descriptionSGF8.I＂＜P＞＜/P＞＂descriptionSGF8.IU＂＜P＞＜/P＞＂descriptionSGF8.X＂＜P＞＜/P＞＂descriptionSGF8.XU＂＜P＞＜/P＞＂default-paramsisa-tie-dll＝lib-i686-Linux/libisa-gf.soiss-tie-dll＝lib-i686-Linux/libiss-gf.socc-tie-dll＝lib-i686-Linux/libcc-gf.soxtensa-tie-header＝xtensa-gf.hgf-paramsisa-tie-dll＝lib-i686-Linux/libisa-gf.soiss-tie-dll＝lib-i686-Linux/libiss-gf.socc-tie-dll＝lib-i686-Linux/libcc-gf.soxtensa-tie-header＝xtensa-gf.h<dpn="d100"/>cstub-gf.c#ifndef_XTENSA_#ifdefTIE_DEBUG#definegf8_loadiTIE_gf8_loadi#definegf8_storeiTIE_gf8_storei#definegf8_moveTIE_gf8_move#defineGFADD8TIE_GFADD8#defineGFADD8ITIE_GFADD8I#defineGFMULX8TIE_GFMULX8#defineGFRWMOD8TIE_GFRWMOD8#defineLGF8_ITIE_LGF8_I#defineSGF8_ITIE_SGF8_I#defineLGF8_IUTIE_LGF8_IU#defineSGF8_IUTIE_SGF8_IU#defineLGF8_XTIE_LGF8_X#defineSGF8_XTIE_SGF8_X#defineLGF8_XUTIE_LGF8_XU#defineSGF8_XUTIE_SGF8_XU#defineRUR0TIE_RUR0#defineWUR0TIE_WUR0#endif#include＜stdio.h＞#defineLittleEndian0#defineBigEndian1#definePIFReadDataBits128#definePIFWriteDataBits128#defineIsaMemoryOrderLittleEndian#include＂BR.h＂#include＂LS.h＂#defineBPW32#defineWINDEX(_n)((_n)/BPW)#defineBINDEX(_n)((_n)％BPW)typedefunsignedcharVb_t；typedefunsignedshortVs_t；typedefstructV1_s{unsigneddata[1]；}V1_t；typedefstructV2_s{unsigneddata[2]；}V2_t；typedefstructV4_s{unsigneddata[4]；}V4_t；typedefVb_tgf8；staticinttie_load_instruction＝0；voidTieMemRead(unsigned*data，unsignedaddr){ unsignedchar*mem； unsignedmodulus，bytes，offset； intt，b0，b1，b2，b3； bytes＝PIFReadDataBits/8； modulus＝bytes-1； mem＝(unsignedchar*)(addr&amp;-modulus)； offset＝(unsignedchar*)addr-mem； if(IsaMemoryOrder＝＝LittleEndian){<dpn="d101"/> for(t＝0；t＜bytes/sizeof(int)；t++){ b0＝mem[(offset++)&amp;modulus]； b1＝mem[(offset++)&amp;modulus]； b2＝mem[(offset++)&amp;modulus]； b3＝mem[(offset++)&amp;modulus]； data[t]＝(b3＜＜24)|(b2＜＜16)|(b1＜＜8)|b0； } }else{ for(t＝bytes/sizeof(int)-1；t＞＝0；t--){ b3＝mem[(offset++)&amp;modulus]； b2＝mem[(offset++)&amp;modulus]； b1＝mem[(offset++)&amp;modulus]； b0＝mem[(offset++)&amp;modulus]； data[t]＝(b3＜＜24)|(b2＜＜16)|(b1＜＜8)|b0； } }}voidTieMemWrite(unsignedaddr，unsignedbytes，unsigned*data){ unsignedchar*mem； unsignedmodulus，offset，w； intt； if(PIFWriteDataBits＜bytes*8){ fprintf(stderr，＂Errornotconfiguredtowrite％dbytes\n＂，bytes)； exit(1)； } modulus＝bytes-1； mem＝(unsignedchar*)(addr&amp;-modulus)； if(IsaMemoryOrder＝＝LittleEndian){ if(bytes＝＝1){ mem＝data&amp;0xff； }elseif(bytes＝＝2){ mem＝data&amp;0xff； mem[1]＝(data＞＞8)&amp;0xff； }else{ offset＝0； for(t＝0；t＜bytes/sizeof(int)；t++){ w＝data[t]； mem[offset++]＝w&amp;255； mem[offset++]＝(w＞＞8)&amp;255； mem[offset++]＝(w＞＞16)&amp;255； mem[offset++]＝(w＞＞24)&amp;255； } } }else{ if(bytes＝＝1){ mem＝data&amp;0xff； }elseif(bytes＝＝2){ mem[1]＝data&amp;0xff； mem＝(data＞＞8)&amp;0xff； }else{ offset＝0； for(t＝bytes/sizeof(int)-1；t＞＝0；t--){ w＝data[t]；<dpn="d102"/> mem[offset++]＝(w＞＞24)&amp;255； mem[offset++]＝(w＞＞16)&amp;255； mem[offset++]＝(w＞＞8)&amp;255； mem[offset++]＝w&amp;255； } } }}#defineGetState(_s，_n)_s＝_n#defineSetState(_n，_s)_n＝_sV1_tSTATE_gfmod；V1_tVAddr＝{{0}}；V1_tVAddrBase＝{{0}}；V1_tVAddrOffset＝{{0}}；V1_tVAddrIndex＝{{0}}；V1_tVAddrIn＝{{0}}；V1_tLssize＝{{0}}；V1_tLSIndexed＝{{0}}；V4_tMemDataIn128＝{{0，0，0，0}}；V2_tMemDataIn64＝{{0，0}}；V1_tMemDstaIn32＝{{0}}；V1_tMemDataIn16＝{{0}}；V1_tMemDataIn8＝{{0}}；V4_tMemDataOut128＝{{0，0，0，0}}；V2_tMemDataOut64＝{{0，0}}；V1_tMemDataOut32＝{{0}}；V1_tMemDataOut16＝{{0}}；V1_tMemDataOut8＝{{0}}；V1_tException＝{{0}}；V1_tExcCause＝{{0}}；V1_tCPEnable＝{{0}}；voidVAddrIn_get(void){ if(LSIndexed.data！＝0){ VAddrIn.data＝VAddrBase.data+VAddrIndex.data； }else{ VAddrIn.data＝VAddrBase.data+VAddrOffset.data； }}voidMemDataIn128_get(void){ unsigneddata[4]； if((！tie_load_instruction)||(LSSize.data！＝16)){ return； } if(PIFReadDataBits＜128){ fprintf(stderr，＂Errornotconfiguredtoread16bytes\n＂)；exit(-1)； }<dpn="d103"/> VAddrIn_get()； TieMemRead(&amp;data，VAddrIn.data)； MemDataIn128.data＝data； MemDataIn128.data[1]＝data[1]； MemDataIn128.data[2]＝data[2]； MemDataIn128.data[3]＝data[3]；}voidMemDataIn64_get(void){ unsigneddata[4]； if((！tie_load_instruction)||(LSSize.data！＝8)){ return； } if(PIFReadDataBits＜64){ fprintf(stderr，＂Errornotconfiguredtoread8bytes\n＂)； exit(-1)； } VAddrIn_get()； TieMemRead(&amp;data，VAddrIn.data)； if(IsaMemoryOrder＝＝LittleEndian){ MemDataIn64.data＝data； MemDataIn64.data[1]＝data[1]； }elseif(PIFReadDataBits＝＝64){ MemDataIn64.data＝data； MemDataIn64.data[1]＝data[1]； }else{ MemDataIn64.data＝data[2]； MemDataIn64.data[1]＝data[3]； }}voidMemDataIn32_get(void){ unsigneddata[4]； if((！tie_load_instruction)||(LSSize.data！＝4)){ return； } if(PIFReadDataBits＜32){ fprintf(stderr，＂Errornotconfiguredtoread4bytes\n＂)； exit(-1)； } VAddrIn_get()； TieMemRead(&amp;data，VAddrIn.data)； if(IsaMemoryOrder＝＝LittleEndian){ MemDataIn32.data＝data； }elseif(PIFReadDataBits＝＝32){ MemDataIn32.data＝data； }elseif(PIFReadDataBits＝＝64){ MemDataIn32.data＝data[1]；<dpn="d104"/> }else{ MemDataIn32.data＝data[3]； }}voidMemDataIn16_get(void){ unsigneddata[4]； if((！tie_load_instruction)||(LSSize.data！＝2)){ return； } if(PIFReadDataBits＜16){ fprintf(stderr，＂Errornotconfiguredtoread2bytes\n＂)； exit(-1)； } VAddrIn_get()； TieMemRead(&amp;data，VAddrIn.data)； if(IsaMemoryOrder＝＝LittleEndian){ MemDataIn16.data＝data&amp;0xffff； }elseif(PIFReadDataBits＝＝32){ MemDataIn16.data＝data＞＞16； }elseif(PIFReadDataBits＝＝64){ MemDataIn16.data＝data[1]＞＞16； }else{ MemDataIn16.data＝data[3]＞＞16； }}voidMemDataIn8_get(void){ unsigneddata[4]； if((！tie_load_instruction)||(LSSize.data！＝1)){ return； } if(PIFReadDataBits＜8){ fprintf(stderr，＂Errornotconfiguredtoread1byte\n＂)； exit(-1)； } VAddrIn_get()； TieMemRead(&amp;data，VAddrIn.data)； if(IsaMemoryOrder＝＝LittleEndian){ MemDataIn8.data＝data&amp;0xff； }elseif(PIFReadDataBits＝＝32){ MemDataIn8.data＝data＞＞24； }elseif(PIFReadDataBits＝＝64){ MemDataIn8.data＝data[1]＞＞24； }else{ MemDataIn8.data＝data[3]＞＞24； }}<dpn="d105"/>voidMemDataOut128_set(void){ if(LSSize.data！＝16){ return； } VAddrIn_get()； TieMemWrite(VAddrIn.data&amp;-0xf，16，&amp;MemDataOut128.data)；}voidMemDataOut64_set(void){ if(LSSize.data！＝8){ return； } VAddrIn_get()； TieMemWrite(VAddrIn.data&amp;-0x7，8，&amp;MemDataOut64.data)；}voidMemDataOut32set(void){ if(LSSize.data！＝4){ return； } VAddrIn_get()； TieMemWrite(VAddrIn.data&amp;-0x3，4，&amp;MemDataOut32.data}voidMemDataOut16_set(void){ if(LSSize.data！＝2){ return； } VAddrIn_get()； TieMemWrite(VAddrIn.data&amp;-0x1，2，&amp;MemDataOut16.data}voidMemDataOut8_set(void){ if(LSSize.data！＝1){ return； } VAddrIn_get()； TieMemWrite(VAddrIn.data，1，&amp;MemDataOut8.data)；}<dpn="d106"/>voidException_set(void){ /*Exceptionhandlingisnotsupportedinnativemode*/}voidCPEnable_get(void){ CPEnable.data＝0xff；/*alwaysenabledinnativeCmode*/}#defineRUR(n)({\ intv；\ switch(n){\ case0\ v＝RUR0()；break；\ default\ fprintf(stderr，＂Errorinvalidrurnumber％d\n＂，n)；\ exit(-1)；\ }\ v；\})#defineWUR(v，n)\ switch(n){\ case0\ WUR0(v)；break；\ default\ fprintf(stderr，＂Errorinvalidwurnumber％d\n＂，n)；\ exit(-1)；\ }gf8GFADD8(gf8gs_，gf8gt_){ /*operandvariables*/ V1_tgr_o； V1_tgs_i； V1_tgt_i； /*unusedoperandvariables*/ /*operandkillvariables*/ V1_tgr_kill_o＝{{0}}； /*one-hotinstructionsignals*/ V1_tGFADD8＝{{1}}； /*statevariables*/ /*localwirevariables*/ /*initializein/inoutoperands*/ gs_i.data＝gs_； gt_i.data＝gt_； tie_load_instruction＝0； /*semanticstatements*/ gr_o.data＝(gs_i.data^gt_i.data)&amp;0xff； gr_kill_o.data＝(0&amp;GFADD8.data)&amp;0x1； /*write-backinoutoperands*/ /*returntheoutputoperand*/ returngr_o.data；<dpn="d107"/>}gf8GFADD8I(gf8gs_，ntimm4_){ /*operandvariables*/ V1_tgr_o； V1_tgs_i； V1_timm4； /*unusedoperandvariables*/ /*operandkillvariables*/ V1_tgr_kill_o＝{{0}}； /*one-hotinstructionsignals*/ V1_tGFADD8I＝{{1}}； /*statevariables*/ /*localwirevariables*/ /*initializein/inoutoperands*/ gs_i.data＝gs_； imm4.data＝imm4_； tie_load_instruction＝0； /*semanticstatements*/ gr_o.data＝(gs_i.data^imm4.data)&amp;0xff； gr_kill_o.data＝(0&amp;GFADD8I.data)&amp;0x1； /*write-backinoutoperands*/ /*returntheoutputoperand*/ returngr_o.data；}gf8GFMULX8(gf8gs_){ /*operandvariables*/ V1_tgr_o； V1_tgs_i； /*unusedoperandvariables*/ /*operandkillvariables*/ V1_tgr_kill_o＝{{0}}； /*one-hotinstructionsignals*/ V1_tGFMULX8＝{{1}}； /*statevariables*/ V1_tgfmod_ps； /*localwirevariables*/ V1_ttmp5； V1_ttmp4； V1_ttmp3； V1_ttmp2； V1_ttmp1； V1_ttmp0； /*getinputstatevalues*/ GetState(gfmod_ps，STATE_gfmod)； /*initializein/inoutoperands*/ gs_i.data＝gs_； tieloadinstruction＝0； /*semanticstatements*/ tmp0.data＝(((gs_i.data＜＜24)＞＞31))&amp;0x1； tmp1.data＝((gs_i.data&amp;0x7f))&amp;0x7f； tmp2.data＝((tmp1.data＜＜1)|0}&amp;0xff； tmp3.data＝(tmp2.data^gfmod_ps.data)&amp;0xff； tmp4.data＝((gs_i.data&amp;0x7f))&amp;0x7f； tmp5.data＝((tmp4.data＜＜1)|0)&amp;0xff；<dpn="d108"/> gr_o.data＝((tmp0.data)？tmp3.datatmp5.data)&amp;0xff； gr_kill_o.data＝(0&amp;GFMULX8.data)&amp;0x1； /*write-backinoutoperands*/ /*returntheoutputoperand*/ returngr_o.data；#defineGFRWMOD8(gt)\ GFRWMOD8_func(&amp;(gt))voidGFRWMOD8_func(gf8*gt_){ /*operandvariables*/ V1_tgt_o； V1_tgt_i； /*unusedoperandvariables*/ /*operandkillvariables*/ V1_tgt_kill_o＝{{0}}； /*one-hotinstructionsignals*/ V1_tGFRWMOD8＝{{1}}； /*statevariables*/ V1_tgfmod_ps； V1_tgfmod_ns； V1_tgfmod_kill_ns； /*localwirevariables*/ V1_tt1； V1_tt2； /*getinputstatevalues*/ GetState(gfmod_ps，STATE_gfmod)； /*initializein/inoutoperands*/ gt_i.data＝*gt_； tie_loadinstruction＝0； /*semanticstatements*/ ti.data＝gt_i.data&amp;0xff； t2.data＝gfmod_ps.data&amp;0xff； gfmod_ns.data＝t1.data&amp;0xff； gt_o.data＝t2.data&amp;0xff； gfmod_kill_ns.data＝(0&amp;GFRWMOD8.data)&amp;0x1； gt_kill_o.data＝(0&amp;GFRWMOD8.data)&amp;0x1； /*write-backinoutoperands*/ if(！gt_kill_o.data)*gt_＝gt_o.data； /*updateout/inoutstates*/ if(！gfmod_kill_ns.data)SetState(STATE_gfmod，gfmod_ns)；}gf8LGF8_I(unsignedars_，intimm8_){ /*operandvariables*/ V1_tgt_o； V1_tars_i； V1_timm8； /*unusedoperandvariables*/ V1_tars_o； V1_tgr_o； V1_tart_i＝{{0}}； /*operandkillvariables*/ V1_tgt_kill_o＝{{0}}； V1_tars_kill_o＝{{0}}；<dpn="d109"/> V1_tgr_kill_o＝{{0}}； /*one-hotinstructionsignals*/ V1_tLGF8_I＝{{1}}； V1_tLGF8_IU＝{{0}}； V1_tLGF8_X＝{{0}}； v1_tLGF8_U＝{{0}}； /*statevariables*/ /*localwirevariables*/ V1_ttmp2； V1_ttmp1； V1_ttmp0； V1_tindexed； /*initializein/inoutoperands*/ ars_i＝*((V1_t*)&amp;ars_)； imm8.data＝imm8_； tie_load_instruction＝1； /*semiticstatements*/ indexed.data＝(LGF8_X.data|LGF8_XU.data)&amp;0x1； LSSize.data＝0x1&amp;0x1f； VAddrBase.data＝ars_i.data； LSIndexed.data＝indexed.data&amp;0x1； VAddrOffset.data＝imm8.data； VAddrIndex.data＝art_i.data； MemDataIn8_get()； gt_o.data＝MemDataIn8.data&amp;0xff； MemDataIn8_get()； gr_o.data＝MemDataIn8.data&amp;0xff； VAddrIn_get()； ars_o.data＝VAddrIn.data； tmp0.data＝(LGF8_I.data|LGF8_IU.data)&amp;0x1； gt_kill_o.data＝(0&amp;tmp0.data)&amp;0x1； tmp1.data＝(LGF8_IU.data|LGF8_XU.data)&amp;0x1； ars_kill_o.data＝(0&amp;tmp1.data)&amp;0x1； tmp2.data＝(LGF8_X.data|LGF8_XU.data)&amp;0x1； gr_kill_o.data＝(0&amp;tmp2.data)&amp;0x1； /*write-backinoutoperands*/ /*updateoutputinterfacesignals*/ /*returntheoutputoperand*/ returngt_o.data；}#defineLGF8_IU(ars，imm8)\ LGF8IUfunc(&amp;(ars)，imm8)gf8LGF8_IU_func(unsigned*ars_，intimm8_){ /*operandvariables*/ V1_tgt_o； V1_tars_o； V1_tars_i； V1_timm8； /*unusedoperandvariables*/ V1_tgr_o； V1_tart_i＝{{0}}； /*operandkillvariables*/ V1_tgt_kill_o＝{{0}}； V1_tars_kill_o＝{{0}}； V1_tgr_kill_o＝{{0}}； /*one-hotinstructionsignals*/<dpn="d110"/> V1_tLGF8_I＝{{0}}； V1_tLGF8_IU＝{{1}}； V1_tLGF8_X＝{{0}}； V1_tLGF8_XU＝{{0}}； /*statevariablles*/ /*localwirevariables*/ V1_ttmp2； V1_ttmp1； V1_ttmp0； V1_tindexed； /*initializein/inoutoperands*/ ars_i＝*((V1_t*)ars_)； imm8.data＝imm8_； tie_load_instruction＝1； /*semanticstatements*/ indexed.data＝(LGF8_X.data|LGF8_XU.data)&amp;0x1； LSSize.data＝0x1&amp;0x1f； VAddrBase.data＝ars_i.data； LSIndexed.data＝indexed.data&amp;0x1； VAddrOffset.data＝imm8.data； VAddrIndex.data＝art_i.data； MemDataIn8_get()； gt_o.data＝MemDataIn8.data&amp;0xff； MemDataIn8_get()； gr_o.data＝MemDataIn8.data&amp;0xff； VAddrIn_get()； ars_o.data＝VAddrIn.data； tmp0.data＝(LGF8_I.data|LGF8_IU.data)&amp;0x1； gt_kill_o.data＝(0&amp;tmp0.data)&amp;0x1； tmpl.data＝(LGF8_IU.data|LGF8_XU.data)&amp;0x1； ars_kill_o.data＝(0&amp;tmp1.data)&amp;0x1； tmp2.data＝(LGF8_X.data|LGF8_XU.data)&amp;0x1； gr_kill_o.data＝(0&amp;tmp2.data)&amp;0x1； /*write-backinoutoperands*/ if(！ars_kill_o.data)*ars_＝*((unsigned*)&amp;ars_o)； /*updateoutputinterfacesignals*/ /*returntheoutputoperand*/ returngt_o.data；}gf8LGF8_X(unsignedars_，unsignedart_){ /*operandvariables*/ V1_tgr_o； V1_tars_i； V1_tart_i； /*unusedoperandvariables*/ V1_tgt_o； V1_tars_o； V1_timm8＝{{0}}； /*operandkillvariables*/ V1_tgt_kill_o＝{{0}}； V1_tars_kill_o＝{{0}}； V1_tgr_kill_o＝{{0}}； /*one-hotinstructionsignals*/ V1_tLGF8_I＝{{0}}； V1_tLGF8_IU＝{{0}}； V1_tLGF8_X＝{{1}}； V1_tLGF8_XU＝{{0}}；<dpn="d111"/> /*statevariables*/ /*localwirevariables*/ V1_ttmp2； V1_ttmp1； V1_ttmp0； V1_tindexed； /*initializein/inoutoperands*/ ars_i＝*((V1_t*)&amp;ars_)； art_i＝*((V1_t*)&amp;art_)； tie_loadinstruction＝1； /*semanticstatements*/ indexed.data＝(LGF8_X.data|LGF8_XU.data)&amp;0x1； LSSize.data＝0x1&amp;0x1f； VAddrBase.data＝ars_i.data； LSIndexed.data＝indexed.data&amp;0x1； VAddrOffset.data＝imm8.data； VAddrIndex.data＝art_i.data； MemDataIn8_get()； gt_o.data＝MemDataIn8.data&amp;0xff； MemDataIn8_get()； gr_o.data＝MemDataIn8.data&amp;0xff； VAddrIn_get()； ars_o.data＝VAddrIn.data； tmp0.data＝(LGF8_I.data|LGF8_IU.data)&amp;0x1； gt_kill_o.data＝(0&amp;tmp0.data)&amp;0x1； tmp1.data＝(LGF8_IU.data|LGF8_XU.data)&amp;0x1； ars_kill_o.data＝(0&amp;tmp1.data)&amp;0x1； tmp2.data＝(LGF8_X.data|LGF8_XU.data)&amp;0x1； gr_kill_o.data＝(0&amp;tmp2.data)&amp;0x1； /*write-backinoutoperands*/ /*updateoutputinterfacesignals*/ /*returntheoutputoperand*/ returngr_o.data；}#defineLGF8_XU(ars，art)\ LGF8_XU_func(&amp;(ars)，art)gf8LGF8_XU_func(unsigned*ars_，unsignedart_){ /*operandvariables*/ V1_tgr_o； V1_tars_o； V1_tars_i； V1_tart_i； /*unusedoperandvariables*/ V1_tgt_o； V1_timm8＝{{0}}； /*operandkillvariables*/ V1_tgt_kill_o＝{{0}}； V1_tars_kill_o＝{{0}}； V1_tgr_kill_o＝{{0}}； /*one-hotinstructionsignals*/ V1_tLGF8_I＝{{0}}； V1_tLGF8_IU＝{{0}}； V1_tLGF8_X＝{{0}}； V1_tLGF8_XU＝{{1}}； /*statevariables*/ /*localwirevariables*/<dpn="d112"/> V1_ttmp2； V1_ttmp1； V1_ttmp0； V1_tindexed； /*initializein/inoutoperands*/ ars_i＝*((V1_t*)ars_)； art_i＝*((V1_t*)&amp;art_)； tie_load_instruction＝1； /*semanticstatements*/ indexed.data＝(LGF8_X.data|LGF8_XU.data)&amp;0x1； LSSize.data＝0x1&amp;0x1f； VAddrBase.data＝ars_i.data； LSIndexed.data＝indexed.data&amp;0x1； VAddrOffset.data＝imm8.data； VAddrIndex.data＝art_i.data； MemDataIn8_get()； gt_o.data＝MemDataIn8.data&amp;0xff； MemDataIn8_get()； gr_o.data＝MemDataIn8.data&amp;0xff； VAddrIn_get()； ars_o.data＝VAddrIn.data； tmp0.data＝(LGF8_I.data|LGF8_IU.data)&amp;0x1； gt_kill_o.data＝(0&amp;tmp0.data)&amp;0x1； tmp1.data＝(LGF8_IU.data|LGF8_XU.data)&amp;0x1； ars_kill_o.data＝(0&amp;tmp1.data)&amp;0x1； tmp2.data＝(LGF8_X.data|LGF8_XU.data)&amp;0x1； gr_kill_o.data＝(0&amp;tmp2.data)&amp;0x1； /*write-backinoutoperands*/ if(！ars_kill_o.data)*ars_＝*((unsigned*)&amp;ars_o)； /*updateoutputinterfacesignals*/ /*returntheoutputoperand*/ returngr_o.data；}voidSGF8_I(gf8gt_，unsignedars_，intimm8_).{ /*operandvariables*/ V1_tgt_i； V1_tars_i； V1_timm8； /*unusedoperandvariables*/ V1_tars_o； V1_tgr_i＝{{0}}； V1_tart_i＝{{0}}； /*operandkillvariables*/ V1_tars_kill_o＝{{0}}； /*one-hotinstructionsignals*/ V1_tSGF8_IU＝{{0}}； V1_tSGF8_X＝{{0}}； V1_tSGF8_XU＝{{0}}； /*statevariables*/ /*localwirevariables*/ V1_ttmp1； V1_ttmp0； V1_tindexed； /*initializein/inoutoperands*/ gt_i.data＝gt_； ars_i＝*((V1_t*)&amp;ars_)； imm8.data＝imm8_；<dpn="d113"/> tie_load_instruction＝0； /*semanticstatements*/ indexed.data＝(SGF8_X.data|SGF8_XU.data)&amp;0x1； LSSize.data＝0x1&amp;0x1f； VAddrBase.data＝ars_i.data； LSIndexed.data＝indexed.data&amp;0x1； VAddrOffset.data＝imm8.data； VAddrIndex.data＝art_i.data； tmp0.data＝(SGF8_X.data|SGF8_XU.data)&amp;0x1； MemDataOut8.data＝((tmp0.data)？gr_i.datagt_i.data)&amp;0xff； VAddrIn_get()； ars_o.data＝VAddrIn.data； tmpl.data＝(SGF8_IU.data|SGF8_XU.data)&amp;0x1； ars_kill_o.data＝(0&amp;tmp1.data)&amp;0x1； /*write-backinoutoperands*/ /*updateoutputinterfacesignals*/ MemDataOut8_set()；#defineSGF8_IU(gt，ars，imm8)\ SGF8_IU_func(gt，&amp;(ars)，imm8)voidSGF8_IU_func(gf8gt_，unsigned*ars_，intimm8_){ /*operandvariables*/ V1_tgt_i； V1_tars_o； V1_tars_i； V1_timm8； /*unusedoperandvariables*/ V1_tgr_i＝{{0}}； V1_tart_i＝{{0}}； /*operandkillvariables*/ V1_tars_kill_o＝{{0}}； /*one-hotinstructionsignals*/ V1_tSGF8_IU＝{{1}}； V1_tSGF8_X＝{{0}}； V1_tSGF8_XU＝{{0}}； /*statevariables*/ /*localwirevariables*/ V1_ttmp1； V1_ttmp0； V1_tindexed； /*initializein/inoutoperands*/ gt_i.data＝gt_； ars_i＝*((V1_t*)ars_)； imm8.data＝imm8_； tie_load_instruction＝0； /*semanticstatements*/ indexed.data＝(SGF8_X.data|SGF8_XU.data)&amp;0x1； LSSize.data＝0x1&amp;0x1f； VAddrBase.data＝ars_i.data； LSIndexed.data＝indexed.data&amp;0x1； VAddrOffset.data＝imm8.data； VAddrIndex.data＝art_i.data； tmp0.data＝(SGF8_X.data|SGF8_XU.data)&amp;0x1； MemDataOut8.data＝((tmp0.data)？gr_i.datagt_i.data)&amp;0xff；<dpn="d114"/> VAddrIn_get()； ars_o.data＝VAddrIn.data； tmp1.data＝(SGF8_IU.data|SGF8_XU.data)&amp;0x1； ars_kill_o.data＝(0&amp;tmp1.data)&amp;0x1； /*write-backinoutoperands*/ if(！ars_kill_o.data)*ars_＝*((unsigned*)&amp;ars_o)； /*updateoutputinterfacesignals*/ MemDataOut8_set()；}voidSGF8_X(gf8gr_，unsignedars_，unsignedart_){ /*operandvariables*/ V1_tgr_i； V1_tars_i； V1_tart_i； /*unusedoperandvariables*/ V1_tgt_i＝{{0}}； V1_tars_o； V1_timm8＝{{0}}； /*operandkillvariables*/ V1_tars_kill_o＝{{0}}； /*one-hotinstructionsignals*/ V1_tSGF8_IU＝{{0}}； V1_tSGF8_X＝{{1}}； V1_tSGF8_XU＝{{0}}； /*statevariables*/ /*localwirevariables*/ V1_ttmp1； V1_ttmp0； V1_tindexed； /*initializein/inoutoperands*/ gr_i.data＝gr_； ars_i＝*((V1_t*)&amp;ars_)； art_i＝*((V1_t*)&amp;art_)； tie_load_instruction＝0； /*semanticstatements*/ indexed.data＝(SGF8_X.data|SGF8_XU.data)&amp;0x1； LSSize.data＝0x1&amp;0x1f； VAddrBase.data＝ars_i.data； LSIndexed.data＝indexed.data&amp;0x1； VAddrOffset.data＝imm8.data； VAddrIndex.data＝art_i.data； tmp0.data＝(SGF8_X.data|SGF8_XU.data)&amp;0x1； MemDataOut8.data＝((tmp0.data)？gr_i.datagt_i.data)&amp;0xff； VAddrIn_get()； ars_o.data＝VAddrIn.data； tmp1.data＝(SGF8_IU.data|SGF8_XU.data)&amp;0x1； ars_kill_o.data＝(0&amp;tmp1.data)&amp;0x1； /*write-backinoutoperands*/ /*updateoutputinterfacesignals*/ MemDataOut8_set()；}#defineSGF8_XU(gr，ars，art)\ SGF8_XU_func(gr，&amp;(ars)，art)void<dpn="d115"/>SGF8_XU_func(gf8gr_，unsigned*ars_，unsignedart_){ /*operandvariables*/ V1_tgr_i； V1_tars_o； V1_tars_i； V1_tart_i； /*unusedoperandvariables*/ V1_tgt_i＝{{0}}； V1_timm8＝{{0}}； /*operandkillvariables*/ V1_tars_kill_o＝{{0}}； /*one-hotinstructionsignals*/ V1_tSGF8_IU＝{{0}}； V1_tSGF8_X＝{{0}}； V1_tSGF8_XU＝{{1}}； /*statevariables*/ /*localwirevariables*/ V1_ttmp1； V1_ttmp0； V1_tindexed； /*initializein/inoutoperands*/ gr_i.data＝gr_； ars_i＝*((V1_t*)ars_)； art_i＝*((V1_t*)&amp;art_)； tie_load_instruction＝0； /*semanticstatements*/ indexed.data＝(SGF8_X.data|SGF8_XU.data)&amp;0x1； LSSize.data＝0x1&amp;0x1f； VAddrBase.data＝ars_i.data； LSIndexed.data＝indexed.data&amp;0x1； VAddrOffset.data＝imm8.data； VAddrIndex.data＝art_i.data； tmp0.data＝(SGF8_X.data|SGF8_XU.data)&amp;0x1； MemDataOut8.data＝((tmp0.data)？gr_i.datagt_i.data)&amp;0xff； VAddrIn_get()； ars_o.data＝VAddrIn.data； tmp1.data＝(SGF8_IU.data|SGF8_XU.data)&amp;0x1； ars_kill_o.data＝(0&amp;tmp1.data)&amp;0x1； /*write-backinoutoperands*/ if(！ars_kill_o.data)*ars_＝*((unsigned*)&amp;ars_o)； /*updateoutputinterfacesignals*/ MemDataOut8_set()；}unsignedRUR0(){ /*operandvariables*/ V1_tarr_o； /*unusedoperandvariables*/ /*operandkillvariables*/ V1_tarr_kill_o＝{{0}}； /*one-hotinstructionsignals*/ V1_tRUR0＝{{1}}； /*statevariables*/ V1_tgfmod_ps； /*localwirevariables*/ /*getinputstatevalues*/<dpn="d116"/> GetState(gfmod_ps，STATE_gfmod)； /*initializein/inoutoperands*/ tie_load_instruction＝0； /*semanticstatements*/ arr_o.data＝gfmod_ps.data； art_kill_o.data＝(0&amp;RUR0.data)&amp;0x1； /*write-backinoutoperands*/ /*returntheoutputoperand*/ return*((unsigned*)&amp;arr_o)；}voidWUR0(unsignedart_){ /*operandvariables*/ V1_tart_i； /*unusedoperandvariables*/ /*operandkillvariables*/ /*one-hotinstructionsignals*/ V1_tWUR0＝{{1}}； /*statevariables*/ V1_tgfmod_ns； V1_tgfmod_kill_ns； /*localwirevariables*/ V1_ttmp0； /*initializein/inoutoperands*/ art_i＝*((V1_t*)&amp;art_)； tie_load_instruction＝0； /*semanticstatements*/ tmp0.data＝((art_i.data&amp;0xff))&amp;0xff； gfmod_ns.data＝(tmp0.data)&amp;0xff； gfmod_kill_ns.data＝(0&amp;WUR0.data)&amp;0x1； /*write-backinoutoperands*/ /*updateout/inoutstates*/ if(！gfmod_kill_ns.data)SetState(STATE_gfmod，gfmod_ns)；}#definegf8_loadi(_s，o)({\ gf8t；\ gf8*s＝_s；\ gf8LGF8_I_return；\ LGF8_I_return＝LGF8_I(*((unsigned*)&amp;(s))，*((int*)&amp;(o)))；\ t＝*((gf8*)&amp;LGF8_I_return)；\ t；\})#definegf8_storei(_t，_s，o)({\ gf8t＝_t；\ gf8*s＝_s；\ SGF8_I(*((gf8*)&amp;(t))，*((unsigned*)&amp;(s))，*((int*)&amp;(o)))；\})#definegf8_move(_r，_s)({\ gf8r＝_r；\ gf8s＝_s；\ gf8GFADD8_return；\ GFADD8_return＝GFADD8(*((gf8*)&amp;(s))，*((gf8*)&amp;(0)))；\ r＝*((gf8*)&amp;GFADD8_return)；\})<dpn="d117"/>#ifdefTIE_DEBUG#undefgf8_loadi#undefgf8_storei#undefgf8_move#undefGFADD8#undefGFADD8I#undefGFMULX8#undefGFRWMOD8#undefLGF8_I#undefSGF8_I#undefLGF8_IU#undefSGF8_IU#undefLGF8_X#undefSGF8_X#undefLGF8_XU#undefSGF8_XU#undefRUR0#undefWUR0#endif#endifcstub-gf-ref.c#ifndef_XTENSA_#ifdefTIE_DEBUG#definegf8_loadiTIE_gf8_loadi#definegf8_storeiTIE_gf8_storei#definegf8_moveTIE_gf8_move#defineGFADD8TIE_GFADD8#defineGFADD8ITIE_GFADD8I#defineGFMULX8TIE_GFMULX8#defineGFRWMOD8TIE_GFRWMOD8#defineLGF8_ITIE_LGF8_I#defineSGF8_ITIE_SGF8_I#defineLGF8_IUTIE_LGF8_IU#defineSGF8_IUTIE_SGF8_IU#defineLGF8_XTIE_LGF8_X#defineSGF8_XTIE_SGF8_X#defineLGF8_XUTIE_LGF8_XU#defineSGF8_XUTIE_SGF8_XU#defineRUR0TIE_RUR0#defineWUR0TIE_WUR0#endif#include＜stdio.h＞#defineLittleEndian0#defineBigEndian1#definePIFReadDataBits128#definePIFWriteDataBits128#defineIsaMemoryOrderLittleEndian#include＂BR.h＂#include＂LS.h＂#defineBPW32#defineWINDEX(_n)((_n)/BPW)#defineBINDEX(_n)((_n)％BPW)typedefunsignedcharVb_t；typedefunsignedshortVs_t；typedefstructV1_s{unsigneddata[1]；}V1_t；<dpn="d118"/>typedefstructV2_s{unsigneddata[2]；}V2_t；typedefstructV4_s{unsigneddata[4]；}V4_t；typedefVb_tgf8；staticinttie_load_instruction＝0；voidTieMemRead(unsigned*data，unsignedaddr){unsignedchar*mem； unsignedmodulus，bytes，offset； intt，b0，b1，b2，b3； bytes＝PIFReadDataBits/8； modulus＝bytes-1； mem＝(unsignedchar*)(addr&amp;-modulus)； offset＝(unsignedchar*)addr-mem； if(IsaMemoryOrder＝＝LittleEndian){ for(t＝0；t＜bytes/sizeof(int)；t++){ b0＝mem[(offset++)&amp;modulus]； b1＝mem[(offset++)&amp;modulus]； b2＝mem[(offset++)&amp;modulus]； b3＝mem[(offset++)&amp;modulus]； data[t]＝(b3＜＜24)|(b2＜＜16)|(b1＜＜8)|b0； } }else{ for(t＝bytes/sizeof(int)-1；t＞＝0；t--){ b3＝mem[(offset++)&amp;modulus]； b2＝mem[(offset++)&amp;modulus]； b1＝mem[(offset++)&amp;modulus]； b0＝mem[(offset++)&amp;modulus]； data[t]＝(b3＜＜24)|(b2＜＜16)|(b1＜＜8)|b0； } }}voidTieMemWrite(unsignedaddr，unsignedbytes，unsigned*data)<br/>{ unsignedchar*mem； unsignedmodulus，offset，w； intt； if(PIFWriteDataBits＜bytes*8){ fprintf(stderr，＂Errornotconfiguredtowrite％dbytes\n＂bytes)； exit(1)； } modulus＝bytes-1； mem＝(unsignedchar*)(addr&amp;-modulus)； if(IsaMemoryOrder＝＝LittleEndian){ if(bytes＝＝1){ mem＝data&amp;0xff； }elseif(bytes＝＝2){ mem＝data&amp;0xff；<dpn="d119"/> mem[1]＝(data＞＞8)&amp;0xff； }else{ offset＝0； for(t＝0；t＜bytes/sizeof(int)；t++){ w＝data[t]； mem[offset++]＝w&amp;255； mem[offset++]＝(w＞＞8)&amp;255； mem[offset++]＝(w＞＞16)&amp;255； mem[offset++]＝(w＞＞24)&amp;255； } } }else{ if(bytes＝＝1){ mem＝data&amp;0xff； }elseif(bytes＝＝2){ mem[1]＝data&amp;0xff； mem＝(data＞＞8)&amp;0xff； }else{ offset＝0； for(t＝bytes/sizeof(int)-1；t＞＝0；t--){ w＝data[t]； mem[offset++]＝(w＞＞24)&amp;255； mem[offset++]＝(w＞＞16)&amp;255； mem[offset++]＝(w＞＞8)&amp;255； mem[offset++]＝w&amp;255； } } }}#defineGetState(_s，_n)_s＝_n#defineSetState(_n，_s)_n＝_sV1_tSTATE_gfmod；V1_tVAddr＝{{0}}；V1_tVAddrBase＝{{0}}；V1_tVAddrOffset＝{{0}}；V1_tVAddrIndex＝{{0}}；V1_tVAddrIn＝{{0}}；V1_tASSize＝{{0}}；V1_tLSIndexed＝{{0}}；V4_tMemDataIn128＝{{0，0，0，0}}；V2_tMemDataIn64＝{{0，0}}；V1_tMemDataIn32＝{{0}}；V1_tMemDataIn16＝{{0}}；V1_tMemDataIn8＝{{0}}；V4_tMemDataOut128＝{{0，0，0，0}}；V2_tMemDataOut64＝{{0，0}}；V1_tMemDataOut32＝{{0}}；V1_tMemDataOut16＝{{0}}；V1_tMemDataOut8＝{{0}}；V1_tException＝{{0}}；V1_tExcCause＝{{0}}；V1_tCPEnable＝{{0}}；voidVAddrIn_get(void){ if(LSIndexed.data！＝0){<dpn="d120"/> VAddrIn.data＝VAddrBase.data+VAddrIndex.data； }else{VAddrIn.data＝VAddrBase.data+VAddrOffset.data； }}voidMemDataIn128_get(void){ unsigneddata[4]； if((！tie_load_instruction)||(LSSize.data！＝16)){ return； } if(PIFReadDataBits＜128){ fprintf(stderr，＂Errornotconfiguredtoread16bytes\n＂)； exit(-1)； } VAddrIn_get()； TieMemRead(&amp;data，VAddrIn.data)； MemDataIn128.data＝data； MemDataIn128.data[1]＝data[1]； MemDataIn128.data[2]＝data[2]； MemDataIn128.data[3]＝data[3]；}voidMemDataIn64_get(void){ unsigneddata[4]； if((！tie_load_instruction)||(LSSize.data！＝8)){ return； } if(PIFReadDataBits＜64){ fprintf(stderr，＂Errornotconfiguredtoread8bytes\n＂)； exit(-1)； } VAddrIn_get()； TieMemRead(&amp;data，VAddrIn.data)； if(IsaMemoryOrder＝＝LittleEndian){ MemDataIn64.data＝data； MemDataIn64.data[1]＝data[1]； }elseif(PIFReadDataBits＝＝64){ MemDataIn64.data＝data； MemDataIn64.data[1]＝data[1]； }else{ MemDataIn64.data＝data[2]； MemDataIn64.data[1]＝data[3]； }}void<dpn="d121"/>MemDataIn32_get(void){ unsigneddata[4]； if((！tie_load_instruction)||(LSSize.data！＝4)){ return； } if(PIFReadDataBits＜32){ fprintf(stderr，＂Errornotconfiguredtoread4bytes\n＂)； exit(-1)； } VAddrIn_get()； TieMemRead(&amp;data，VAddrIn.data)； if(IsaMemoryOrder＝＝LittleEndian){ MemDataIn32.data＝data； }elseif(PIFReadDataBits＝＝32){ MemDataIn32.data＝data； }elseif(PIFReadDataBits＝＝64}{ MemDataIn32.data＝data[1]； }else{ MemDataIn32.data＝data[3]； }}voidMemDataIn16_get(void){ unsigneddata[4]； if((！tie_load_instruction)||(LSSize.data！＝2)){ return； } if(PIFReadDataBits＜16){ fprintf(stderr，＂Errornotconfiguredtoread2bytes\n＂)； exit(-1)； } VAddrIn_get()； TieMemRead(&amp;data，VAddrIn.data)； if(IsaMemoryOrder＝＝LittleEndian){ MemDataIn16.data＝data&amp;0xffff； }elseif(PIFReadDataBits＝＝32){ MemDataIn16.data＝data＞＞16； }elseif(PIFReadDataBits＝＝64){ MemDataIn16.data＝data[1]＞＞16； }else{ MemDataIn16.data＝data[3]＞＞16； }}voidMemDataIn8_get(void){ unsigneddata[4]；<dpn="d122"/> if((！tie_load_instruction)||(LSSize.data！＝1)){ return； } if(PIFReadDataBits＜8){ fprintf(stderr，＂Errornotconfiguredtoread1byte\n＂)； exit(-1)； } VAddrIn_get()； TieMemRead(&amp;data，VAddrIn.data)； if(IsaMemoryOrder＝＝LittleEndian){ MemDataIn8.data＝data&amp;0xff； }elseif(PIFReadDataBits＝＝32){ MemDataIn8.data＝data＞＞24； }elseif(PIFReadDataBits＝＝64){ MemDataIn8.data＝data[1]＞＞24； }else{ MemDataIn8.data＝data[3]＞＞24； }}voidMemDataOut128_set(void){ if(LSSize.data！＝16){ return； } VAddrIn_get()； TieMemWrite(VAddrIn.data&amp;-0xf，16，&amp;MemDataOut128.data)；}voidMemDataOut64_set(void){ if(LSSize.data！＝8){ return； } VAddrIn_get()； TieMemWrite(VAddrIn.data&amp;-0x7，8，&amp;MemDataOut64.data)；}voidMemDataOut32_set(void){ if(LSSize.data！＝4){ return； } VAddrIn_get()； TieMemWrite(VAddrIn.data&amp;-0x3，4，&amp;MemDataOut32.data)；}void<dpn="d123"/>MemDataOut16set(void){ if(LSSize.data！＝2){ return； } VAddrIn_get()； TieMemWrite(VAddrIn.data&amp;-0x1，2，&amp;MemDataOut16.data)；}voidMemDataOut8_set(void){ if(LSSize.data！＝1){ return； } VAddrIn_get()； TieMemWrite(VAddrIn.data，1，&amp;MemDataOut8.data)；}voidException_set(void){ /*Exceptionhandlingisnotsupportedinnativemode*/}voidCPEnable_get(void){ CPEnable.data＝0xff；/*alwaysenabledinnativeCmode*/}#defineRUR(n)({\ intv；\ switch(n){\ case0\ v＝RUR0()；break；\ default\ fprintf(stderr，＂Errorinvalidrurnumber％d\n＂，n)；\ exit(-1)；\ }\ v；\})#defineWUR(v，n)\ switch(n){\ case0\ WUR0(v)；break；\ default\ fprintf(stderr，＂Errorinvalidwurnumber％d\n＂，n)；\ exit(-1)；\ }gf8GFADD8(gf8gs_，gf8gt_){<dpn="d124"/> /*operandvariables*/ V1_tgr_o； V1_tgs_i； V1_tgt_i； /*unusedoperandvariables*/ /*operandkillvariables*/ V1_tgr_kill_o＝{{0}}； /*one-hotinstructionsisals*/ V1_tGFADD8＝{{1}}； /*statevariables*/ /*localwirevariables*/ /*initializein/inoutoperands*/ gs_i.data＝gs_； gt_i.data＝gt_； tie_load_instruction＝0； /*semanticstatements*/ gr_o.data＝(gs_i.data^gt_i.data)&amp;0xff； gr_kill_o.data＝(0&amp;GFADD8.data)&amp;0x1； /*write-backinoutoperands*/ /*returntheoutputoperand*/ returngr_o.data；}gf8GFADD8I(gf8gs_，intimm4){ /*operandvariables*/ V1_tgr_o； V1_tgs_i； V1_timm4； /*unusedoperandvariables*/ /*operandkillvariables*/ V1_tgr_kill_o＝{{0}}； /*one-hotinstructionsignals*/ V1_tGFADD8I＝{{1}}； /*statevariables*/ /*localwirevariables*/ /*initializein/inoutoperands*/ gs_i.data＝gs_； imm4.data＝imm4_； tie_load_instruction＝0； /*semanticstatements*/ gr_o.data＝(gs_i.data^imm4.data)&amp;0xff； gr_kill_o.data＝(0&amp;GFADD8I.data)&amp;0x1； /*write-backinoutoperands*/ /*returntheoutputoperand*/ returngr_o.data；}gf8GFMULX8(gf8gs_){ /*operandvariables*/ V1_tgr_o； V1_tgs_i； /*unusedoperandvariables*/ /*operandkillvariables*/ V1_tgr_kill_o＝{{0}}； /*one-hotinstructionsignals*/ V1_tGFMULX8＝{{1}}；<dpn="d125"/> /*statevariables*/ V1_tgfmod_ps； /*localwirevariables*/ V1_ttmp5； V1_ttmp4； V1_ttmp3； V1_ttmp2； V1_ttmp1； V1_ttmp0； /*getinputstatevalues*/ GetState(gfmod_ps，STATE_gfmod)； /*initializein/inoutoperands*/ gs_i.data＝gs_； tie_load_instruction＝0； /*semanticstatements*/ tmp0.data＝(((gs_i.data＜＜24)＞＞31))&amp;0x1； tmp1.data＝((gs_i.data&amp;0x7f))&amp;0x7f； tmp2.data＝((tmp1.data＜＜1)|0)&amp;0xff； tmp3.data＝(tmp2.data^gfmod_ps.data)&amp;0xff； tmp4.data＝((gs_i.data&amp;0x7f))&amp;0x7f； tmp5.data＝((tmp4.data＜＜1)|0)&amp;0xff； gr_o.data＝((tmp0.data)？tmp3.datatmp5.data)&amp;0xff； gr_kill_o.data＝(0&amp;GFMULX8.data)&amp;0x1； /*write-backinoutoperands*/ /*returntheoutputoperand*/ returngr_o.data；}#defineGFRWMOD8(gt)\ GFRWMOD8_func(&amp;(gt))voidGFRWMOD8_func(gf8*gt_){ /*operandvariables*/ V1_tgt_o； V1_tgt_i； /*unusedoperandvariables*/ /*operandkillvariables*/ V1_tgt_kill_o＝{{0}}； /*one-hotinstructionsignals*/ V1_tGFRWMOD8＝ /*statevariables*/ V1_tgfmod_ps； V1_tgfmod_ns； V1_tgfmod_kill_ns； /*localwirevariables*/ Vi_tt1； Vi_tt2； /*getinputstatevalues*/ GetState(gfmod_ps，STATE_gfmod)； /*initializein/inoutoperands*/ gt_i.data＝*gt_； tie_load_instruction＝0； /*semanticstatements*/ t1.data＝gt_i.data&amp;0xff； t2.data＝gfmod_ps.data&amp;0xff； gfmod_ns.data＝t1.data&amp;0xff； gt_o.data＝t2.data&amp;0xff； gfmod_kill_ns.data＝(0&amp;GFRWMOD8.data)&amp;0x1；<dpn="d126"/> gt_kill_o.data＝(0&amp;GFRWMOD8.data)&amp;0x1； /*write-backinoutoperands*/ if(！gt_kill_o.data)*gt_＝gt_o.data； /*updateout/inoutstates*/ if(！gfmod_kill_ns.data)SetState(STATE_gfmod，gfmod_ns)；}gf8LGF8_I(unsignedars_，intimm8_){ /*operandvariables*/ V1_tgt_o； V1_tars_i； V1_timm8； /*unusedoperandvariables*/ /*operandkillvariables*/ V1_tgt_kill_o＝{{0}}； /*one-hotinstructionsignals*/ V1_tLGF8_I＝{{1}}； /*statevariables*/ /*localwirevariables*/ /*initializein/inoutoperands*/ ars_i＝*((V1_t*)&amp;ars_)； imm8.data＝imm8_； tie_load_instruction＝1； /*semanticstatements*/ LSSize.data＝0x1&amp;0x1f； VAddrBase.data＝ars_i.data； LSIndexed.data＝0&amp;0x1； VAddrOffset.data＝imm8.data； MemDataIn8_get()； gt_o.data＝MemDataIn8.data&amp;0xff； gt_kill_o.data＝(0&amp;LGF8_I.data)&amp;0x1； /*write-backinoutoperands*/ /*updateoutputinterfacesignals*/ /*returntheoutputoperand*/ returngt_o.data；}#defineLGF8_IU(ars，imm8)\ LGF8_IU_func(&amp;(ars)，imm8)gf8LGF8_IU_func(unsigned*ars_，intimm8_){ /*operandvariables*/ V1_tgt_o； V1_tars_o； V1_tars_i； V1_timm8； /*unusedoperandvariables*/ /*operandkillvariables*/ V1_tgt_kill_o＝{{0}}； V1_tars_kill_o＝{{0}}； /*one-hotinstructionsignals*/ V1_tLGF8_IU＝{{1}}； /*statevariables*/ /*localwirevariables*/ /*initializein/inoutoperands*/ ars_i＝*((V1_t*)ars_)；<dpn="d127"/> imm8.data＝imm8_； tie_load_instruction＝1； /*semanticstatements*/ LSSize.data＝0x1&amp;0x1f； VAddrBase.data＝ars_i.data； LSIndexed.data＝0&amp;0x1； VAddrOffset.data＝imm8.data； MemDataIn8_get()； gt_o.data＝MemDataIn8.data&amp;0xff； VAddrIn_get()； ars_o.data＝VAddrIn.data； gt_kill_o.data＝(0&amp;LGF8_IU.data)&amp;0x1； ars_kill_o.data＝(0&amp;LGF8_IU.data)&amp;0x1； /*write-backinoutoperands*/ if(！ars_kill_o.data)*ars_＝*((unsigned*)&amp;ars_o)； /*updateoutputinterfacesignals*/ /*returntheoutputoperand*/ returngt_o.data；}gf8LGF8_X(unsignedars_，unsignedart_){ /*operandvariables*/ V1_tgr_o； V1_tars_i； V1_tart_i； /*unusedoperandvariables*/ /*operandkillvariables*/ V1_tgr_kill_o＝{{0}}； /*one-hotinstructionsignals*/ V1_tLGF8_X＝{{1}}； /*statevariables*/ /*localwirevariables*/ /*initializein/inoutoperands*/ ars_i＝*((V1_t*)&amp;ars_)； art_i＝*((V1_t*)&amp;art_)； tie_load_instruction＝1； /*semanticstatements*/ LSSize.data＝0x1&amp;0x1f； VAddrBase.data＝ars_i.data； LSIndexed.data＝0x1&amp;0x1； VAddrIndex.data＝art_i.data； MemDataIn8_get()； gr_o.data＝MemDataIn8.data&amp;0xff； VAddrIn_get()； ars_o.data＝VAddrIn.data； gr_kill_o.data＝(0&amp;LGF8_X.data)&amp;0x1； /*write-backinoutoperands*/ /*updateoutputinterfacesignals*/ /*returntheoutputoperand*/ returngr_o.data；}#defineLGF8_XU(ars，art)\ LGF8_XU_func(&amp;(ars)，art)gf8LGF8_XU_func(unsigned*ars_，unsignedart_){<dpn="d128"/> /*operandvariables*/ V1_tgr_o； V1_tars_o； V1_tars_i； V1_tart_i； /*unusedoperandvariables*/ /*operandkillvariables*/ V1_tgr_kill_o＝{{0}}； V1_tars_kill_o＝{{0}}； /*one-hotinstructionsignals*/ V1_tLGF8_XU＝{{1}}； /*statevariables*/ /*localwirevariables*/ /*initializein/inoutoperands*/ ars_i＝*((V1_t*)ars_)； art_i＝*((V1_t*)&amp;art_)； tie_load_instruction＝1； /*semanticstatements*/ LSSize.data＝0x1&amp;0x1f； VAddrBase.data＝ars_i.data； LSIndexed.data＝0x1&amp;0x1； VAddrIndex.data＝art_i.data； MemDataIn8_get()； gr_o.data＝MemDataIn8.data&amp;0xff； VAddrIn_get()； ars_o.data＝VAddrIn.data； gr_kill_o.data＝(0&amp;LGF8_XU.data)&amp;0x1； ars_kill_o.data＝(0&amp;LGF8_XU.data)&amp;0x1； /*write-backinoutoperands*/ if(！ars_kill_o.data)*ars_＝*((unsigned*)&amp;ars_o)； /*updateoutputinterfacesignals*/ /*returntheoutputoperand*/ returngr_o.data；}voidSGF8_I(gf8gt_，unsignedars_，intimm8_){ /*operandvariables*/ V1_tgt_i； V1_tars_i； V1_timm8； /*unusedoperandvariables*/ /*operandkillvariables*/ /*one-hotinstructionsignals*/ /*statevariables*/ /*localwirevariables*/ /*initializein/inoutoperands*/ gt_i.data＝gt_； ars_i＝*((V1_t*)&amp;ars_)； imm8.data＝imm8_； tie_load_instruction＝0； /*semanticstatements*/ LSSize.data＝0x1&amp;0x1f； VAddrBase.data＝ars_i.data； LSIndexed.data＝0&amp;0x1； VAddrOffset.data＝imm8.data； MemDataOut8.data＝gt_i.data&amp;0xff； /*write-backinoutoperands*/ /*updateoutputinterfacesignals*/<dpn="d129"/> MemDataOut8_set()；}#defineSGF8_IU(gt，ars，imm8)\ SGF8_IU_func(gt，&amp;(ars)，imm8)voidSGF8_IU_func(gf8gt_，unsigned*ars_，intimm8_){ /*operandvariables*/ V1_tgt_i； V1_tars_o； V1_tars_i； V1_timm8； /*unusedoperandvariables*/ /*operandkillvariables*/ V1_tars_kill_o＝{{0}}； /*one-hotinstructionsignals*/ V1_tSGF8_IU＝ /*statevariables*/ /*localwirevariables*/ /*initializein/inoutoperands*/ gt_i.data＝gt_； ars_i＝*((V1_t*)ars_)； imm8.data＝imm8_； tie_load_instruction＝0； /*semanticstatements*/ LSSize.data＝0x1&amp;0x1f； VAddrBase.data＝ars_i.data； LSIndexed.data＝0&amp;0x1； VAddrOffset.data＝imm8.data； MemDataOut8.data＝gt_i.data&amp;0xff； VAddrIn_get()； ars_o.data＝VAddrIn.data； ars_kill_o.data＝(0&amp;SGF8_IU.data)&amp;0x1 /*write-backinoutoperands*/ if(！ars_kill_o.data)*ars_＝*((unsigned*)&amp;ars_o)； /*updateoutputinterfacesignals*/ MemDataOut8_set()；}voidSGF8_X(gf8gr_，unsignedars_，unsignedart_){ /*operandvariables*/ V1_tgr_i； V1_tars_i； V1_tart_i； /*unusedoperandvariables*/ /*operandkillvariables*/ /*one-hotinstructionsignals*/ /*statevariables*/ /*localwirevariables*/ /*initializein/inoutoperands*/ gr_i.data＝gr_； ars_i＝*((V1_t*)&amp;ars_)； art_i＝*((V1_t*)&amp;art_)； tie_load_instruction＝0； /*semanticstatements*/ LSSize.data＝0x1&amp;0x1f；<dpn="d130"/> VAddrBase.data＝ars_i.data； LSIndexed.data＝0x1&amp;0x1； VAddrIndex.data＝art_i.data； MemDataOut8.data＝gr_i.data&amp;0xff； /*write-backinoutoperands*/ /*updateoutputinterfacesignals*/ MemDataOut8_set()；}#defineSGF8_XU(gr，ars，art)\ SGF8_XU_func(gr，&amp;(ars)，art)voidSGF8_XU_func(gf8gr_，unsigned*ars_，unsignedart_){ /*operandvariables*/ V1_tgr_i； V1_tars_o； V1_tars_i； V1_tart_i； /*unusedoperandvariables*/ /*operandkillvariables*/ V1_tars_kill_o＝{{0}}； /*one-hotinstructionsignals*/ V1_tSGF8_XU＝{{1}}； /*statevariables*/ /*localwirevariables*/ /*initializein/inoutoperands*/ gr_i.data＝gr_； ars_i＝*((Vi_t*)ars_)； art_i＝*((V1_t*)&amp;art_)； tie_load_instruction＝0； /*semanticstatements*/ LSSize.data＝0x1&amp;0x1f； VAddrBase.data＝ars_i.data； LSIndexed.data＝0x1&amp;0x1； VAddrIndex.data＝art_i.data； MemDataOut8.data＝gr_i.data&amp;0xff； VAddrIn_get()； ars_o.data＝VAddrIn.data； ars_kill_o.data＝(0&amp;SGF8_XU.data)&amp;0x1； /*write-backinoutoperands*/ if(！ars_kill_o.data)*ars_＝*((unsigned*)&amp;ars_o)； /*updateoutputinterfacesignals*/ MemDataOut8_set()；}unsignedRUR0(){ /*operandvariables*/ V1_tarr_o； /*unusedoperandvariables*/ /*operandkillvariables*/ V1_tarr_kill_o＝{{0}}； /*one-hotinstructionsignals*/ V1_tRUR0＝{{1}}； /*statevariables*/ V1_tgfmod_ps； /*localwirevariables*/<dpn="d131"/> /*getinputstatevalues*/ GetState(gfmod_ps，STATE_gfmod)； /*initializein/inoutoperands*/ tie_load_instruction＝0； /*semanticstatements*/ arr_o.data＝gfmod_ps.data； arr_kill_o.data＝(0&amp;RUR0.data)&amp;0x1； /*write-backinoutoperands*/ /*returntheoutputoperand*/ return*((unsigned*)&amp;arr_o)；}voidWUR0(unsignedart_){ /*operandvariables*/ V1_tart_i； /*unusedoperandvariables*/ /*operandkillvariables*/ /*one-hotinstructionsignals*/ V1_tWUR0＝{{1}}； /*statevariables*/ V1_tgfmod_ns； V1_tgfmod_kill_ns； /*localwirevariables*/ V1_ttmp0； /*initializein/inoutoperands*/ art_i＝*((V1_t*)&amp;art_)； tie_load_instruction＝0； /*semanticstatements*/ tmp0.data＝((art_i.data&amp;0xff))&amp;0xff； gfmod_ns.data＝(tmp0.data)&amp;0xff； gfmod_kill_ns.data＝(0&amp;WUR0.data)&amp;0x1； /*write-backinoutoperands*/ /*updateout/inoutstates*/ if(！gfmod_kill_ns.data)SetState(STATE_gfmod，gfmod_ns)；}#definegf8_loadi(_s，o)({\ gf8t；\ gf8*s＝_s；\ gf8LGF8_I_return；\ LGF8_I_return＝LGF8_I(*((unsigned*)&amp;(s))，*((int*)&amp;(o)))；\ t＝*((gf8*)&amp;LGF8_I_return)；\ t；\})#definegf8_storei(_t，_s，o)({\ gf8t＝_t；\ gf8*s＝_s；\ SGF8_I(*((gf8*)&amp;(t))，*((unsigned*)&amp;(s))，*((int*)&amp;(o)))；\})#definegf8_move(_r，_s)({\ gf8r＝_r；\ gf8s＝_s；\ gf8GFADD8_return；\ GFADD8_return＝GFADD8(*((gf8*)&amp;(s))，*((gf8*)&amp;(0)))；\ r＝*((gf8*)&amp;GFADD8_return)；\})<dpn="d132"/>#ifdefTIE_DEBUG#undefgf8_loadi#undefgf8_storei#undefgf8_move#undefGFADD8#undefGFADD8I#undefGFMULX8#undefGFRWMOD8#undefLGF8_I#undefSGF8_I#undefLGF8_IU#undefSGF8_IU#undefLGF8_X#undefSGF8_X#undefLGF8_XU#undefSGF8_XU#undefRUR0#undefWUR0#endif#endifBR.h/**Copyright1999-2000TensilicaInc.*Thesecodedinstructions，statements，andcomputerprogramsare*ConfidentialProprietaryInformationofTensilicaInc.andmaynotbe*disclosedtothirdpartiesorcopiedinanyform，inwholeorinpart，*withoutthepriorwrittenconsentofTensilicaInc.*/#ifndefBR_HEADER#defineBR_HEADER#ifndef_XTENSA_typedefunsignedcharxtbool；typedefunsignedcharxtbool2；typedefunsignedcharxtbool4；typedefunsignedcharxtbool8；typedefunsignedshortxtbool16；xtboolXT_ANDB(xtboolbs，xtboolbt){ return0x1&amp;(bs&amp;bt)；}xtboolXT_ANDBC(xtboolbs，xtboolbt){ return0x1&amp;(bs&amp;！bt)；}xtboolXT_ORB(xtboolbs，xtboolbt){ return0x1&amp;(bs|bt)；<dpn="d133"/>}xtboolXT_ORBC(xtboolbs，xtboolbt){ return0x1&amp;(bs|！bt)；}xtboolXT_XORB(xtboolbs，xtboolbt){ return0x1&amp;(bs^bt)；}xtboolXT_ANY4(xtbool4bs4){ return(bs4&amp;0xf)！＝0；}xtboolXT_ALL4(xtbool4bs4){ return(bs4&amp;0xf)＝＝0xf；}xtboolXT_ANY8(xtbool8bs8){ return(bs8&amp;0xf)！＝0；}xtboolXT_ALL8(xtbool8bs8){ return(bs8&amp;0xf)＝＝0xf；}#endif/*_XTENSA_*/#endif/*BR_HEADER*/gf.vmodulexmTIE_gf_Regfile(rd0_data_C1，rd0_addr_C0，rd0_width8_C0，rd0_use1_C0，rd1_data_C1，rd1_addr_C0，rd1_width8_C0，rd1_use1_C0，rd2_data_C1，rd2_addr_C0，rd2_width8_C0，rd2_use1_C0，wd_addr_C0，wd_width8_C0，wd_def1_C0，wd_def2_C0，wd_data8_C1，wd_data8_C2，wd_wen_C1，wd_wen_C2，Kill_E，KillPipe_W，Stall_R，clk)； output[70]rd0_data_C1； input[30]rd0_addr_C0； inputrd0_width8_C0； inputrd0_use1_C0； output[70]rd1_data_C1； input[30]rd1_addr_C0； inputrd1_width8_C0； inputrd1_use1_C0； output[70]rd2_data_C1；<dpn="d134"/> input[30]rd2_addr_C0； inputrd2_width8_C0； inputrd2_use1_C0； input[30]wd_addr_C0； inputwd_width8_C0； inputwd_def1_C0； inputwd_def2_C0； input[70]wd_data8_C1； input[70]wd_data8_C2； inputwd_wen_C1； inputwd_wen_C2； inputKill_E； inputKillPipe_W； outputStall_R； inputclk；/*********************************************************************** READPORTrd0***********************************************************************/ //computetheaddressmask wirerd0_addr_mask_C0＝1′d0； //maskedaddresspipeline wirerd0_maddr_C0＝1′d0； //bank-qualifieduse wirerd0_use1_bank0_C0＝(rd0_use1_C0&amp;(rd0_maddr_C0＝＝(1′d0&amp;rd0_addr_mask_C0)))； //alignmentmuxforuse1 wire[70]rd0_data_bank0_C1； assignrd0_data_C1[70]＝rd0_data_bank0_C1；/*********************************************************************** READPORTrd1***********************************************************************/ //computetheaddressmask wirerd1_addr_mask_C0＝1′d0； //maskedaddresspipeline wirerd1_maddr_C0＝1′d0； //bank-qualifieduse wirerd1_use1_bank0_C0＝(rd1_use1_C0&amp;(rd1_maddr_C0＝＝(1′d0&amp;rd1_addr_mask_C0)))； //alignmentmuxforuse1 wire[70]rd1_data_bank0_C1； assignrd1_data_C1[70]＝rd1_data_bank0_C1；/*********************************************************************** READPORTrd2<dpn="d135"/>***********************************************************************/ //computetheaddressmask wirerd2_addr_mask_C0＝1′d0； //maskedaddresspipeline wirerd2_maddr_C0＝1′d0； //bank-qualifieduse wirerd2_use1_bank0_C0＝(rd2_use1_C0&amp;(rd2_maddr_C0＝＝(1′d0&amp;rd2_addr_mask_C0)))； //alignmentmuxforuse1 wire[70]rd2_data_bank0_C1； assignrd2_data_C1[70]＝rd2_data_bank0_C1；/*********************************************************************** WRITEPORTwd***********************************************************************/ //computetheaddressmask wirewd_addr_mask_C0＝1′d0； //bank-qualifiedwritedefforportwd wirewd_def1_bank0_C0＝(wd_def1_C0&amp;((wd_addr_C0&amp;wd_addr_mask_C0)＝＝(1′d0&amp;wd_addr_mask_C0)))； wirewd_def2_bank0_C0＝(wd_def2_C0&amp;((wd_addr_C0&amp;wd_addr_mask_C0)＝＝(1′d0&amp;wd_addr_mask_C0)))； //writemuxfordef1 wire[70]wd_wdata_C1； assignwd_wdata_C1＝{1{wd_data8_C1[70]}}； //writemuxfordef2 wire[70]wd_wdata_C2； assignwd_wdata_C2＝{1{wd_data8_C2[70]}}； wireStall_R0；/*********************************************************************** PIPELINEDBANK***********************************************************************/ xmTIE_gf_Regfile_bankTIE_gf_Regfile_bank0(rd0_data_bank0_C1， rd0_addr_C0[30]，rd0_use1_bank0_C0，rd1_data_bank0_C1，rd1_addr_C0[30]， rd1_use1_bank0_C0，rd2_data_bank0_C1，rd2_addr_C0[30]，rd2_use1_bank0_C0， wd_addr_C0[30]，wd_def1_bank0_C0，wd_def2_bank0_C0，wd_wdata_C1[70]， wd_wdata_C2[70]，wd_wen_C1，wd_wen_C2，Kill_E，KillPipe_W，Stall_R0， clk)； assignStall_R＝Stall_R0|1′b0；endmodule<dpn="d136"/>modulexmTIE_gf_Regfile_bank(rd0_data_C1，rd0_addr_C0，rd0_use1_C0，rd1_data_C1，rd1_addr_C0，rd1_use1_C0，rd2_data_C1，rd2_addr_C0，rd2_use1_C0，wd_addr_C0，wd_def1_C0，wd_def2_C0，wd_data_C1，wd_data_C2，wd_wen_C1，wd_wenC2，Kill_E，KillPipe_W，Stall_R，clk)； output[70]rdo_data_C1； input[30]rd0_addr_C0； inputrd0_use1_C0； output[70]rd1_data_C1； input[30]rd1_addr_C0； inputrd1_use1_C0； output[70]rd2_data_C1； input[30]rd2_addr_C0； inputrd2_use1_C0； input[30]wd_addr_C0； inputwd_def1_C0； inputwd_def2_C0； input[70]wd_data_C1； input[70]wd_data_C2； inputwd_wen_C1； inputwd_wen_C2； inputKill_E； inputKillPipe_W； outputStall_R； inputclk； wirerd0_use2_C0＝1′d0； wirerd1_use2_C0＝1′d0； wirerd2_use2_C0＝1′d0； wirekill_C0＝KillPipe_W； wirekill_C1＝KillPipe_W|Kill_E； wirekill_C2＝KillPipe_W； wirekill_C3＝KillPipe_W； //writedefinitionpipeline wirewd_ns_def1_C0＝wd_def1_C0&amp;1′b1&amp;-kill_C0； wirewd_def1_C1； xtdelay1#(1)iwd_def1_C1(wd_def1_C1，wd_ns_def1_C0，clk)； wirewd_ns_def2_C0＝wd_def2_C0&amp;1′b1&amp;-kill_C0； wirewd_def2_C1； xtdelay1#(1)iwd_def2_C1(wd_def2_C1，wd_ns_def2_C0，clk)； wirewd_ns_def2_C1＝wd_def2_C1&amp;wd_wen_C1&amp;-kill_C1； wirewd_def2_C2； xtdelay1#(1)iwd_def2_C2(wd_def2_C2，wd_ns_def2_C1，clk)； //writeenablepipeline wirewd_we_C2； wirewd_we_C3； wirewd_ns_we_C1＝(1′d0|(wd_def1_C1&amp;wd_wen_C1))&amp;-kill_C1； wirewd_ns_we_C2＝(wd_we_C2|(wd_def2_C2&amp;wd_wen_C2))&amp;-kill_C2； wirewd_ns_we_C3＝(wd_we_C3|(1′d0&amp;1′d0))&amp;-kill_C3； xtdelay1#(1)iwd_we_C2(wd_we_C2，wd_ns_we_C1，clk)； xtdelay1#(1)iwd_we_C3(wd_we_C3，wd_ns_we_C2，clk)； //writeaddresspipeline wire[30]wd_addr_C1； wire[30]wd_addr_C2； wire[30]wd_addr_C3；<dpn="d137"/> xtdelay1#(4)iwd_addr_C1(wd_addr_C1，wd_addr_C0，clk)； xtdelay1#(4)iwd_addr_C2(wd_addr_C2，wd_addr_C1，clk)； xtdelay1#(4)iwd_addr_C3(wd_addr_C3，wd_addr_C2，clk)； //writedatapipeline wire[70]wd_result_C2； wire[70]wd_result_C3； wire[70]wd_mux_C1＝wd_data_C1； wire[70]wd_mux_C2＝wd_def2_C2？wd_data_C2wd_result_C2； xtdelay1#(8)iwd_result_C2(wd_result_C2，wd_mux_C1，clk)； xtdelay1#(8)iwd_result_C3(wd_result_C3，wd_mux_C2，clk)； wire[70]rd0_data_C0； wire[70]rd1_data_C0； wire[70]rd2_data_C0； //Readbypasscontrolsforportrd0 wirebypass_data_rd0_C0_wd_C1＝(wd_addr_C1＝＝rd0_addr_C0)&amp;wd_def1_C1&amp;wd_wen_C1&amp;-kill_C1； wirebypass_data_rd0_C0_wd_C2＝(wd_addr_C2＝＝rd0_addr_C0)&amp;wd_def2_C2&amp;wd_wen_C2&amp;-kill_C2； wirebypass_result_rd0_C0_wd_C2＝(wd_addr_C2＝＝rd0_addr_C0)&amp;wd_we_C2&amp;-kill_C2； wirebypass_result_rd0_C0_wd_C3＝(wd_addr_C3＝＝rd0_addr_C0)&amp;wd_we_C3&amp;-kill_C3； //Readbypassforportrd0use1 wire[70]rd0_mux_result_C0； xtmux3p#(8)m0(rd0_mux_result_C0，wd_result_C2，wd_result_C3，rd0_data_C0，bypass_result_rd0_C0_wd_C2，bypass_result_rd0_C0_wd_C3)； wire[70]rd0_mux_C0； wire[10]rd0_mux_C0_sel＝ bypass_data_rd0_C0_wd_C1？2′d1 bypass_data_rd0_C0_wd_C2？2′d2 bypass_result_rd0_C0_wd_C2？2′d0 bypass_result_rd0_C0_wd_C3？2′d0 2′d0； xtmux3e#(8)m1(rd0_mux_C0，rd0_mux_result_C0，wd_data_C1，wd_data_C2，rd0_mux_C0_sel)； xtdelay1#(8)ird0_data_C1(rd0_data_C1，rd0_mux_C0，clk)； //Readbypasscontrolsforportrd1 wirebypass_data_rd1_C0_wd_C1＝(wd_addr_C1＝＝rd1_addr_C0)&amp;wd_def1_C1&amp;wd_wen_C1&amp;-kill_C1； wirebypass_data_rd1_C0_wd_C2＝(wd_addr_C2＝＝rd1_addr_C0)&amp;wd_def2_C2&amp;wd_wen_C2&amp;-kill_C2；wirebypass_result_rd1_C0_wd_C2＝(wd_addr_C2＝＝rd1_addr_C0)&amp;wd_we_C2&amp;-kill_C2； wirebypass_result_rd1_C0_wd_C3＝(wd_addr_C3＝＝rd1_addr_C0)&amp;wd_we_C3&amp;-kill_C3； //Readbypassforportrd1use1 wire[70]rd1_mux_result_C0； xtmux3p#(8)m2(rd1_mux_result_C0，wd_result_C2，wd_result_C3，rd1_data_C0，bypass_result_rd1_C0_wd_C2，bypass_result_rd1_C0_wd_C3)； wire[70]rd1_mux_C0； wire[10]rd1_mux_C0_sel＝ bypass_data_rd1_C0_wd_C1？2′d1 bypass_data_rd1_C0_wd_C2？2′d2 bypass_result_rd1_C0_wd_C2？2′d0<dpn="d138"/> bypass_result_rd1_C0_wd_C3？2′d0 2′d0； xtmux3e#(8)m3(rd1_mux_C0，rd1_mux_result_C0，wd_data_C1，wd_data_C2，rd1_mux_C0_sel)； xtdelay1#(8)ird1_data_C1(rd1_data_C1，rd1_mux_C0，clk)； //Readbypasscontrolsforportrd2 wirebypass_data_rd2_C0_wd_C1＝(wd_addr_C1＝＝rd2_addr_C0)&amp;wd_def1_C1&amp;wd_wen_C1&amp;-kill_C1； wirebypass_data_rd2_C0_wd_C2＝(wd_addr_C2＝＝rd2_addr_C0)&amp;wd_def2_C2&amp;wd_wen_C2&amp;-kill_C2； wirebypass_result_rd2_C0_wd_C2＝(wd_addr_C2＝＝rd2_addr_C0)&amp;wd_we_C2&amp;-kill_C2； wirebypass_result_rd2_C0_wd_C3＝(wd_addr_C3＝＝rd2_addr_C0)&amp;wd_we_C3&amp;-kill_C3； //Readbypassforportrd2use1 wire[70]rd2_mux_result_C0； xtmux3p#(8)m4(rd2_mux_result_C0，wd_result_C2，wd_result_C3，rd2_data_C0，bypass_result_rd2_C0_wd_C2，bypass_result_rd2_C0_wd_C3)； wire[70]rd2_mux_C0； wire[10]rd2_mux_C0_sel＝ bypass_data_rd2_C0_wd_C1？2′d1 bypass_data_rd2_C0_wd_C2？2′d2 bypass_result_rd2_C0_wd_C2？2′d0 bypass_result_rd2_C0_wd_C3？2′d0 2′d0； xtmux3e#(8)m5(rd2_mux_C0，rd2_mux_result_C0，wd_data_C1，wd_data_C2，rd2_mux_C0_sel)； xtdelayl#(8)ird2_data_C1(rd2_tata_C1，rd2_mux_C0，clk)； assignStallR＝ ((wd_addr_C1＝＝rd0_addr_C0)&amp;( (rd0_use1_C0&amp;(wd_ns_def2_C1))))| ((wd_addr_C1＝＝rd1_addr_C0)&amp;( (rd1_use1_C0&amp;(wd_ns_def2_C1))))| ((wd_addr_C1＝＝rd2_addr_C0)&amp;( (rd2_use1_C0&amp;(wd_ns_def2_C1))))| 1′b0； //registerfilecore xtregfile_3R1W_16#(8)icore(rd0_data_C0，rd0_addr_C0，rd1_data_C0， rd1_addr_C0，rd2_data_C0，rd2_addr_C0，wd_result_C3，wd_addr_C3， wd_ns_we_C3，clk)；endmodulemodulexmTIE_gfmod_State(ps_data_C1，ps_width8_C0，ps_use1_C0，ns_width8_C0，ns_def1_C0，ns_data8_C1，ns_wen_C1，Kill_E，KillPipe_W，Stall_R，clk)； output[70]ps_data_C1； inputps_width8_C0； inputps_use1_C0； inputns_width8_C0； inputns_def1_C0； input[70]ns_data8_C1； inputns_wen_C1； inputKill_E； inputKillPipe_W； outputStall_R；<dpn="d139"/> inputclk； wireps_addr_C0＝1′d0； wirens_addr_C0＝1′d0； wirens_wen_C2＝1′d1；/*********************************************************************** READPORTps***********************************************************************/ //computetheaddressmask wireps_addr_mask_C0＝1′d0； //maskedaddresspipeline wireps_maddr_C0＝1′d0； //bank-qualifieduse wireps_use1_bank0_C0＝(ps_use1_C0&amp;(ps_maddr_C0＝＝(1′d0&amp;ps_addr_mask_C0)))； //alignmentmuxforuse1 wire[70]ps_databank0_C1； assignps_data_C1[70]＝ps_data_bank0_C1；/*********************************************************************** WRITEPORTns***********************************************************************/ //computetheaddressmask wirens_addr_mask_C0＝1′d0； //bank-qualifiedwritedefforportns wirens_def1_bank0_C0＝(ns_def1_C0&amp;((ns_addr_C0&amp;ns_addrmask_C0)＝＝(1′d0&amp;ns_addr_mask_C0)))； //writemuxfordef1 wire[70]ns_wdata_C1； assignns_wdata_C1＝{1{ns_data8_C1[70]}}； wireStall_R0；/*********************************************************************** PIPELINEDBANK***********************************************************************/ xmTIE_gfmod_State_bankTIE_gfmod_State_bank0(ps_data_bank0_C1， ps_use1_bank0_C0，ns_def1_bank0_C0，ns_wdata_C1[70]，ns_wen_C1， ns_wen_C2，Kill_E，KillPipe_W，Stall_R0，clk)； assignStall_R＝Stall_R0|1′b0；endmodulemodulexmTIE_gfmod_State_bank(ps_data_C1，ps_use1_C0，ns_def1_C0，ns_data_C1，<dpn="d140"/>ns_wen_C1，ns_wen_C2，Kill_E，KillPipe_W，Stall_R，clk)；output[70]ps_data_C1；inputps_use1_C0；inputns_def1_C0；input[70]ns_data_C1；inputns_wen_C1；inputns_wen_C2；inputKill_E7inputKillPipe_W；outputStall_R；inputclk；wireps_addr_C0＝1′d0；wireps_use2_C0＝1′d0；wirens_addr_C0＝1′d0；wirens_def2_C0＝1′d0；wire[70]ns_data_C2＝0；wirekill_C0＝KillPipe_W；wirekill_C1＝KillPipe_W|Kill_E；wirekill_C2＝KillPipe_W；wirekill_C3＝KillPipe_W；//writedefinitionpipelinewirens_ns_def1_C0＝ns_def1_C0&amp;1′b1&amp;-kill_C0；wirens_def1_C1；xtdelay1#(1)ins_def1_C1(ns_def1_C1，nsnsdef1_C0，clk)；wirens_ns_def2_C0＝1′d0；wirens_def2_C1＝1′d0；wirens_ns_def2_C1＝1′d0；wirens_def2_C2＝1′d0；//writeenablepipelinewirens_we_C2；wirens_we_C3；wirens_ns_we_C1＝(1′d0|(ns_def1_C1&amp;ns_wen_C1))&amp;-kill_C1；wirens_ns_we_C2＝(ns_we_C2|(ns_def2_C2&amp;ns_wen_C2))&amp;-kill_C2；wirens_ns_we_C3＝(ns_we_C3|(1′d0&amp;1′d0))&amp;-kill_C3；xtdelay1#(1)ins_we_C2(ns_we_C2，ns_ns_we_C1，clk)；xtdelay1#(1)ins_we_C3(ns_we_C3，ns_ns_we_C2，clk)；//writeaddresspipelinewirens_addr_C1；wirens_addr_C2；wirens_addr_C3；assignns_addr_C1＝1′d0；assignns_addr_C2＝1′d0；assignns_addr_C3＝1′d0；//writedatapipelinewire[70]ns_result_C2；wire[70]ns_result_C3；wire[70]ns_mux_C1＝ns_data_C1；wire[70]ns_mux_C2＝ns_def2_C2？ns_data_C2ns_result_C2；xtdelay1#(8)ins_result_C2(ns_result_C2，ns_mux_C1，clk)；xtdelay1#(8)ins_result_C3(ns_result_C3，ns_mux_C2，clk)；wire[70]ps_data_C0；//Readbypasscontrolsforportps<dpn="d141"/> wirebypass_data_ps_C0_ns_C1＝(ns_addr_C1＝＝ps_addr_C0)&amp;ns_def1_C1&amp;ns_wen_C1&amp;-kill_C1； wirebypass_result_ps_C0_ns_C2＝(ns_addr_C2＝＝ps_addr_C0)&amp;ns_we_C2&amp;-kill_C2； wirebypass_result_ps_C0_ns_C3＝(ns_addr_C3＝＝ps_addr_C0)&amp;ns_we_C3&amp; -kill_C3； //Readbypassforportpsuse1 wire[70]ps_mux_result_C0； xtmux3p#(8)m6(ps_mux_result_C0，ns_result_C2，ns_result_C3，ps_data_C0，bypass_result_ps_C0_ns_C2，bypass_result_ps_C0_ns_C3)； wire[70]ps_mux_C0； wireps_mux_C0_sel＝ bypass_data_ps_C0_ns_C1？1′d1 bypass_result_ps_C0_ns_C2？1′d0 bypass_result_ps_C0_ns_C3？1′d0 1′d0； xtmux2e#(8)m7(ps_mux_C0，ps_mux_result_C0，ns_data_C1，ps_mux_C0_sel)； xtdelay1#(8)ips_data_C1(ps_data_C1，ps_mux_C0，clk)； assignStall_R＝ ((ns_addr_C1＝＝ps_addr_C0)&amp;( (ps_use1_C0&amp;(ns_ns_def2_C1))))| 1′b0； //registerfilecore xtregfile_1R1W_1#(8)icore(ps_data_C0，ns_result_C3，ns_ns_we_C3，clk)；endmodulemodulexmTIE_decoder(FADD8，GFADD8I，GFMULX8，GFRWMOD8，LGF8_I，SGF8_I，LGF8_IU，SGF8_IU，LGF8_X，SGF8_X，LGF8_XU，SGF8_XU，RUR0，WUR0，imm4，imm8，art_use，art_def，ars_use，ars_def，arr_use，arr_def，br_use，br_def，bs_use，bs_def，bt_use，<dpn="d142"/>bt_def，bs4_use，bs4_def，bs8_use，bs8_def，gr_use，gr_def，gs_use，gs_def，gt_use，gt_def，gfmod_use1，gfmod_def1，AR_rd0_use1，AR_rd0_width32，AR_rd1_use1，AR_rd1_width32，AR_wd_def1，AR_wd_width32，gf_rd0_addr，gf_rd0_use1，gf_rd0_width8，gf_rd1_addr，gf_rd1_use1，gf_rd1_width8，gf_rd2_addr，gf_rd2_use1，gf_rd2_width8，gf_wd_addr，gf_wd_def2，gf_wd_def1，gf_wd_width8，gf1_semantic，gf4_semantic，gf2_semantic，gf3_semantic，lgf_semantic，sgf_semantic，RUR0_semantic，WUR0_semantic，load_instruction，store_instruction，TIE_Inst，Inst)；outputGFADD8；outputGFADD8I；outputGFMULX8；outputGFRWMOD8；outputLGF8_I；outputSGF8_I；outputLGF8_IU；outputSGF8_IU；outputLGF8_X；outputSGF8_X；outputLGF8_XU；outputSGF8_XU；outputRUR0；outputWUR0；output[310]imm4；<dpn="d143"/>output[70]imm8；outputart_use；outputart_def；outputars_use；outputars_def；outputarr_use；outputarr_def；outputbr_use；outputbr_def；outputbs_use；outputbs_def；outputbt_use；outputbt_def；outputbs4_use；outputbs4_def；outputbs8_use；outputbs8_def；outputgr_use；outputgr_def；outputgs_use；outputgs_def；outputgt_use；outputgt_def；outputgfmod_use1；outputgfmod_def1；outputAR_rd0_use1；outputAR_rd0_width32；outputAR_rd1_use1；outputAR_rd1_width32；outputAR_wd_def1；outputAR_wd_width32；output[30]gf_rd0_addr；outputgf_rd0_use1；outputgf_rd0_width8；output[30]gf_rd1_addr；outputgf_rd1_use1；outputgf_rd1_width8；output[30]gf_rd2_addr；outputgf_rd2_use1；outputgf_rd2_width8；output[30]gf_wd_addr；outputgf_wd_def2；outputgf_wd_def1；outputgf_wd_width8；outputgf1_semantic；outputgf4_semantic；outputgf2_semantic；outputgf3_semantic；outputlgf_semantic；outputsgf_semantic；outputRUR0_semantic；outputWUR0_semantic；outputload_instruction；outputstore_instruction；outputTIE_Inst；input[230]Inst；wire[30]op2＝{Inst[2320]}；wire[30]op1＝{Inst[1916]}；wire[30]op0＝{Inst[30]}；<dpn="d144"/>wireQRST＝(op0＝＝4′b0000)；wireCUST0＝(op1＝＝4′b0110)&amp;QRST；assignGFADD8＝(op2＝＝4′b0000)&amp;CUST0；assignGFADD8I＝(op2＝＝4′b0100)&amp;CUST0；assignGFMULX8＝(op2＝＝4′b0001)&amp;CUST0；assignGFRWMOD8＝(op2＝＝4′b0010)&amp;CUST0；wire[30]r＝{Inst[1512]}；wireLSCI＝(op0＝＝4′b0011)；assignLGF8_I＝(r＝＝4′b0000)&amp;LSCI；assignSGF8_I＝(r＝＝4′b0001)&amp;LSCI；assignLGF8_IU＝(r＝＝4′b0010)&amp;LSCI；assignSGF8_IU＝(r＝＝4′b0011)&amp;LSCI；wireLSCX＝(op1＝＝4′b1000)&amp;QRST；assignLGF8_X＝(op2＝＝4′b0000)&amp;LSCX；assignSGF8_X＝(op2＝＝4′b0001)&amp;LSCX；assignLGF8_XU＝(op2＝＝4′b0010)&amp;LSCX；assignSGF8_XU＝(op2＝＝4′b0011)&amp;ISCX；wire[30]s＝{Inst[118]}；wire[30]t＝{Inst[74]}；wire[70]st＝{s，t}；wireRST3＝(op1＝＝4′b0011)&amp;QRST；wireRUR＝(op2＝＝4′b1110)&amp;RST3；assignRUR0＝(st＝＝8′b00000000)&amp;RUR；wire[70]sr＝{r，s}；wireWUR＝(op2＝＝4′b1111)&amp;RST3；assignWUR0＝(sr＝＝8′b00000000)&amp;WUR；assigngfmod_use1＝GFMULX8|GFRWMOD8|RUR0|1′b0；assigngfmod_def1＝GFRWMOD8|WUR0|1′b0；assignAR_rd0_use1＝1′b0 |LGF8_I |SGF8_I |LGF8_IU |SGF8_IU |LGF8_X |SGF8_X |LGF8_XU |SGF8_XU；assignAR_rd0_width32＝1′b0；assignAR_rd1_use1＝1′b0 |LGF8_X |SGF8_x |GF8_XU |SGF8_XU |WUR0；assignAR_rd1_width32＝1′b0；assignAR_wd_def1＝1′b0 |LGF8_IU |SGF8_IU |LGF8_XU |SGF8_XU |RUR0；assignAR_wd_width32＝1′b0；assigngf_rd0_use1＝1′b0 |GFADD8 |GFADD8I |GFMULX8；assigngf_rd0_width8＝1′b0；assigngf_rd1_use1＝1′b0 |GFADD8 |GFRWMOD8<dpn="d145"/> |SGF8_I |SGF8_IU；assigngf_rd1_width8＝1′b0；assigngf_rd2_use1＝1′b0 |SGF8_X |SGF8_XU；assigngf_rd2_width8＝1′b0；assigngf_wd_def2＝1′b0 |LGF8_I |LGF8_IU |LGF8_X |LGF8_XU；assigngf_wd_def1＝1′b0 |GFADD8 |GFADD8I |GFMULX8 |GFRWMOD8；assigngf_wd_width8＝1′b0；assignart_def＝1′b0；assignart_use＝LGF8_X|SGF8_X|LGF8_XU|SGF8_XU|WUR0|1′b0；assignars_def＝LGF8_IU|SGF8_IU|LGF8_XU|SGF8_XU|1′b0；assignars_use＝LGF8_I|SGF8_I|LGF8_IU|SGF8_IU|LGF8_X|SGF8_X|LGF8_XU|SGF8_XU|1′b0；assignarr_def＝RUR0|1′b0；assignarr_use＝1′b0；assignbr_def＝1′b0；assignbr_use＝1′b0；assignbs_def＝1′b0；assignbs_use＝1′b0；assignbt_def＝1′b0；assignbt_use＝1′b0；assignbs4_def＝1′b0；assignbs4_use＝1′b0；assignbs8_def＝1′b0；assignbs8_use＝1′b0；assigngr_def＝GFADD8|GFADD8I|GFMULX8|LGF8_X|LGF8XU|1′b0；assigngr_use＝SGF8_X|SGF8_XU|1′b0；assigngs_def＝1′b0；assigngs_use＝GFADD8|GFADD8I|GFMULX8|1′b0；assigngt_def＝GFRWMOD8|LGF8_I|LGF8_IU|1′b0；assigngt_use＝GFADD8|GFRWMOS8|SGF8_I|SGF8_IU|1′b0；wire[30]gr_addr＝r；wire[30]gs_addr＝s；wire[30]gt_addr＝t；assigngf_wd_addr＝4′b0 |{4{gr_def}}&amp;gr_addr |{4{gt_def}}&amp;gt_addr；assigngf_rd0_addr＝gs_addr；assigngf_rd1_addr＝gt_addr；assigngf_rd2_addr＝gr_addr；assigngf1_semantic＝GFADD8|1′b0；assigngf4_semantic＝GFADD8I|1′b0；assigngf2_semantic＝GFMULX8|1′b0；assigngf3_semantic＝GFRWMOD8|1′b0；assignIgf_semantic＝LGF8_I|LGF8_IU|LGF8_X|LGF8_XU|1′b0；assignsgf_semantic＝SGF8_I|SGF8_IU|SGF8_X|SGF8_XU|1′b0；assignRUR0_semantic＝RUR0|1′b0；assignWUR0_semantic＝WUR0|1′b0；assignimm4＝t；wire[70]imm8＝{Inst[236]}；<dpn="d146"/>assignloadinstruction＝1′b0 |LGF8_I |LGF8_IU |LGF8_X |LGF8_XU；assignstore_instruction＝1′b0 |SGF8_I |SGF8_IU |SGF8_XassignTIE_Inst＝1′b0 |GFADD8 |GFADD8I |GFMULX8 |GFRWMOD8 |LGF8_I |SGF8_I |LGF8_IU |SGF8_IU |LGF8_X |SGF8_X |LGF8_XU |SGF8_XU |RUR0 |WUR0；endmodulemoduulexmTIE_gf1(GFADD8_C0，gr_o_C1，gr_kill_C1，gs_i_C1，gt_i_C1，clk)；inputGFADD8_C0；output[70]gr_o_C1；outputgr_kill_C1；input[70]gs_i_C1；input[70]gt_i_C1；inputclk；assigngr_o_C1＝(gs_i_C1)^(gt_i_C1)；wireGFADD8_C1；xtdelay1#(1)iGFADD8C1(.xtin(GFADD8_C0)，.xtout(GFADD8_C1)，.clk(clk))；assigngr_kill_C1＝(1′b0)&amp;(GFADD8_C1)；endmodulemodulexmTIE_gf4(GFADD8I_C0，gr_o_C1，gr_kill_C1，gs_i_C1，imm4_C0，clk)；inputGFADD8I_C0；output[70]gr_o_C1；outputgr_kill_C1；input[70]gs_i_C1；input[310]imm4_C0；<dpn="d147"/>inputclk；wire[310]imm4_C1；xtdelay1#(32)iimm4_C1(.xtin(imm4_C0)，.xtout(imm4_C1)，.clk(clk))；assigngr_o_C1＝(gs_i_C1)^(imm4_C1)；wireGFADD8I_C1；xtdelay1#(1)iGFADD8I_C1(.xtin(GFADD8I_C0)，.xtout(GFADD8I_C1)，.clk(clk))；assigngr_kill_C1＝(1′b0)&amp;(GFADD8I_C1)；endmodulemodulexmTIE_gf2(GFMULX8_C0，gr_o_C1，gr_kill_C1，gs_i_C1，gfmod_ps_C1，clk)；inputGFMULX8_C0；output[70]gr_o_C1；outputgr_kill_C1；input[70]gs_i_C1；input[70]gfmod_ps_C1；inputclk；assigngr_o_C1＝(gs_i_C1[7])？(({gs_i_C1[60]，1′b0})^(gfmod_ps_C1))({gs_i_C1[60]，1′b0})；wireGFMULX8_C1；xtdelay1#(1)iGFMULX8_C1(.xtin(GFMULX8_C0)，.xtout(GFMULX8_C1)，.clk(clk))；assigngr_kill_C1＝(1′b0)&amp;(GFMULX8_C1)；endmodulemodulexmTIE_gf3(GFRWMOD8_C0，gt_i_C1，gt_o_C1，gt_kill_C1，gfmod_ps_C1，gfmod_ns_C1，gfmod_kill_C1，clk)；inputGFRWMOD8_C0；input[70]gt_i_C1；output[70]gt_o_C1；outputgt_kill_C1；input[70]gfmod_ps_C1；output[70]gfmod_ns_C1；outputgfmod_kill_C1；inputclk；wire[70]t1_C1；assignt1_C1＝gt_i_C1；wire[70]t2_C1；assignt2_C1＝gfmod_ps_C1；assigngfmod_ns_C1＝t1_C1；assigngt_o_C1＝t2_C1；wireGFRWMOD8_C1；xtdelay1#(1)iGFRWMOD8_C1(.xtin(GFRWMOD8_C0)，.xtout(GFRWMOD8_C1)，.clk(clk))；assigngfmod_kill_C1＝(1′b0)&amp;(GFRWMOD8_C1)；<dpn="d148"/>assigngt_kill_C1＝(1′b0)&amp;(GFRWMOD8_C1)；endmodulemodulexmTIE_lgf(LGF8_I_C0，LGF8_IU_C0，LGF8_X_C0，LGF8_XU_C0，gt_o_C2，gt_kill_C2，ars_i_C1，ars_o_C1，ars_kill_C1，imm8_C0，gr_o_C2，gr_kill_C2，art_i_C1，MemDataIn8_C2，VAddrIn_C1，LSSize_C0，VAddrBase_C1，VAddrIndex_C1，VAddrOffset_C0，LSIndexed_C0，clk)；inputLGF8_I_C0；inputLGF8_IU_C0；inputLGF8_X_C0；inputLGF8_XU_C0；output[70]gt_o_C2；outputgt_kill_C2；input[310]ars_i_C1；output[310]ars_o_C1；outputars_kill_C1；input[70]imm8_C0；output[70]gr_o_C2；outputgr_kill_C2；input[310]art_i_C1；input[70]MemDataIn8_C2；input[310]VAddrIn_C1；output[40]LSSize_C0；output[310]VAddrBase_C1；output[310]VAddrIndex_C1；output[310]VAddrOffset_C0；outputLSIndexed_C0；inputclk；wireindexed_C0；assignindexed_C0＝(LGF8_X_C0)|(LGF8_XU_C0)；assignLSSize_C0＝32′h1；assignVAddrBase_C1＝ars_i_C1；assignLSIndexed_C0＝indexed_C0；assignVAddrOffset_C0＝imm8_C0；assignVAddrIndex_C1＝art_i_C1；assigngt_o_C2＝MemDataIn8_C2；assigngr_o_C2＝MemDataIn8_C2；assignars_o_C1＝VAddrIn_C1；wireLGF8_I_C2；xtdelay2#(1)iLGF8_I_C2(.xtin(LGF8_I_C0)，.xtout(LGF8_I_C2)，.clk(clk))；wireLGF8_IU_C2；<dpn="d149"/>xtdelay2#(1)iLGF8_IU_C2(.xtin(LGF8_IU_C0)，.xtout(LGF8_IU_C2).clk(clk))；assigngt_kill_C2＝(1′b0)&amp;((LGF8_I_C2)|(LGF8_IU_C2))；wireLGF8_IU_C1；xtdelay1#(1)iLGF8_IU_C1(.xtin(LGF8_IU_C0)，.xtout(LGF8_IU_C1).clk(clk))；wireLGF8_XU_C1；xtdelay1#(1)iLGF8_XU_C1(.xtin(LGF8_XU_C0)，.xtout(LGF8_XU_C1).clk(clk))；assignars_kill_C1＝(1′b0)&amp;((LGF8_IU_C1)|(LGF8_XU_C1))；wireLGF8_X_C2；xtdelay2#(1)iLGF8_X_C2(.xtin(LGF8_X_C0)，.xtout(LGF8_X_C2)，.clk(clk))；wireLGF8_XU_C2；xtdelay2#(1)iLGF8_XU_C2(.xtin(LGF8_XU_C0)，.xtout(LGF8_XU_C2)，.clk(clk))；assigngr_kill_C2＝(1′b0)&amp;((LGF8_X_C2)|(LGF8_XU_C2))；endmodulemodulexmTIE_sgf(SGF8_I_C0，SGF8_IU_C0，SGF8_X_C0，SGF8_XU_C0，gt_i_C1，ars_i_C1，ars_o_C1，ars_kill_C1，imm8_C0，gr_i_C1，art_i_C1，VAddrIn_C1，LSSize_C0，MemDataOut8_C1，VAddrBase_C1，VAddrIndex_C1，VAddrOffset_C0，LSIndexed_C0，clk)；inputSGF8_I_C0；inputSGF8_IU_C0；inputSGF8_X_C0；inputSGF8_XU_C0；input[70]gt_i_C1；input[310]ars_i_C1；output[310]ars_o_C1；outputars_kill_C1；input[70]imm8_C0；input[70]gr_i_C1；input[310]art_i_C1；input[310]VAddrIn_C1；output[40]LSSize_C0；output[70]MemDataOut8_C1；output[310]VAddrBase_C1；output[310]VAddrIndex_C1；output[310]VAddrOffset_C0；outputLSIndexed_C0；inputclk；wireindexed_C0；assignindexed_C0＝(SGF8_X_C0)|(SGF8_XU_C0)；<dpn="d150"/>assignLSSize_C0＝32′h1；assignVAddrBase_C1＝ars_i_C1；assignLSIndexed_C0＝indexed_C0；assignVAddrOffset_C0＝imm8_C0；assignVAddrIndex_C1＝art_i_C1；wireSGF8_X_C1；xtdelay1#(1)iSGF8_X_C1(.xtin(SGF8_X_C0)，.xtout(SGF8_X_C1)，.clk(clk))；wireSGF8_XU_C1；xtdelay1#(1)iSGF8_XU_C1(.xtin(SGF8_XU_C0)，.xtout(SGF8_XU_C1)，.clk(clk))；assignMemDataOut8_C1＝((SGF8_X_C1)|(SGF8_XU_C1))？(gr_i_C1)，(gt_i_C1)；assignars_o_C1＝VAddrIn_C1；wireSGF8_IU_C1；xtdelay1#(1)iSGF8_IU_C1(.xtin(SGF8_IU_C0)，.xtout(SGF8_IU_C1)，.clk(clk))；assignars_kill_C1＝(1′b0)&amp;((SGF8_IU_C1)|(SGF8_XU_C1))；endmodulemodulexmTIE_RUR0(RUR0_C0，arr_o_C1，arr_kill_C1，gfmod_ps_C1，clk)；inputRUR0_C0；output[310]arr_o_C1；outputarr_kill_C1；input[70]gfmod_ps_C1；inputclk；assignarr_o_C1＝{gfmod_ps_C1}；wireRUR0_C1；xtdelay1#(1)iRUR0_C1(.xtin(RUR0_C0)，.xtout(RUR0_C1)，.clk(clk))；assignarr_kill_C1＝(1′b0)&amp;(RUR0_C1)；endmodulemodulexmTIE_WUR0(WUR0_C0，art_i_C1，gfmod_ns_C1，gfmod_kill_C1，clk)；inputWUR0_C0；input[310]art_i_C1；output[70]gfmod_ns_C1；outputgfmod_kill_C1；inputclk；assigngfmod_ns_C1＝{art_i_C1[70]}；wireWUR0_C1；xtdelay1#(1)iWUR0_C1(.xtin(WUR0_C0)，.xtout(WUR0_C1)，.clk(clk))；assigngfmod_kill_C1＝(1′b0)&amp;(WUR0C1)；endmodulemodulexmTIE(TIE_inst_R，TIE_asRead_R，TIE_atRead_R，TIE_atWrite_R，<dpn="d151"/>TIE_arWrite_R，TIE_asWrite_R，TIE_aWriteM_R，TIE_aDataKill_E，TIE_aWriteData_E，TIE_aDataKill_M，TIE_aWriteData_M，TIE_Load_R，TIE_Store_R，TIE_LSSize_R，TIE_LSIndexed_R，TIE_LSOffset_R，TIE_MemLoadData_M，TIE_MemStoreData8_E，TIE_MemStoreData16_E，TIE_MemStoreData32_E，TIE_MemStoreData64_E，TIE_MemStoreData128_E，TIE_Stall_R，TIE_Exception_E，TIE_ExcCause_E，TIE_bsRead_R，TIE_btRead_R，TIE_btWrite_R，TIE_brWrite_R，TIE_bsWrite_R，TIE_bsReadSize_R，TIE_btReadSize_R，TIE_bWriteSize_R，TIE_bsReadData_E，TIE_btReadData_E，TIE_bWriteData1_E，TIE_bWriteData2_E，TIE_bWriteData4_E，TIE_bWriteData8_E，TIE_bWriteData16_E，TIE_bDataKill_E，CPEnable，Instr_R，SBus_E，TBus_E，MemOpAddr_E，Kill_E，Except_W，Replay_W，G1WCLK，Reset)；outputTIE_inst_R；outputTIE_asRead_R；outputTIE_atRead_R；outputTIE_atWrite_R；outputTIE_arWrite_R；outputTIE_asWrite_R；outputTIE_aWriteM_R；outputTIE_aDataKill_E；output[310]TIE_aWriteData_E；outputTIE_aDataKill_M；output[310]TIE_aWriteData_M；outputTIE_Load_R；<dpn="d152"/>outputTIE_Store_R；output[40]TIE_LSSize_R；outputTIE_LSIndexed_R；output[310]TIE_LSOffset_R；input[1270]TIE_MemLoadData_M；output[70]TIE_MemStoreData8_E；output[150]TIE_MemStoreData16_E；output[310]TIE_MemStoreData32_E；output[630]TIE_MemStoreData64_E；output[1270]TIE_MemStoreData128_E；outputTIE_Stall_R；outputTIE_Exception_E；output[50]TIE_ExcCause_E；outputTIE_bsRead_R；outputTIE_btRead_R；outputTIE_btWrite_R；outputTIE_brWrite_R；outputTIEbsWrite_R；output[40]TIE_bsReadSize_R；output[40]TIE_btReadSize_R；output[40]TIE_bWriteSize_R；input[150]TIE_bsReadData_E；input[150]TIE_btReadData_E；outputTIE_bWriteData1_E；output[10]TIE_bWriteData2_E；output[30]TIE_bWriteData4_E；output[70]TIE_bWriteData8_E；output[150]TIE_bWriteData16_E；outputTIE_bDataKill_E；input[70]CPEnable；input[230]Instr_R；input[310]SBus_E；input[310]TBus_E；input[310]MemOpAddr_E；inputKill_E；inputExcept_W；inputReplay_W；inputG1WCLK；inputReset；//unusedsignalswireTMode＝0；//controlsignalswireKillpipe_W；wireclk；//decodedsignalswireGFADD8_C0；wireGFADD8I_C0；wireGFMULX8_C0；wireGFRWMOD8_C0；wireLGF8_I_C0；wireSGF8_I_C0；wireLGF8_IU_C0；wireSGF8_IU_C0；wireLGF8_X_C0；wireSGF8_X_C0；wireLGF8_XU_C0；wireSGF8_XU_C0；<dpn="d153"/>wireRUR0_C0；wireWUR0_C0；wire[310]imm4_C0；wire[70]imm8_C0；wireart_use_C0；wireart_def_C0；wirears_use_C0；wirears_def_C0；wirearr_use_C0；wirearr_def_C0；wirebr_use_C0；wirebr_def_C0；wirebs_use-C0；wirebs_def_C0；wirebt_use_C0；wirebt_def_C0；wirebs4_use_C0；wirebs4_def_C0；wirebs8_use_C0；wirebs8_def_C0；wiregr_use_C0；wiregr_def_C0；wiregs_use_C0；wiregs_def_C0；wiregt_use_C0；wiregt_def_C0；wiregfmod_use1_C0；wiregfmod_def1_C0；wireAR_rd0_use1_C0；wireAR_rd0_width32_C0；wireAR_rd1_use1_C0；wireAR_rd1_width32_C0；wireAR_wd_def1_C0；wireAR_wd_width32_C0；wire[30]gf_rd0_addr_C0；wiregf_rd0_use1_C0；wiregf_rd0_width8_C0；wire[30]gf_rd1_addr_C0；wiregf_rd1_use1_C0；wiregf_rd1_width8_C0；wire[30]gf_rd2_addr_C0；wiregf_rd2_use1-C0；wiregf_rd2_width8_C0；wire[30]gf_wdaddr_C0；wiregf_wd_def2_C0；wiregf_wd_def1_C0；wiregf_wd_width8_C0；wiregf1_semanticC0；wiregf4_semantic_C0；wiregf2_semantic_C0；wiregf3_semantic_C0；wirelgf_semantic_C0；wiresgf_semantic_C0；wireRUR0_semantic_C0；wireWUR0_semantic_C0；wireload_instruction_C0；wirestore_instruction_C0；wireTIE_Inst_C0；wire[230]Inst_C0；<dpn="d154"/>//statedata，write-enableandstallsignalswire[70]gfmod_ps_C1；wire[70]gfmod_ns_C1；wiregfmod_kill_C1；wiregfmod_Stall_C1；//registerdata，write-enableandstallsignalswire[310]AR_rd0_data_C1；wire[310]AR_rd1_data_C1；wire[310]AR_wd_data32_C1；wireAR_wd_kill_C1；wire[70]gf_rd0_data_C1；wire[70]gf_rd1_data_C1；wire[70]gf_rd2_data_C1；wire[70]gf_wd_data8_C2；wiregf_wd_kill_C2；wire[70]gf_wd_data8_C1；wiregf_wd_kill_C1；wiregf_Stall_C1；//operandswire[310]art_i_C1；wire[310]art_o_C1；wireart_kill_C1；wire[310]ars_i_C1；wire[310]ars_o_C1；wirears_kill_C1；wire[310]arr_o_C1；wirearr_kill_C1；wire[70]gr_i_C1；wire[70]gr_o_C2；wiregr_kill_C2；wire[70]gr_o_C1；wiregr_kill_C1；wire[70]gs_i_C1；wire[70]gt_i_C1；wire[70]gt_o_C2；wiregt_kill_C2；wire[70]gt_o_C1；wiregt_kill_C1；//outputstateofsemanticgf1//outputinterfaceofsemanticgf1//outputoperandofsemanticgf1wire[70]gf1_gr_o_C1；wiregf1_gr_kill_C1；//outputstateofsemanticgf4//outputinterfaceofsemanticgf4//outputoperandofsemanticgf4wire[70]gf4_gr_o_C1；wiregf4_gr_kill_C1；//outputstateofsemanticgf2//outputinterfaceofsemanticgf2<dpn="d155"/>//outputoperandofsemanticgf2wire[70]gf2_gr_o_C1；wiregf2_gr_kill_C1；//outputstateofsemanticgf3wire[70]gf3_gfmod_ns_C1；wiregf3_gfmod_kill_C1；//outputinterfaceofsemanticgf3//outputoperandofsemanticgf3wire[70]gf3_gt_o_C1；wiregf3_gt_kill_C1；//outputstateofsemanticlgf//outputinterfaceofsemanticlgfwire[40]lgf_LSSize_C0；wire[310]lgf_VAddrBase_C1；wire[310]lgf_VAddrIndex_C1；wire[310]lgf_VAddrOffset_C0；wirelgf_LSIndexed_C0；//outputoperandofsemanticlgfwire[70]lgf_gt_o_C2；wirelgf_gt_kill_C2；wire[310]lgf_ars_o_C1；wirelgf_ars_kill_C1；wire[70]lgf_gr_o_C2；wirelgf_gr_kill_C2；//outputstateofsemanticsgf//outputinterfaceofsemanticsgfwire[40]sgf_LSSize_C0；wire[70]sgf_MemDataOut8_C1；wire[310]sgf_VAddrBase_C1；wire[310]sgf_VAddrIndex_C1；wire[310]sgf_VAddrOffset_C0；wiresgf_LSIndexed_C0；//outputoperandofsemanticsgfwire[310]sgf_ars_o_C1；wiresgf_ars_kill_C1；//outputstateofsemanticRUR0//outputinterfaceofsemanticRUR0//outputoperandofsemanticRUR0wire[310]RUR0_arr_o_C1；wireRUR0_arr_kill_C1；//outputstateofsemanticWUR0wire[70]WUR0_gfmod_ns_C1；wireWUR0_gfmod_kill_C1；//outputinterfaceofsemanticWUR0<dpn="d156"/>//outputoperandofsemanticWUR0//TIE-definedinterfacesignalswire[310]VAddr_C1；wire[310]VAddrBase_C1；wire[310]VAddrOffset_C0；wire[310]VAddrIndex_C1；wire[310]VAddrIn_C1；wire[40]LSSize_C0；wireLSIndexed_C0；wire[1270]MemDataIn128_C2；wire[630]MemDataIn64_C2；wire[310]MemDataIn32_C2；wire[150]MemDataIn16_C2；wire[70]MemDataIn8_C2；wire[1270]MemDataOut128_C1；wire[630]MemDataOut64_C1；wire[310]MemDataOut32_C1；wire[150]MemDataOut16_C1；wire[70]MemDataOut8_C1；wireException_C1；wire[50]ExcCause_C1；wire[70]CPEnable_C1； xtflop#(1)reset(localReset，Reset，G1WCLK)；xmTIEdecoderTIE_decoder( .GFADD8(GFADD8_C0)， .GFADD8I(GFADD8I_C0)， .GFMULX8(GFMULX8_C0)， .GFRWMOD8(GFRWMOD8_C0)， .LGF8_I(LGF8_I_C0)， .SGF8_I(SGF8_I_C0)， .LGF8_IU(LGF8_IU_C0)， .SGF8_IU(SGF8_IU_C0)， .LGF8_X(LGF8_X_C0)， .SGF8_X(SGF8_X_C0)， .LGF8_XU(LGF8_XU_C0)， .SGF8_XU(SGF8_XU_C0)， .RUR0(RUR0_C0)， .WUR0(WUR0_C0)， .imm4(imm4_C0)， .imm8(imm8_C0)； .art_use(art_use_C0)， .art_def(art_def_C0)， .ars_use(ars_use_C0)， .ars_def(ars_def_C0)， .arr_use(arr_use_C0)， .arr_def(arr_def_C0)， .br_use(br_use_C0)， .br_def(br_def_C0)， .bs_use(bs_use_C0)， .bs_def(bs_def_C0)， .bt_use(btuse_C0)， .bt_def(bt_def_C0)， .bs4_use(bs4_use_C0)， bs4_def(bs4_def_C0)， .bs8_use(bs8_use_C0)， .bs8_def(bs8_def_C0)， .gr_use(gr_use_C0)， .gr_def(gr_def_C0)，<dpn="d157"/> .gs_use(gs_use_C0)， .gs_def(gs_def_C0)， .gt_use(gt_use_C0)， .gt_def(gt_def_C0)， .gfmod_use1(gfmod_use1_C0)， .gfmod_def1(gfmod_def1_C0)， .R_rd0_use1(AR_rd0_use1_C0)， .AR_rd0_width32(AR_rd0_width32_C0)， .R_rd1_use1(AR_rd1_use1_C0)， .AR_rd1_width32(AR_rd1_width32_C0)， .AR_wd_def1(AR_wd_def1_C0)， .AR_wd_width32(AR_wd_width32_C0)， .gf_rd0_addr(gf_rd0_addr_C0)， .gf_rd0_use1(gf_rd0_use1_C0)， .gf_rd0_width8(gf_rd0_width8_C0)， .gf_rd1_addr(gf_rd1_addr_C0)， .gf_rd1_use1(gf_rd1_use1_C0)， .gf_rd1_width8(gf_rd1_width8_C0)， .gf_rd2_addr(gf_rd2_addr_C0)， .gf_rd2_use1(gf_rd2_use1_C0)， .gf_rd2_width8(gf_rd2_width8_C0)， .gf_wd_addr(gf_wd_addr_C0)， .gf_wd_def2_(gf_wd_def2_C0)， .gf_wd_def1(gf_wd_def1_C0)， .gf_wd_width8(gf_wd_width8_C0)， .gf1_semantic(gf1_semantic_C0)， .gf4_semantic(gf4_semantic_C0)， .gf2_semantic(gf2_semantic_C0)， .gf3_semantic(gf3_semantic_C0)， .lgf_semantic(lgf_semantic_C0)， .sgf_semantic(sgf_semantic_C0)， .RUR0_semantic(RUR0_semantic_C0)， .WUR0_semantic(WUR0_semantic_C0)， .load_instruction(load_instruction_C0)， .store_instruction(store_instruction_C0)， .TIE_Inst(TIE_Inst_C0)， .Inst{Inst_C0))；xmTIE_gf1TIE_gf1( .GFADD8_C0(GFADD8_C0)， .gr_o_C1(gf1_gr_o_C1)， .gr_kill_C1(gf1_gr_kill_C1)， .gs_i_C1(gs_i_C1)， .gt_i_C1(gt_i_C1)， .clk(clk))；xmTIE_gf4TIE_gf4( .GFADD8I_C0(GFADD8I_C0)， .gr_o_C1(gf4_gr_o_C1)， .gr_kill_C1(gf4_gr_kill_C1)， .gs_i_C1(gs_i_C1)， .imm4_C0(imm4_C0)， .clk(clk))；xmTIE_gf2TIE_gf2( .GFMULX8_C0(GFMULX8_C0)， .gr_o_C1(gf2_gr_o_C1)， .gr_kill_C1(gf2_gr_kill_C1)， .gs_i_C1(gs_i_C1)，<dpn="d158"/> .gfmod_ps_C1(gfmod_ps_C1)， .clk(clk))；xmTIE_gf3TIE_gf3( .GFRWMOD8_C0(GFRWMOD8_C0)， .gt_i_C1(gt_i_C1)， .gt_o_C1(gf3_gt_o_C1)， .gt_kill_C1(gf3_gt_kill_C1)， .gfmod_ps_C1(gfmod_ps_C1)， .gfmod_ns_C1(gf3_gfmod_ns_C1)， .gfmod_kill_C1(gf3_gfmod_kill_C1)， .clk(clk))；xmTIE_lgfTIE_lgf( .LGF8_I_C0(LGF8_I_C0)， .LGF8_IU_C0(LGF8_IU_C0)， .LGF8_X_C0(LGF8_X_C0)， .LGF8_XU_C0(LGF8_XU_C0)， .gt_o_C2(lgf_gt_o_C2)， .gt_kill_C2(lgf_gt_kill_C2)， .ars_i_C1(ars_i_C1)， .ars_o_C1(lgf_ars_o_C1)， .ars_kill_C1(lgf_ars_kill_C1)， .imm8_C0(imm8_C0)， .gr_o_C2(lgf_gr_o_C2)， .gr_kill_C2(lgf_gr_kill_C2)， .art_i_C1(art_i_C1)， .MemDataIn8_C2(MemDataIn8_C2)， .VAddrIn_C1(VAddrIn_C1)， .LSSize_C0(lgf_LSSize_C0)， .VAddrBase_C1(lgf_VAddrBase_C1)， .VAddrIndex_C1(lgf_VAddrIndex_C1)， .VAddrOffset_C0(lgf_VAddrOffset_C0)， .LSIndexed_C0(lgf_LSIndexed_C0)， .clk(clk))；xmTIE_sgfTIE_sgf( .SGF8_I_C0(SGF8_I_C0)， .SGF8_IU_C0(SGF8_IU_C0)， .SGF8_X_C0(SGF8_X_C0)， .SGF8_XU_C0(SGF8_XU_C0)， .gt_i_C1(gt_i_C1)， .ars_i_C1(ars_i_C1)， .ars_o_C1(sgf_ars_o_C1)， .ars_kill_C1(sgf_ars_kill_C1)， .imm8_C0(imm8_C0)， .gr_i_C1(gr_i_C1)， .art_i_C1(art_i_C1)， .VAddrIn_C1(VAddrIn_C1)， .LSSize_C0(sgf_LSSize_C0)， .MemDataOut8_C1(sgf_MemDataOut8_C1)， .VAddrBase_C1(sgf_VAddrBase_C1)， .VAddrIndex_C1(sgf_VAddrIndex_C1)， .VAddrOffset_C0(sgf_VAddrOffset_C0)， .LSIndexed_C0(sgf_LSIndexed_C0)， .clk(clk))；xmTIE_RUR0TIE_RUR0( .RUR0_C0(RUR0_C0)， .arr_o_C1(RUR0_arr_o_C1)，<dpn="d159"/> .arr_kill_C1(RUR0_arr_kill_C1)， .gfmod_ps_C1(gfmod_ps_C1)， .clk(clk))；xmTIE_WUR0TIE_WUR0( .WUR0_C0(WUR0_C0)， .art_i_C1(art_i_C1)， .gfmod_ns_C1(WUR0_gfmod_ns_C1)， .gfmod_kill_C1(WUR0_gfmod_kill_C1)， .clk(clk))；xmTIE_gfmod_StateTIE_gfmod_State( .ps_width8_C0(1′b1)， .ps_use1_C0(gfmod_use1_C0)， .ps_data_C1(gfmod_ps_C1)， .ns_width8_C0(1′b1)， .ns_def1_C0(gfmod_def1_C0)， .ns_data8_C1(gfmod_ns_C1)， .ns_wen_C1(-gfmod_kill_C1)， .Kill_E(Kill_E)， .KillPipe_W(KillPipe_W)， .Stall_R(gfmod_Stall_C1)， .clk(clk))；xmTIE_gf_RegfileTIE_gf_Regfile( .rd0_addr_C0(gf_rd0_addr_C0)， .rd0_use1_C0(gf_rd0_use1_C0)， .rd0_data_C1(gf_rd0_data_C1)， .rd0_width8_C0(gf_rd0_width8_C0)， .rd1_addr_C0(gf_rd1_addr_C0)， .rd1_use1_C0(gf_rd1_use1_C0)， .rd1_data_C1(gf_rd1_data_C1)， .rd1_width8_C0(gf_rd1_width8_C0)， .rd2_addr_C0(gf_rd2_addr_C0)， .rd2_use1_C0(gf_rd2_use1_C0)， .rd2_data_C1(gf_rd2_data_C1)， .rd2_width8_C0(gf_rd2_width8_C0)， .wd_addr_C0(gf_wd_addr_C0)， .wd_def2_C0(gf_wd_def2_C0)， .wd_wen_C2(-gf_wd_kill_C2)， .wd_data8_C2(gf_wd_data8_C2)， .wd_def1_C0(gf_wd_def1_C0)， .wd_wen_C1(-gf_wd_kill_C1)， .wd_data8_C1(gf_wd_data8_C1)， .wd_width8_C0(gf_wd_width8_C0)， .Kill_E(Kill_E)， .KillPipe_W(KillPipe_W)， .Stall_R(gf_Stall_C1)， .clk(clk))；//StalllogicassignTLE_Stall_R＝1′b0 |gf_Stall_C1 |gfmod_Stall_C1；//pipelinesemanticselectsignalstoeachstagewirelgf_semantic_C1；<dpn="d160"/>xtdelay1#(1)ilgf_semantic_C1(.xtin(lgf_semantic_C0)，.xtout(lgf_semantic_C1)，.clk(clk))；wiresgf_semantic_C1；xtdelay1#(1)isgf_semantic_C1(.xtin(sgf_semantic_C0)，.xtout(sgf_semantic_C1)，.clk(clk))；wiregf3_semantic_C1；xtdelay1#(1)igf3_semanticC1(.xtin(gf3_semantic_C0)，.xtout(gf3_semantic_C1)，.clk(clk))；wireWUR0_semantic_C1；xtdelay1#(1)iWUR0_semantic_C1(.xtin(WUR0_semantic_C0)，.xtout(WUR0_semantic_C1)，.clk(clk))；wireRUR0_semantic_C1；xtdelay1#(1)iRUR0_semantic_C1(.xtin(RUR0_semantic_C0)，.xtout(RUR0_semantic_C1)，.clk(clk))；wirelgf_semantic_C2；xtdelay2#(1)ilgf_semantic_C2(.xtin(lgf_semantic_C0)，.xtout(lgf_semantic_C2)，.clk(clk))；wiregf1_semantic_C1；xtdelay1#(1)igf1_semantic_C1(.xtin(gf1_semantic_C0)，.xtout(gf1_semantic_C1)，.clk(clk))；wiregf4_semantic_C1；xtdelay1#(1)igf4_semantic_C1(.xtin(gf4_semantic_C0)，.xtout(gf4_semantic_C1)，.clk(clk))；wiregf2_semantic_C1；xtdelay1#(1)igf2_semantic_C1(.xtin(gf2_semantic_C0)，.xtout(gf2_semantic_C1)，.clk(clk))；//combineoutputinterfacesignalsfromallsemanticsassignVAddr_C1＝32′b0；assignVAddrBase_C1＝32′b0 |(lgf_VAddrBase_C1&amp;{32{lgf_semantic_C1}}) |(sgf_VAddrBase_C1&amp;{32{sgf_semantic_C1}})；assignVAddrOffset_C0＝32′b0 |(lgf_VAddrOffset_C0&amp;{32{lgf_semantic_C0}}) |(sgf_VAddrOffset_C0&amp;{32{sgf_semantic_C0}})；assignVAddrIndex_C1＝32′b0 |(lgf_VAddrIndex_C1&amp;{32{lgf_semantic_C1}}) |(sgf_VAddrIndex_C1&amp;{32{sgf_semantic_C1}})；assignLSSize_C0＝5′b0 |(lgf_LSSize_C0&amp;{5{lgf_semantic_C0}}) |(sgf_LSSize_C0&amp;{5{sgf_semantic_C0}})；assignLSIndexedC0＝1′b0 |(lgf_LSIndexed_C0&amp;lgf_semantic_C0) |(sgf_LSIndexed_C0&amp;sgf_semantic_C0)；assignMemDataOut128_C1＝128′b0；assignMemDataOut64_C1＝64′b0；assignMemDataOut32_C1＝32′b0；assignMemDataOut16_C1＝16′b0；assignMemDataOut8_C1＝8′b0 |(sgf_MemDataOut8_C1&amp;{8{sgf_semantic_C1}})；assignException_C1＝1′b0；assignExcCause_C1＝6′b0；//combineoutputstatesignalsfromallsemanticsassigngfmod_ns_C1＝8′b0 |(gf3_gfmod_ns_C1&amp;{8{gf3_semantic_C1}}) |(WUR0_gfmod_ns_C1&amp;{8{WUR0_semantic_C1}})；assigngfmod_kill_C1＝1′b0 |(gf3_gfmod_kill_C1&amp;gf3_semantic_C1) |(WUR0_gfmod_kill_C1&amp;WUR0_semantic_C1)；<dpn="d161"/>//combineoutputoperandsignalsfromallsemanticsassignart_o_C1＝32′b0；assignart_kill_C1＝1′b0；assignars_o_C1＝32′b0 |(lgf_ars_o_C1&amp;{32{lgf_semantic_C1}}) |(sgf_ars_o_C1&amp;{32{sgf_semantic_C1}})；assignars_kill_C1＝1′b0 |(lgf_ars_kill_C1&amp;lgf_semantic_C1) |(sgf_ars_kill_C1&amp;sgf_semantic_C1)；assignarr_o_C1＝32′b0 |(RUR0_arr_o_C1&amp;{32{RUR0_semantic_C1}})；assignarr_kill_C1＝1′b0 |(RUR0_arr_kill_C1&amp;RUR0_semantic_C1)；assigngr_o_C2＝8′b0 |(lgf_gr_o_C2&amp;{8{lgf_semantic_C2}})；assigngr_kill_C2＝1′b0 |(lgf_gr_kill_C2&amp;lgf_semantic_C2)；assigngr_o_C1＝8′b0 |(gf1_gr_o_C1&amp;{8{gf1_semantic_C1}}) |(gf4_gr_o_C1&amp;{8{gf4_semantic_C1}}) |(gf2_gr_o_C1&amp;{8{gf2_semantic_C1}})；assigngr_kill_C1＝1′b0 |(gf1_gr_kill_C1&amp;gf1_semantic_C1) |(gf4_gr_kill_C1&amp;gf4_semantic_C1) |(gf2_gr_kill_C1&amp;gf2_semantic_C1)；assigngt_o_C2＝8′b0 |(lgf_gt_o_C2&amp;{8{lgf_semantic_C2}})；assigngt_kill_C2＝1′b0 |(lgf_gt_kill_C2&amp;lgf_semantic_C2)；assigngt_o_C1＝8′b0 |(gf3_gt_o_C1&amp;{8{gf3_semantic_C1}})；assigngt_kill_C1＝1′b0 |(gf3_gt_kill_C1&amp;gf3_semantic_C1)；//outputoperandtowriteportmappinglogicassignAR_wd_data32_C1＝ars_o_C1|arr_o_C1|32′b0；assignAR_wd_kill_C1＝ars_kill_C1|arr_kill_C1|1′b0；assigngf_wd_data8_C2＝gt_o_C2|gr_o_C2|8′b0；assigngf_wd_kill_C2＝gt_kill_C2|gr_kill_C2|1′b0；assigngf_wd_data8_C1＝gr_o_C1|gt_o_C1|8′b0；assigngf_wd_kill_C1＝gr_kill_C1|gt_kill_C1|1′b0；//readporttoinputoperandmappinglogicassignars_i_C1＝AR_rd0_data_C1；assignart_i_C1＝AR_rd1_data_C1；assigngs_i_C1＝gf_rd0_data_C1；assigngt_i_C1＝gf_rd1_data_C1；assigngr_i_C1＝gf_rd2_data_C1；//clockandinstructionsassignclk＝G1WCLK；assignInst_C0＝Instr_R；assignTIE_inst_R＝TIE_Inst_C0；//AR-relatedsignalsto/fromcoreassignTIE_asRead_R＝ars_use_C0；assignTIE_atRead_R＝art_use_C0；assignTIE_atWrite_R＝art_def_C0；assignTIE_arWrite_R＝arr_def_C0；<dpn="d162"/>assignTIE_asWrite_R＝ars_def_C0；assignTIE_aWriteM_R＝0；assignTIE_aWriteData_E＝AR_wd_data32_C1；assignTIE_aWriteData_M＝0；assignTIE_aDataKill_E＝AR_wd_kill_Ci；assignTIE_aDataKill_M＝0；assignAR_rd0_data_C1＝SBus_E；assignAR_rd1_data_C1＝TBus_E；//BR-relatedsignalsto/fromcoreassignTIE_bsRead_R＝1′b0|bs_use_C0|bs4_use_C0|bs8_use_C0；assignTIE_btRead_R＝1′b0|bt_use_C0；assignTIE_btWrite_R＝1′b0|bt_def_C0；assignTIE_bsWrite_R＝1′b0|bs_def_C0|bs4_def_C0|bs8_def_C0；assignTIE_brWrite_R＝1′b0|br_def_C0；assignTIE_bWriteData16_E＝0；assignTIE_bWriteData8_E＝0；assignTIE_bWriteData4_E＝0；assignTIE_bWriteData2_E＝0；assignTIE_bWriteData1_E＝0；assignTIE_bDataKill_E＝0；assignTIE_bWriteSize_R＝{1′b0，1′b0，1′b0，1′b0，1′b0}；assignTIE_bsReadSize_R＝{1′b0，1′b0，1′b0，1′b0，1′b0}；assignTIE_btReadSize_R＝{1′b0，1′b0，1′b0，1′b0，1′b0}；//Load/storesignalsto/fromcoreassignTIE_Load_R＝load_instruction_C0；assignTIE_Store_R＝store_instruction_C0；assignTIE_LSSize_R＝LSSize_C0；assignTIE_LSIndexed_R＝LSIndexed_C0；assignTIE_LSOffset_R＝VAddrOffset_C0；assignTIE_MemStoreData128_E＝MemDataOut128_C1；assignTIE_MemStoreData64_E＝MemDataOut64_C1；assignTIE_MemStoreData32_E＝MemDataOut32_C1；assignTIE_MemStoreData16_E＝MemDataOut16_C1；assignTIE_MemStoreData8_E＝MemDataOut8_C1；assignMemDataIn128_C2＝TIE_MemLoadData_M；assignMemDataIn64_C2＝TIE_MemLoadData_M；assignMemDataIn32_C2＝TIE_MemLoadData_M；assignMemDataIn16_C2＝TIE_MemLoadData_M；assignMemDataIn8_C2＝TIE_MemLoadData_M；assignVAddrIn_C1＝MemOpAddr_E；//CPEnableandcontrolsignalsto/fromcoreassignCPEnableC1＝CPEnable；assignTIE_Exception_E＝xception_C1；assignTIE_ExcCause_E＝ExcCause_C1；assignKillPipe_W＝Except_W|Replay_W；endmodulemodulextdelay1(xtout，xtin，clk)；parametersize＝1；output[size-10]xtout；input[size-10]xtin；inputclk；wire[size-10]t0； xtflop#(size)i0(t0，xtin，clk)； assignxtout＝t0；endmodulemodulextdelay2(xtout，xtin，clk)；<dpn="d163"/>parametersize＝1；output[size-10]xtout；input[size-10]xtin；inputclk； wire[size-10]t0； xtflop#(size)i0(t0，xtin，clk)； wire[size-10]t1； xtflop#(size)i1(t1，t0，clk)； assignxtout＝t1；endmodulemodulextmux3p(o，d0，d1，d2，s0，s1)；parametersize＝1；output[size-10]o；input[size-10]d0，d1，d2；inputs0，s1； wire[10]s＝s0？0s1？12； xtmux3e#(size)i0(o，d0，d1，d2，s)；endmodulemodulextregfile_1R1W_1(rd0_data，wr0_data，wr0_we，clk)；parametersize＝32，addr_size＝0；output[size-10]rd0_data；input[size-10]wr0_data；inputwr0_we；inputclk； wirewr0_addr＝0； wireword0_we＝wr0_we&amp;(wr0_addr＝＝0)； wire[size-10]word0； xtenflop#(size)iword0(word0，wr0_data，word0_we，clk)； assignrd0_data＝word0；endmodulemodulextregfile_3R1W_16(rd0_data，rd0_addr，rd1_data，rd1_addr，rd2_data， rd2_addr，wr0_data，wr0_addr，wr0_we，clk)；parametersize＝32，addr_size＝4；output[size-10]rd0_data；input[addr_size-10]rd0_addr；output[size-10]rd1_data；input[addr_size-10]rd1_addr；output[size-10]rd2_data；input[addr_size-10]rd2_addr；input[size-10]wr0_data；input[addr_size-10]wr0_addr；inputwr0_we；inputclk； wire[size-10]wr0_ndata； xtnflop#(size)iwr0_ndata(wr0_ndata，wr0_data，clk)； wireword0_we＝wr0_we&amp;(wr0_addr＝＝0)； wire[size-10]word0； wiregclk0； xtclock_gate_norxt_clock_gate_nor0(gclk0，clk，-word0_we)； xtRFlatch#(size)iword0(word0，wr0_ndata，gclk0)； wireword1_we＝wr0_we&amp;(wr0_addr＝＝1)； wire[size-10]word1； wiregclk1；<dpn="d164"/>xtclock_gate_norxt_clock_gate_nor1(gclk1，clk，-word1_we)；xtRFlatch#(size)iword1(word1，wr0_ndata，gclk1)；wireword2_we＝wr0_we&amp;(wr0_addr＝＝2)；wire[size-10]word2；wiregclk2；xtclock_gate_norxt_clock_gate_nor2(gclk2，clk，-word2_we)；xtRFlatch#(size)iword2(word2，wr0_ndata，gclk2)；wireword3_we＝wr0_we&amp;(wr0_addr＝＝3)；wire[size-10]word3；wiregclk3；xtclock_gate_norxt_clock_gate_nor3(gclk3，clk，-word3_we)；xtRFlatch#(size)iword3(word3，wr0_ndata，gclk3)；wireword4_we＝wr0_we&amp;(wr0_addr＝＝4)；wire[size-10]word4；wiregclk4；xtclock_gate_norxt_clock_gate_nor4(gclk4，clk，-word4_we)；xtRFlatch#(size)iword4(word4，wr0_ndata，gclk4)；wireword5_we＝wr0_we&amp;(wr0_addr＝＝5)；wire[size-10]word5；wiregclk5；xtclock_gate_norxt_clock_gate_nor5(gclk5，clk，-word5_we)；xtRFlatch#(size)iword5(word5，wr0_ndata，gclk5)；wireword6_we＝wr0we&amp;(wr0_addr＝＝6)；wire[size-10]word6；wiregclk6；xtclock_gate_norxt_clock_gate_nor6(gclk6，clk，-word6_we)；xtRFlatch#(size)iword6(word6，wr0_ndata，gclk6)；wireword7_we＝wr0_we&amp;(wr0_addr＝＝7)；wire[size-10]word7；wiregclk7；xtclock_gate_norxt_clock_gate_nor7(gclk7，clk，-word7_we)；xtRFlatch#(size)iword7(word7，wr0_ndata，gclk7)；wireword8_we＝wr0_we&amp;(wr0_addr＝＝8)；wire[size-10]word8；wiregclk8；xtclock_gate_norxt_clock_gate_nor8(gclk8，clk，-word8_we)；xtRFlatch#(size)iword8(word8，wr0_ndata，gclk8}；wireword9_we＝wr0_we&amp;(wr0_addr＝＝9)；wire[size-10]word9；wiregclk9；xtclock_gate_norxt_clock_gate_nor9(gclk9，clk，-word9_we)；xtRFlatch#(size)iword9(word9，wr0_ndata，gclk9)；wireword10_we＝wr0_we&amp;(wr0_addr＝＝10)；wire[size-10]word10；wiregclk10；xtclock_gate_norxt_clock_gate_nor10(gclk10，clk，-word10_we)；xtRFlatch#(size)iword10(word10，wr0_ndata，gclk10)；wireword11_we＝wr0_we&amp;(wr0_addr＝＝11)；wire[size-10]word11；wiregclk11；<dpn="d165"/> xtclock_gate_norxt_clock_gate_nor11(gclk11，clk，-word11_we)； xtRFlatch#(size)iword11(word11，wr0_ndata，gclk11)； wireword12_we＝wr0_we&amp;(wr0_addr＝＝12)； wire[size-10]word12； wiregclk12； xtclock_gate_norxt_clock_gate_nor12(gclk12，clk，-word12_we)； xtRFlatch#(size)iword12(word12，wr0_ndata，gclk12)； wireword13_we＝wr0_we&amp;(wr0_addr＝＝13)； wire[size-10]word13； wiregclk13； xtclock_gate_norxt_clock_gate_nor13(gclk13，clk，-word13_we)； xtRFlatch#(size)iword13(word13，wr0_ndata，gclk13)； wireword14_we＝wr0_we&amp;(wr0_addr＝＝14)； wire[size-10]word14； wiregclk14； xtclock_gate_norxt_clock_gate_nor14(gclk14，clk，-word14_we)； xtRFlatch#(size)iword14(word14，wr0_ndata，gclk14)； wireword15_we＝wr0_we&amp;(wr0_addr＝＝15)； wire[size-10]word15； wiregclk15； xtclock_gate_norxt_clock_gate_nor15(gclk15，clk，-word15_we)； xtRFlatch#(size)iword15(word15，wr0_ndata，gclk15)； xtmux16e#(size)rd0(rd0_data，word0，word1，word2，word3，word4，word5，word6，word7，word8，word9，word10，word11，word12，word13，word14，word15，rd0addr)； xtmux16e#(size)rd1(rd1_data，word0，word1，word2，word3，word4，word5，word6，word7，word8，word9，word10，word11，word12，word13，word14，word15，rd1addr)； xtmux16e#(size)rd2(rd2_data，word0，word1，word2，word3，word4，word5，word6，word7，word8，word9，word10，word11，word12，word13，word14，word15，rd2_addr)；endmodulemodulextmux16e(o，d0，d1，d2，d3，d4，d5，d6，d7，d8，d9，d10，d11，d12，d13，d14，d15，s)；parametersize＝1；output[size-10]o；input[size-10]d0，d1，d2，d3，d4，d5，d6，d7，d8，d9，d10，d11，d12，d13，d14，d15；input[30]s； wire[size-10]t0； xtmux4e#(size)i0(t0，d0，d1，d2，d3，{s[1]，s})； wire[size-10]t1； xtmux4e#(size)i1(t1，d4，d5，d6，d7，{s[1]，s})； wire[size-10]t2； xtmux4e#(size)i2(t2，d8，d9，d10，d11，{s[1]，s})； wire[size-10]t3； xtmux4e#(size)i3(t3，d12，d13，d14，d15，{s[1]，s})； wire[size-10]t4； xtmux4e#(size)i4(t4，t0，t1，t2，t3，{s[3]，s[2]})； assigno＝t4；endmodulemodulextRFenlatch(xtRFenlatchout，xtin，xten，clk)； parametersize＝32；<dpn="d166"/> output[size-10]xtRFenlatchout； input[size-10]xtin； inputxten； inputclk； reg[size-10]xtRFenlatchout；always@(clkorxtenorxtinorxtRFenlatchout)begin if(clk)begin xtRFenlatchout＜＝#1(xten)？xtinxtRFenlatchout； endendendmodulemodulextRFlatch(xtRFlatchout，xtin，clk)； parametersize＝32； output[size-10]xtRFlatchout； input[size-10]xtin； inputclk； reg[size-10]xtRFlatchout；always@(clkorxtin)begin if(clk)begin xtRFlatchout＜＝#1xtin； endendendmodulemodulextadd(xtout，a，b)； parametersize＝32； output[size-10]xtout； input[size-10]a； input[size-10]b； assignxtout＝a+b；endmodulemodulextaddc(sum，carry，a，b，c)； parametersize＝32； output[size-10]sum； outputcarry； input[size-10]a； input[size-10]b； inputc； wirejunk； assign{carry，sum，junk}＝{a，c}+{b，c}；endmodulemodulextaddcin(xtout，a，b，c)； parametersize＝32； output[size-10]xtout； input[size-10]a； input[size-10]b； .inputc；<dpn="d167"/> assignxtout＝({a，c}+{b，c})＞＞1；endmodulemodulextaddcout(sum，carry，a，b)； parametersize＝1； output[size-10]sum； outputcarry； input[size-10]a； input[size-10]b； assign{carry，sum}＝a+b；endmodulemodulextbooth(out，cin，a，b，sign，negate)；parametersize＝16；output[size+10]out；outputcin；input[size-10]a；input[20]b；inputsign，negate； wirease＝sign&amp;a[size-1]； wire[size+10]ax1＝{ase，ase，a}； wire[size+10]ax2＝{ase，a，1′d0}； wireone＝b[1]^b； wiretwo＝b[2]？-b[1]&amp;-bb[1]&amp;b； wirecin＝negate？(-b[2]&amp;(b[1]|b))(b[2]&amp;-(b[1]&amp;b))； assignout＝{size+2{cin}}^(ax1&amp;{size+2{one}}|ax2&amp;{size+2{two}})；endmodulemodulextclock_gate_nor(xtout，xtin1，xtin2)；outputxtout；inputxtin1，xtin2；assignxtout＝-(xtin1||xtin2)；endmodulemodulextclock_gate_or(xtout，xtin1，xtin2outputxtout；inputxtin1，xtin2；assignxtout＝(xtin1||xtin2)；endmodulemodulextcsa(sum，carry，a，b，c)； parametersize＝1； output[size-10]sum； output[size-10]carry； input[size-10]a； input[size-10]b； input[size-10]c； assignsum＝a^b^c； assigncarry＝(a&amp;b)|(b&amp;c)|(c&amp;a)；endmodulemodulextenflop(xtout，xtin，en，clk)； parametersize＝32；<dpn="d168"/> output[size-10]xtout； input[size-10]xtin； inputen； inputclk； reg[size-10]tmp； assignxtout＝tmp； always@(posedgeclk)begin if(en) tmp＜＝#1xtin；endendmodulemodulextfa(sum，carry，a，b，c)；outputsum，carry；inputa，b，c； assignsum＝a^b^c； assigncarry＝a&amp;b|a&amp;c|b&amp;c；endmodulemodulextflop(xtout，xtin，clk)； parametersize＝32； output[size-10]xtout； input[size-10]xtin； inputclk； reg[size-10]tmp； assignxtout＝tmp； always@(posedgeclk)begin tmp＜＝#1xtin；endendmodulemodulextha(sum，carry，a，b)；outputsum，carry；inputa，b； assignsum＝a^b； assigncarry＝a&amp;b；endmodulemodulextinc(xtout，a)； parametersize＝32； output[size-10]xtout； input[size-10]a； assignxtout＝a+1；endmodulemodulextmux2e(xtout，a，b，sel)； parametersize＝32； output[size-10]xtout； input[size-10]a； input[size-10]b； inputsel； assignxtout＝(-sel)？ab；endmodulemodulextmux3e(xtout，a，b，c，sel)；<dpn="d169"/> parametersize＝32； output[size-10]xtout； input[size-10]a； input[size-10]b； input[size-10]c； input[10]sel； reg[size-10]xtout； always@(aorborcorsel)begin xtout＝sel[1]？c(sel？ba)；endendmddulemodulextmux4e(xtout，a，b，c，d，sel)； parametersize＝32； output[size-10]xtout； input[size-10]a； input[size-10]b； input[size-10]c； input[size-10]d； input[10]sel； reg[size-10]xtout； //synopsysinfer_mux＂xtmux4e＂ always@(seloraorborcord)beginxtmux4e case(sel)//synopsysparallel_casefull_case 2′b00 xtout＝a 2′b01 xtout＝b； 2′b10 xtout＝c； 2′b11 xtout＝d； default xtout＝{size{1′bx}}； endcase//case(sel) end//always@(seloraorborcord)endmodulemodulextnflop(xtout，xtin，clk)； parametersize＝32； output[size-10]xtout； input[size-10]xtin； inputclk； reg[size-10]tmp； assignxtout＝tmp； always@(negedgeclk)begin tmp＜＝#1xtin； end//always@(negedgeclk)endmodulemodulextscflop(xtout，xtin，clrb，clk)；//syncclearff parametersize＝32； output[size-10]xtout；<dpn="d170"/> input[size-10]xtin； inputclrb； inputclk； reg[size-10]tmp； assignxtout＝tmp； always@(posedgeclk)begin if(！clrb)tmp＜＝0； elsetmp＜＝#1xtin； endendmodulemodulextscenflop(xtout，xtin，en，clrb，clk)；//syncclear parametersize＝32； output[size-10]xtout； input[size-10]xtin； inputen； inputclrb； inputclk； reg[size-10]tmp； assignxtout＝tmp； always@(posedgeclk)begin if(！clrb)tmp＜＝0； elseif(en) tmp＜＝#1xtin； endendmodulegfcheck.dcsh/**Copyright1999-2000TensilicaInc.*Thesecodedinstructions，statements，andcomputerprogramsare*ConfidentialProprietaryInformationofTensilicaInc.andmaynotbe*disclosedtothirdpartiesorcopiedinanyform，inwholeorinpart，*withoutthepriorwrittenconsentofTensilicaInc.*//*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ Genericsetup＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/hdlin_auto_save_templates＝truedefine_design_libWORK-pathworkdirdefine_name_rulesno_slash-restrict＂/＂-replacement_char＂_＂verilogout_no_tri＝trueverbose_messages＝falseshmkdir-pworkdirshdateshhostname/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝<dpn="d171"/> Readandelaboratethedesign＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*//*foreach(F，{＂gf.v＂，＂gf_FF.v＂，＂gf_tlt.v＂}){*/foreach(F，{＂gf.v＂}){ read-fverilog＂/home/earl/tensilica/test/gf/gf.out/＂+F /* remove_designfind(design，＂xtha＂)＞/dev/null remove_designfind(design，＂xtfa＂)＞/dev/null remove_designfind(design，＂xtmux4b＂)＞/dev/null read-fverilog＂/home/earl/tensilica/test/gf/gf.out/prim.v＂ */ /* elaboratexmTIE */ current_designxmTIE link ungroup-all-flatten check_design remove_designfind(design，＂*＂)}quitgf.dcsh/**Copyright1999-2000TensilicaInc.*Thesecodedinstructions，statements，andcomputerprogramsare*ConfidentialProprietaryInformationofTensilicaInc.andmaynotbe*disclosedtothirdpartiesorcopiedinanyform，inwholeorinpart，*withoutthepriorwrittenconsentofTensilicaInc.*//*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ Genericsetup＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/hdlinauto_save_templates＝truedefine_design_libWORK-pathworkdirdefine_name_rulesno_slash-restrict＂/＂-replacement_char＂_＂verilogout_no_tri＝trueverbose_messages＝falseshmkdir-pworkdirshdateshhostname/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝<dpn="d172"/> Library-specificparameters Mostareself-explanatory.Examplesforeachareshown. LIB_MAP_ONLYisasetofgatestousethe＂set_map_only＂attributefor DesignCompiler.Typicallythisshouldbeall3∶1and4∶1muxesand allhalf-addersandfull-adders. LIB_SCAN_FLOPisasetofflopstonotuseforsequentialmappingbecause theyrepresentscanflopsinthelibrary. LIB_DONT_USEcanselecttargetgatesinthelibrarynottouse.＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/synthetic_library＝{standard.sldb}search_path＝search_path+{＂/cad/artisan/Phantom/synopsys/acb872＂}target_library＝slow.dblink_library＝{＂*＂}+target_library+synthetic_libraryCLOCK_PERIOD＝6.67/*targetclockperiod*/CLOCK_SKEW＝.35/*estimatedclockskew*/CRITICAL_RANGE＝.8/*keeppathsoff-criticalpathstight*/BOUNDARY_LOAD＝slow/INVX1/A/*typicalload*/DRIVE_CELL＝DFFX4/*typicaldrivecellname*/DRIVE_PIN＝Q/*typicaldrivepinname*/DRIVE_PIN_FROM＝CK/*typicaldrivefrompinname*/OPERATING_CONDITION＝slow/*operatingconditions*/WIRE_LOAD＝TSMC32K_Aggresive/*wire-loadmodel*/LIB_MAP_ONLY＝{slow/MX4*，slow/MXI4*，slow/ADDF*，slow/ADDH*}LIB_SCAN_FLOP＝{slow/SDFF*，slow/SEDFF*}LIB_DONT_USE＝{slow/ADDFX4*}+LIB_SCAN_FLOP/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ Design-specificparameters TIE_DESIGNisthenameofthetop-leveldesignforoptimization.Typically itis＂xmTIE＂therootoftheTIElogic.However，itcanbesettoany lower-leveldesign(e.g.，anysinglesemanticblocksuchasxmTIE_myblock) tooptimizejustthatsemanticblocklogic. TIE_RETIMEenables＂optimize_registers＂forretimingaTIEpipelined design.Itcanbesetto0，1or2.If0，noretimingisdone.If1， retimingofsemanticblocklogicisdone.If2，amoreaggressiveretiming isdonewhichincludesthecontrolandbypasslogicintheregisterfiles. RetimingrequiresaDesignCompilerUltralicense. TIE_MAP_EFFORTcontrolstheDesignCompilereffortlevelonthefinalpass ofincrementalcompiles. AREA_IS_PRIORITYtweakstheoptimizationscripttotryforaminimumarea .design.Useitonlywhentimingconstraintsareveryloose.<dpn="d173"/>＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/TIE_DESIGN＝xmTIETIE_RETIME＝0TIE_MAP_EFFORT＝mediumAREA_IS_PRIORITY＝0/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ Configurethesyntheticlibrary＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/readstandard.sldbset_dont_usestandard.sldb/*/rplremove_attributestandard.sldb/*cmp*/rpldont_use/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ Readandelaboratethedesign＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/read-fverilog＂/home/earl/tensilica/test/gf/gf.out/gf.v＂remove_designfind(design，＂xtha＂)＞/dev/nullremove_designfind(design，＂xtfa＂)＞/dev/nullremove_designfind(design，＂xtmux4b＂)＞/dev/nullread-fverilog＂/home/earl/tensilica/test/gf/gf.out/prim.v＂elaborateTIE_DESIGNcurrent_designTIE_DESIGNlink/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ Optimize＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*//*+----------------------------------------------------------------+|Copyright(c)1997-2000TensilicaInc.||||Thesecodedinstructions，statements，andcomputerprograms||areConfidentialProprietaryInformationofTensilicaInc.||andmaynotbedisclosedtothirdpartiesorcopiedinany||form，inwholeorinpart，withoutthepriorwritten||consentofTensilicaInc.|+----------------------------------------------------------------+ TitleSynthesisscriptforTensilicaprimitives CreatedFriNov12，1999；#AuthorRichardRudell；#＜rudell@tensilica.com＞<dpn="d174"/>Description TheDesignCompiler＂current_design＂isrelevantwhenthisscriptisrun. Ahierarchicalsearchfromthecurrentdesignfindsthesetofprimitives. TENSILICA_SOURCE/Hardware/scripts/syn/Xtensa_cons_generic.dcsetsthe constraintsontheprimitives. Theprimitivesareungroupedwhentheyareoptimized.Mostprimitivesare optimizedwithaCLOCK_PERIODof0andaCLOCK_SKEWof0(i.e.，min- delay).Somearemappedwiththerealconstraints.Notallprimitivesare optimized. Theprimitivesareorderedsothatprimitiveswhichcontainotherprimitives asinstanceswillbeoptimizedlaterintheflow.Theorderishardwired. XTADDandXTMULgivebetterresultswhenmapped＂incremental＂.Aprimitive withlotsofgenericlogicwhenitismappedusuallyisworsewhenmapped incremental. prim.vcontainsspecialsynthesisversionsofxtmux3e，xtmux4e，andxtcsa. Thesedesignscontaincellsofxtmux3e_1024，xtmux4e_1024，andxtcsa_1024 whichtheninstantiate1,024xtmux3b，xtmux4b，andxtfacells.Itis importantthatthesedesignsareungroupedandoptimizedtoremovethemany netswithnofanout.Thistrickisusedto.ensureefficientcellsfromthe libraryareused，regardlessofthewidthoftheprimitive. Single-bitversionsofxtmux3b，xtmux4b，xtfaandxthaarepremappedhoping togetsinglecellsfromthelibraryoftheyexist.Notethatthisis prettymuchguaranteedforxtmux4b，xtfa，andxthaastheyareinstantiated in＂prim.v＂asGTECHcomponents.RevisionHistory Nov1999Rewritetospecializeitforsomeprimitives Nov1998Originalversion*/XTVERBOSE＝0XTCURRENT_DESIGN＝current_designXTCLOCK_PERIOD＝CLOCK_PERIODXTCLOCK_SKEW＝CLOCK_SKEWLAST_TIME＝time()/*configurethelibrary*/<dpn="d175"/>readtarget_libraryset_map_onlyLIB_MAP_ONLY+{gtech/GTECH_ADD_ABC，gtech/GTECH_ADD_AB，gtech/GTECH_MUX4}trueif(LIB_DONT_USE！＝{}){ set_dont_useLIB_DONT_USE}current_designXTCURRENT_DESIGNXTGATE＝find(design，＂xtmux*b＂，-hier)+find(design，＂xtfa＂，-hier)+find(design，＂xtha＂，-hier)＞/dev/nullXTCLOCKGATE＝find(design，＂xtclock_gate*＂，-hier)＞/dev/nullXTRFLATCH＝find(design，＂xtRF*latch*＂，-hier)＞/dev/nullXTMUX2＝find(design，＂xtmux2_size*＂，-hier)+find(design，＂xtmux2e_size*＂，-hier)+find(design，＂xtmux2p_size*＂，-hier)＞/dev/nullXTMUX3＝find(design，＂xtmux3_size*＂，-hier)+find(design，＂xtmux3e_size*＂，-hier)+find(design，＂xtmux3p_size*＂，-hier)＞/dev/nullXTMUX4＝find(design，＂xtmux4_size*＂，-hier)+find(design，＂xtmux4e_size*＂，-hier)+find(design，＂xtmux4p_size*＂，-hier)＞/dev/nullXTBOOTH＝find(design，＂xtbooth*＂，-hier)＞/dev/nullXTADD＝find(design，＂xtinc*＂，-hier)+find(design，＂xtadd*＂，-hier)+find(design，＂xtcsa_size*＂，-hier)+find(design，＂xtrelational*＂，-hier)＞/dev/nullXTMUL＝find(design，＂xtmul*＂，-hier)+find(design，＂xtmac*＂，-hier)＞/dev/nullXTREGFILE＝find(design，＂xtregfile*＂，-hier)＞/dev/null/*setthecompilationorder*/XTPRIM＝XTGATE+XTCLOCKGATE+XTRFLATCH+XTMUX2+XTMUX3+XTMUX4+XTBOOTH+XTADD+XTMUL+XTREGFILE/*setcompileoptions*/XTFLATTEN＝{}XTSTRUCTURE＝{}XTDONT_TOUCH＝XTCLOCKGATE+XTREGFILEXTINCREMENTAL＝XTADD+XTMUL+XTREGFILEXTAREA＝XTCLOCKGATE+XTRFLATCHXTRELAXED＝XTREGFILE/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ Premaptheprimitives＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/if(XTFLATTEN！＝{}){ set_flattentrue-designXTFLATTEN}if(XTPRIM-XTSTRUCTURE！＝{}){ set_structurefalse-designXTPRIM-XTSTRUCTURE}if(XTDONT_TOUCH！＝{}){ set_dont_touchXTDONT_TOUCHtrue}foreach(D，XTPRIM){ echo＂Primitivemap＂+D current_designD<dpn="d176"/> echo＂Ungrouping＂+D ungroup-all-flatten＞/dev/null echo＂Constraining＂+D if(({D}-XTAREA)＝{}){ echoD+＂Areaoptimization＂ set_max_area0 }else{ if(({D}-XTRELAXED)＝＝{}){ /*normalconstraints*/ CLOCK_PERIOD＝XTCLOCK_PERIOD CLOCK_SKEW＝XTCLOCK_SKEW }else{ /*overconstrainallotherprimitives*/ CLOCK_PERIOD＝0 CLOCK_SKEW＝0 } echoD+＂Clockperiodis＂+CLOCK_PERIOD+＂andclockskewis＂+CLOCK_SKEW/*+----------------------------------------------------------------+|Copyright(c)1997-2000TensilicaInc.||||Thesecodedinstructions，statements，andcomputerprograms||areConfidentialProprietaryInformationofTensilicaInc.||andmaynotbedisclosedtothirdpartiesorcopiedinany||form，inwholeorinpart，withoutthepriorwritten||consentofTensilicaInc.|+----------------------------------------------------------------+ TitleGenericDesignCompilerConstraints CreatedNovember，1998；#AuthorRichardRudell；#＜rudell@tensilica.com＞DescriptionRevisionHistory Nov1999ChangedmulticyclepathsforRFLATCHintoa set_disable_timingonthelatchesinstead Nov1998Originalversion*//*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝Clocks＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/CLOCK_PORT＝find(port，＂CLK＂)+find(port，＂G*CLK＂)+find(port，＂clk＂)＞/dev/nullif(CLOCK_PORT＝＝{}){ create_clock-nameCLK-periodCLOCK_PERIOD}else{ CLOCK_PORT＝filter(CLOCK_PORT，＂@port_direction＝＝in＂)＞/dev/null create_clockCLOCK_PORT-nameCLK-periodCLOCK_PERIOD}set_dont_touch_networkfind(clock，＂*＂)set_fix_holdfind(clock，＂*＂)set_cloc}_skew-ideal-uncertaintyCLOCK_SKEWfind(clock，＂*＂)<dpn="d177"/>DEBUG_CLOCK_PORT＝find(port，＂TClockDR＂)＞/dev/nullif(DEBUG_CLOCK_PORT！＝{}){ create_clockDEBUG_CLOCK_PORT-nameTClockDR-period4*CLOCK_PERIOD}/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝I/Odelays，loads，drives＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/set_input_delay.20*CLOCK_PERIOD-clockCLKall_inputs()-CLOCK_PORT-DEBUG_CLOCK_PORTset_output_delay.20*CLOCK_PERIOD-clockCLKall_outputs()set_load{4*load_of(BOUNDARY_LOAD)}all_outputs()set_driving_cell-cellDRIVE_CELL-pinDRIVE_PIN-from_pinDRIVE_PIN_FROall_inputs()-CLOCK_PORT-DEBUG_CLOCK_PORT＞/dev/null/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝Miscellaneous＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/set_operating_conditionsOPERATING_CONDITION/*BACKWARDCOMPATIBILITYISSUEset_wire_load_modelDOESNOTworkwithDC98.08*//*set_wire_load_model-nameWIRE_LOAD*/set_wire_loadWIRE_LOADset_critical_rangeCRITICAL_RANGEcurrent_design/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ClockGatingChecks＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/set_clock_gating_check-setupCLOCK_SKEW-holdCLOCK_SKEWcurrent_design/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝Disablelatchtiming＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*//*theifpreventsRFLATCHfrombeingprinted*/if(FOOBAR＝＝FOOBAR){ RFLATCH＝find(cell，＂*xtRF*latchout*＂，-hier)＞/dev/null if(RFLATCH！＝{}){ echodisablingtimingthroughthelatches set_disable_timingRFLATCH }}/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝Falsepaths＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*//*if(DEBUG_CLOCK_PORT！＝{}){set_false_path-fromTClockDR-toCLKset_false_path-fromCLK-toTClockDR}*/ if(({D}-XTREGFILE)＝＝{}){ set_input_delay.35*CLOCK_PERIOD-clockCLKfind(port，＂wr*_addr＂)＞/dev/null set_input_delay.35*CLOCK_PERIOD-clockCLKfind(port，＂wr*_we＂) } } echo＂Optimizing＂+D if(({D}-XTINCREMENTAL)＝＝{}){ compile-map_effortlow-ungroup_all-no_design_rule-incremental }else{ compile-map_effortlow-ungroup_all-no_design_rule }<dpn="d178"/>if(XTVERBOSE){ echo＂Reporting＂+D report_constraint report_timing report_area report_reference ELAPSE_TIME＝time()-LAST_TIME LAST_TIME＝time() echoD+＂elapsetimeis＂+ELAPSE_TIME echoD+＂totaltimeis＂+time() echoD+＂memoryis＂+mem()}}echo＂Primtotaltimeis＂+time()echo＂Primmemoryis＂+mem()remove_designfind(design，＂xtmux3e_1024＂)＞/dev/nullremove_designfind(design，＂xtmux4e_1024＂)＞/dev/nullremove_designfind(design，＂xtcsa1024＂)＞/dev/nullcurrent_designXTCURRENT_DESIGNCLOCK_PERIOD＝XTCLOCK_PERIODCLOCK_SKEW＝XTCLOCK_SKEW/*+----------------------------------------------------------------+|Copyright(c)1997-2000TensilicaInc.||||Thesecodedinstructions，statements，andcomputerprograms||areConfidentialProprietaryInformationofTensilicaInc.||andmaynotbedisclosedtothirdpartiesorcopiedinany||form，inwholeorinpart，withoutthepriorwritten||consentofTensilicaInc.|+----------------------------------------------------------------+ TitleSynthesisscriptforTIECoprocessors CreatedFriNov12，1999；#AuthorRichardRudell；#＜rudell@tensilica.com＞Description ControlsDesignCompilerforoptimizingTIECoprocessors. SetTIE_DESIGNtoTIEtooptimizetheTIEmodule，orsetittotheverilog nameofasemanticblock(e.g.，TIE_vec_mac)tooptimizejustthat module. SetTIE_RETIMEto1toperformretiming(＂optimize_registers＂).Allofthe TIElogicexceptforthethepipelinedregisterfileswillberetimed.If TIE_RETIMEis2，onlytheregisterfilecoreswillnotberetimed.This allowsforretimingofthepipelinelogicwithintheregisterfiles，butis<dpn="d179"/> moretaxingontheDesignCompilerretimingalgorithm. TIE_MAP_EFFORTisoneof{low，medium，high}forthefinaloptimization. Thestepsareasfollows -groupthetop-levellogicintoadesign(TIE_toplogic) -setcompileoptions -optimizethedesignforeachtop-levelcell(loweffort) -TIE_RETIMEregroupthetop-leveldesignforretiming -optimizetop-leveldesign(usingTIE_MAP_EFFORT) -TIE_RETIMEretimethetop-leveldesign -optimizetop-leveldesign(usingTIE_MAP_EFFORT) -fixdesignrulesRevisionHistory Nov1999Originalversion*//*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ GrouptheTIEtop-levellogicintoasubdesign＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/current_designTIE_DESIGNif(TIE_UNGROUP！＝{}){ /*removesomecells*/ ungroupTIE_UNGROUP-flatten}if(TIE_DESIGN＝＝＂xmTIE＂){ /*groupthetop-levelrandomlogicintoasubdesign*/ TIE_CELL_LIST＝find(cell，＂TIE_*＂)＞/dev/null group-design_namexmTIE_toplogic-cell_name.TIE_toplogic-exceptTIE_CELL_LIST}/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ Findthetop-levelcellsandtheirdesigns＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/current_designTIE_DESIGNif(TIE_DESIGN＝＝＂xmTIE＂){ TIE_CELL_LIST＝find(cell，＂TIE_*＂)＞/dev/null TIE_DESIGN_LIST＝{}}else{ TIE_CELL_LIST＝{} TIE_DESIGN_LIST＝TIE_DESIGN}foreach(C，TIE_CELL_LIST){ TIE_DESIGN_LIST＝TIE_DESIGN_LIST+find(design，＂xm＂+C)}TIE_REGFILE＝find(design，＂xmTIE*_Regfile＂，-hier)+find(design，＂xmTIE*_State＂，-hier)＞/dev/nullTIE_XTREGFILE＝find(design，＂xtregfile*＂，-hier)＞/dev/null<dpn="d180"/>TIE_DECODER＝find(design，＂xmTIE_decoder＂，-hier)＞/dev/hull/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ Setoptimizationcontrols.＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/TIE_FLATTEN＝TIE_DECODER/*alwaysflattendecoder*/if(AREA_IS_PRIORITY){ TIE_STRUCTURE＝TIE_DESIGN_LIST}else{ TIE_STRUCTURE＝TIE_DECODER/*alwaysstructuredecoder*/}if(TIE_FLATTEN！＝{}){ set_flattentrue-effortmedium-designTIE_FLATTEN}if(TIE_DESIGN_LIST-TIE_STRUCTURE！＝{}){ set_structurefalse-designTIE_DESIGN_LIST-TIE_STRUCTURE}/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ Premapthehierarchicaldesigns＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/LAST_TIME＝time()foreach(D，TIE_DESIGN_LIST){ echo＂Premapping＂+D current_designD echo＂Ungrouping＂+D ungroup-all-flatten echo＂Constraining＂+D set_resource_allocationnone set_resourGe_implementationarea_only/*+----------------------------------------------------------------+|Copyright(c)1997-2000TensilicaInc.||||Thesecodedinstructions，statements，andcomputerprograms||areConfidentialProprietaryInformationofTensilicaInc.||andmaynotbedisclosedtothirdpartiesorcopiedinany||form，inwholeorinpart，withoutthepriorwritten||consentofTensilicaInc.|+----------------------------------------------------------------+ TitleGenericDesignCompilerConstraints CreatedNovember，1998；#AuthorRichardRudel；#＜rudell@tensilica.com＞Description<dpn="d181"/>RevisionHistory Nov1999ChangedmulticyclepathsforRFIATCHintoa set_disable_timingonthelatchesinstead Nov1998Originalversion*//*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝Clocks＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/CLOCK_PORT＝find(port，＂CLK＂)+find(port，＂G*CLK＂)+find(port，＂clk＂)＞/dev/nullif(CLOCK_PORT＝＝{}){ createclock-nameCLK-periodCLOCKPERIOD}else{ CLOCK_PORT＝filter(CLOCK_PORT，＂@port_direction＝＝in＂)＞/dev/null create_clockCLOCK_PORT-nameCLK-periodCLOCK_PERIOD}set_dont_touch_networkfind(clock，＂*＂)set_fix_holdfind(clock，＂*＂)set_clock_skew-ideal-uncertaintyCLOCK_SKEWfind(clock，＂*＂)DEBUG_CLOCK_PORT＝find(port，＂TClockDR＂)＞/dev/nullif(DEBUG_CLOCK_PORT！＝{}){ create_clockDEBUG_CLOCK_PORT-nameTClockDR-period4*CLOCK_PERIOD}/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝I/Odelays，loads，drives＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/set_input_delay.20*CLOCK_PERIOD-clockCLKall_inputs()-CLOCK_PORT-DEBUG_CLOCK_PORTset_output_delay.20*CLOCK_PERIOD-clockCLKall_outputs()set_load{4*load_of(BOUNDARY_LOAD)}all_outputs()set_driving_cell-cellDRIVE_CELL-pinDRIVE_PIN-from_pinDRIVE_PIN_FROMall_inputs()-CLOCK_PORT-DEBUG_CLOCK_PORT＞/dev/null/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝Miscellaneous＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/set_operating_conditionsOPERATING_CONDITION/*BACKWARDCOMPATIBILITYISSUEset_wire_load_modelDOESNOTworkwithDC98.08*//*set_wire_load_model-nameWIRELOAD*/set_wire_loadWIRE_LOADset_critical_rangeCRITICAL_RANGEcurrent_design/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ClockGatingChecks＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/set_clock_gating_check-setupCLOCK_SKEW-holdCLOCK_SKEWcurrent_design/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝Disablelatchtiming＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*//*theifpreventsRFLATCHfrombeingprinted*/if(FOOBAR＝＝FOOBAR){ RFLATCH＝find(cell，＂*xtRF*latchout*＂，-hier)＞/dev/null if(RFLATCH！＝{}){ echodisablingtimingthroughthelatches setdisabletimingRFIATCH }}/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝Falsepaths＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/<dpn="d182"/>/*if(DEBUG_CLOCK_PORT！＝{}){set_false_path-fromTClockDR-toCLKset_false_path-fromCLK-toTClockDR}*/if(FOOBAR＝＝FOOBAR){ X＝find(port，＂MemOpAddr_E＂)＞/dev/null if(X！＝{}){ echosettinginputdelayforTIEmemoryinterface set_input_delay.50*CLOCK_PERIOD-clockCLKX } X＝find(port，＂TIE_MemLoadData_M＂)+find(port，＂MemDataIn*＂)＞/dev/null if(X！＝{}){ echosettinginputdelayforTIEmemoryinterface set_input_delay.60*CLOCK_PERIOD-clockCLKX } /*constraintsforTIEregisterfilesandTIEstate*/ X＝find(port，＂rd*_data_C*＂)+find(port，＂ps_data_C*＂)＞/dev/null if(X！＝{}){ echosettingoutputdelayforTIEregisterfile set_output_delay.95*CLOCK_PERIOD-clockCLKX } X＝find(port，＂wd*data*_C*＂)+find(port，＂wr*_data*_C*＂)+find(port，＂ns_data*_C*＂)＞/dev/null if(X！＝{}){ echosettinginputdelayforTIEregisterfile set_input_delay.90*CLOCK_PERIOD-clockCLKX } X＝find(port，＂wd*_wen_C*＂)+find(port，＂Kill*＂)＞/dev/null if(X！＝{}){ X＝filter(X，＂@port_direction＝＝in＂)＞/dev/null if(X！＝{}){ echosettinginputdelayforTIEregisterfilecontrols set_input_delay.35*CLOCKPERIOD-clockCLKX }}}if(TIE_RETIME){ set_critical_rangeCLOCK_PERIODcurrent_design}echo＂Optimizing＂+Dcompile-map_effortlow-ungroup_all-no_design_ruleecho＂Reporting＂+Dreport_constraintreport_timingreport_areareport_referenceELAPSE_TIME＝time()-LAST_TIMELAST_TIME＝time()echoD+＂elapsetimeis＂+ELAPSE_TIMEechoD+＂totaltimeis＂+time()echoD+＂memoryis＂+mem()}<dpn="d183"/>echo＂Premaptotaltimeis＂+time()echo＂Premapmemoryis＂+mem()/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ Reportonthetoplevel＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/current_designTIE_DESIGN/*+----------------------------------------------------------------+|Copyright(c)1997-2000TensilicaInc.||||Thesecodedinstructions，statements，andcomputerprograms||areConfidentialProprietaryInformationofTensilicaInc.||andmaynotbedisclosedtothirdpartiesorcopiedinany||form，inwholeorinpart，withoutthepriorwritten||consentofTensilicaInc.|+----------------------------------------------------------------+TitleGenericDesignCompilerConstraintsCreatedNovember，1998；#AuthorRichardRudell；#＜rudell@tensilica.com＞DescriptionRevisionHistory Nov1999ChangedmulticyclepathsforRFLATCHintoa set_disable_timingonthelatchesinstead Nov1998Originalversion*//*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝Clocks＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/CLOCK_PORT＝find(port，＂CLK＂)+find(port，＂G*CLK＂)+find(port，＂clk＂)＞/dev/nullif(CLOCK_PORT＝＝{}){create_clock-nameCLK-periodCLOCK_PERIOD}else{CLOCK_PORT＝filter(CLOCK_PORT，＂@port_direction＝＝in＂)＞/dev/nullcreate_clockCLOCK_PORT-nameCLK-periodCLOCK_PERIOD}set_dont_touchnetworkfind(clock，＂*＂)set_fixholdfind(clock，＂*＂)set_clock_skew-ideal-uncertaintyCLOCK_SKEWfind(clock，＂*＂)DEBUG_CLOCK_PORT＝find(port，＂TClockDR＂)＞/dev/nullif(DEBUG_CLOCK_PORT！＝{}){ create_clockDEBUG_CLOCK_PORT-nameTClockDR-period4*CLOCK_PERIOD}/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝I/Odelays，loads，drives＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/<dpn="d184"/>set_input_delay.20*CLOCK_PERIOD-clockCLKall_inputs()-CLOCK_PORT-DEBUG_CLOCK_PORTset_output_delay.20*CLOCK_PERIOD-clockCLKall_outputs()set_load{4*load_of(BOUNDARY_LOAD)}all_outputs()set_driving_cell-cellDRIVE_CELL-pinDRIVE_PIN-from_pinDRIVE_PIN_FROMall_inputs()-CLOCK_PORT-DEBUG_CLOCK_PORT＞/dev/null/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝Miscellaneous＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/set_operating_conditionsOPERATING_CONDITION/*BACKWARDCOMPATIBILITYISSUEset_wire_load_modelDOESNOTworkwithDC98.08*//*set_wire_load_model-nameWIRE_LOAD*/set_wire_loadWIRE_LOADset_critical_rangeCRITICALRANGEcurrent_design/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ClockGatingChecks＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/set_clock_gating_check-setupCLOCK_SKEW-holdCLOCK_SKEWcurrent_design/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝Disablelatchtiming＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*//*theifpreventsRFLATCHfrombeingprinted*/if(FOOBAR＝＝FOOBAR){ RFLATCH＝find(cell，＂*xtRF*latchout*＂，-hier)＞/dev/null if(RFLATCH！＝{}){ echodisablingtimingthroughthelatches set_disable_timingRFLATCH }}/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝Falsepaths＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*//*if(DEBUG_CLOCK_PORT！＝{}){ set_false_path-fromTClockDR-toCLK set_false_path-fromCLK-toTClockDR}*/if(FOOBAR＝＝FOOBAR){ X＝find(port，＂MemOpAddr_E＂)＞/dev/null if(X！＝{}){ echosettinginputdelayforTIEmemoryinterface set_input_delay.50*CLOCK_PERIOD-clockCLKX } X＝find(port，＂TIE_MemLoadData_M＂)+find(port，＂MemDataIn*＂)＞/dev/null if(X！＝{}){ echosettinginputdelayforTIEmemoryinterface set_input_delay.60*CLOCK_PERIOD-clockCLKX } /*constraintsforTIEregisterfilesandTIEstate*/ X＝find(port，＂rd*_data_C*＂)+find(port，＂ps_data_C*＂)＞/dev/null if(X！＝{}){ echosettingoutputdelayforTIEregisterfile set_output_delay.95*CLOCKPERIOD-clockCLKX } X＝find(port，＂wd*_data*_C*＂)+find(port，＂wr*_data*_C*＂)+find(port，＂ns_data*_C*＂)＞/dev/null if(X！＝{}){<dpn="d185"/> echosettinginputdelayforTIEregisterfile set_input_delay.90*CLOCK_PERIOD-clockCLKX } X＝find(port，＂wd*_wen_C*＂)+find(port，＂Kill*＂)＞/dev/null if(X！＝{}){ X＝filter(X，＂@port_direction＝＝in＂)＞/dev/null if(X！＝{}){ echosettinginputdelayforTIEregisterfilecontrols set_input_delay.35*CLOCK_PERIOD-clockCLKX } }}report_constraintreport_timingreport_areareport_reference/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ Preparedesignforretiming＝keeptheregisterfilesassubdesigns， andgroupeverythingelseinto＂datapath＂.Also，setaveryhigh criticalrangesothatallpathsaremadefast.＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/current_designTIE_DESIGNif(TIE_RETIME){ set_critical_rangeCLOCK_PERIODcurrent_design if(TIE_RETIME＝＝2){ TIE_KEEP_DESIGN＝TIE_XTREGFILE }else{ TIE_KEEP_DESIGN＝TIE_REGFILE } listTIE_KEEP_DESIGN if(TIE_KEEP_DESIGN＝＝{}){ TIE_RETIME_DESIGN＝TIE_DESIGN ungroup-all-flatten }else{ TIE_RETIME_DESIGN＝＂xmTIE_datapath＂ set_dont_touchTIE_KEEP_DESIGNtrue ungroup-all-flatten set_dont_touchTIE_KEEP_DESIGNfalse if(TIE_RETIME＝＝2){ TIE_KEEP_CELL＝find(cell，＂*icore＂) }else{ TIE_KEEP_CELL＝find(cell，＂TIE*_Regfile＂)+find(cell，＂TIE*_State＂) } group-designTIE_RETIME_DESIGN-cellTIE_RETIME_DESIGN-exceptTIE_KEEP_CELL listTIE_KEEP_CELL }}/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ .Pass1<dpn="d186"/>＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/current_designTIE_DESIGNif(TIE_XTREGFILE！＝{}){set_dont_touchTIE_XTREGFILEfalse}if(TIE_DESIGN＝＝＂xmTIE＂){ compile_no_new_cells_at_top_level＝true}uniquifycompile-incremental-map_effortTIE_MAP_EFFORT-no_design_rule-boundary_optimizationreport_constraintreport_timingreport_areareport_referenceELAPSE_TIME＝time()-LAST_TIMELAST_TIME＝time()echo＂passlelapsetimeis＂+ELAPSE_TIMEecho＂passltotaltimeis＂+time()echo＂passlmemoryis＂+mem()/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ Retime＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/current_designTIE_DESIGNif(TIE_RETIME){ if(TIE_RETIME_DESIGN！＝TIE_DESIGN){ characterizeTIE_RETIME_DESIGN current_desiguTIE_RETIME_DESIGN set_wire_loadWIRE_LOAD } optimize_registers-check_design-print_critical_loop-no_incremental_map current_designTIE_DESIGN set_critical_rangeCRITICAL_RANGEcurrent_design}/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ Pass2(addareaconstraint)＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/current_designTIE_DESIGNset_max_area0compile-incremental-map_effortTIE_MAP_EFFORT-no_design_rule-boundary_optimizationreport_constraintreport_timingreport_areareport_referenceELAPSE_TIME＝time()-LAST_TIMELAST_TIME＝time()<dpn="d187"/>echo＂pass2elapsetimeis＂+ELAPSE_TIMEecho＂pass2totaltimeis＂+time()echo＂pass2memoryis＂+mem()/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ pass3(DesignRules)＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/current_designTIE_DESIGNcompile-incremental-map_effortTIE_MAP_EFFORT-only_design_rule-boundary_optimizationreport_constraintreport_timingreport_areareport_referenceELAPSE_TIME＝time()-LAST_TIMELAST_TIME＝time()echo＂pass3elapsetimeis＂+ELAPSE_TIMEecho＂pass3totaltimeis＂+time()echo＂pass3memoryis＂+mem()/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ Writeitout＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/current_designTIE_DESIGNwrite-oTIE_DESIGN+＂.db＂-hier/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ Finalhierarchicalarea/timingreport＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/current_designTIE_DESIGNX＝find(cell，＂TIE_*＂)+find(cell，＂icore＂)＞/dev/nullif(X！＝{}){characterizeX}current_designTIE_DESIGNreport_hierarchy＞TIE_DESIGN+＂.report＂foreach(D，TIE_DESIGN+find(design，＂*＂，-hier)){ echo＂Finalreport＂+D current_designD report_constraint＞＞TIE_DESIGN+＂.report＂ report_timing＞＞TIE_DESIGN+＂.report＂ report_area＞＞TIE_DESIGN+＂.report＂ report_reference＞＞TIE_DESIGN+＂.report＂}echo＂xmTIEelapsetimeis＂+time()＞＞TIE_DESIGN+＂.report＂echo＂xmTIEmemoryis＂+mem()＞＞TIE_DESIGN+＂.report＂<dpn="d188"/>shrm-rfworkdirecho＂xmTIEtotaltimeis＂+time()echo＂xmTIEmemoryis＂+mem()quitprim.v//+----------------------------------------------------------------+//|Copyright(c)1997-2000TensilicaInc.|//||//|Thesecodedinstructions，statements，andcomputerprograms|//|areConfidentialProprietaryInformationofTensilicaInc.|//|andmaynotbedisclosedtothirdpartiesorcopiedinany|//|form，inwholeorinpart，withoutthepriorwritten|//|consentofTensilicaInc.|//+----------------------------------------------------------------+////TitleBaseSynthesisPrimitives////CreatedTueSep281659241999//////Description////RevisionHistory//modulextmux3e(xtout，a，b，c，sel)；parametersize＝32；output[size-10]xtout；input[size-10]a，b，c；input[10]sel； wire[10230]tmp； wire[10230]fa； wire[10230]fb； wire[10230]fc； assignfa[1023size]＝{(1024-size){1′b0}}； assignfa[size-10]＝a； assignfb[1023size]＝{(1024-size){1′b0}}； assignfb[size-10]＝b； assignfc[1023size]＝{(1024-size){1′b0}}； assignfc[size-10]＝c； xtmux3e_1024i(tmp，fa，fb，fc，sel)； assignxtout＝tmp；endmodulemodulextmux3b(xtout，a，b，c，sel)；outputxtout；inputa，b，c；input[10]sel； //synopsysinfermux＂xtmux3b＂ assignxtout＝sel[1]？c(sel？ba)；endmodule_modulextmux4e(xtout，a，b，c，d，sel)；parametersize＝32；output[size-10]xtout；input[size-10]a，b，c，d；input[10]sel；<dpn="d189"/> wire[10230]tmp； wire[10230]fa； wire[10230]fb； wire[10230]fc； wire[10230]fd； assignfa[1023size]＝{(1024-size){1′b0}}； assignfa[size-10]＝a； assignfb[1023size]＝{(1024-size){1′b0}}； assignfb[size-10]＝b； assignfc[1023size]＝{(1024-size){1′b0}}； assignfc[size-10]＝c； assignfd[1023size]＝{(1024-size){1′b0}}； assignfd[size-10]＝d； xtmux4e_1024i(tmp，fa，fb，fc，fd，sel)； assignxtout＝tmp；endmodulemodulextmux4b(xtout，a，b，c，d，sel)；outputxtout；inputa，b，c，d；input[10]sel； GTECH_MUX4i(.D0(a)，.D1(b)，.D2(c)，.D3(d)，.A(sel)，.B(sel[1])，.Z(xtout))；endmodule_modulextcsa(sum，carry，a，b，c)；parametersize＝32；output[size-10]sum，carry；input[size-10]a，b，c； wire[10230]tmp1，tmp2； wire[10230]fa； wire[10230]fb； wire[10230]fc； assignfa[1023size]＝{(1024-size){1′b0}}； assignfa[size-10]＝a； assignfb[1023size]＝{(1024-size){1′b0}}； assignfb[size-10]＝b； assignfc[1023size]＝{(1024-size){1′b0}}； assignfc[size-10]＝c； xtcsa_1024i(tmp1，tmp2，fa，fb，fc)； assignsum＝tmp1； assigncarry＝tmp2；endmodulemodulextfa(sum，carry，a，b，c)；outputsum，carry；inputa，b，c； GTECH_ADD_ABCi(a，b，c，sum，carry)；endmodulemodulextha(sum，carry，a，b)；outputsum，carry；inputa，b； GTECH_ADD_ABi(a，b，sum，carry)；endmodule_modulextmux3e_1024(xtout，a，b，c，sel)；output[10230]xtout；<dpn="d190"/>input[10230]a，b，c；input[10]sel； xtmux3bi0(.xtout(xtout)，.a(a)，.b(b)，.c(c)，.sel(sel))； xtmux3bi1(.xtout(xtout[1])，.a(a[1])，.b(b[1])，.c(c[1])，.sel(sel))； xtmux3bi2(.xtout(xtout[2])，.a(a[2])，.b(b[2])，.c(c[2])，.sel(sel))； xtmux3bi3(.xtout(xtout[3])，.a(a[3])，.b(b[3])，.c(c[3])，.sel(sel))； xtmux3bi4(.xtout(xtout[4])，.a(a[4])，.b(b[4])，.c(c[4])，.sel(sel))； xtmux3bi5(.xtout(xtout[5])，.a(a[5])，.b(b[5])，.c(c[5])，.sel(sel))； xtmux3bi6(.xtout(xtout[6])，.a(a[6])，.b(b[6])，.c(c[6])，.sel(sel))； xtmux3bi7(.xtout(xtout[7])，.a(a[7])，.b(b[7])，.c(c[7])，.sel(sel))； xtmux3bi8(.xtout(xtout[8])，.a(a[8])，.b(b[8])，.c(c[8])，.sel(sel))； xtmux3bi9(.xtout(xtout[9])，.a(a[9])，.b(b[9])，.c(c[9])，.sel(sel))； xtmux3bi10(.xtout(xtout[10])，.a(a[10])，.b(b[10])，.c(c[10])，.sel(sel))； xtmux3bi11(.xtout(xtout[11])，.a(a[11])，.b(b[11])，.c(c[11])，.sel(sel))； xtmux3bi12(.xtout(xtout[12])，.a(a[12])，.b(b[12])，.c(c[12])，.sel(sel))； xtmux3bi13(.xtout(xtout[13])，.a(a[13])，.b(b[13])，.c(c[13])，.sel(sel))； xtmux3bi14(.xtout(xtout[14])，.a(a[14])，.b(b[14])，.c(c[14])，.sel(sel))； xtmux3bi15(.xtout(xtout[15])，.a(a[15])，.b(b[15])，.c(c[15])，.sel(sel))； xtmux3bi16(.xtout(xtout[16])，.a(a[16])，.b(b[16])，.c(c[16])，.sel(sel))； xtmux3bi17(.xtout(xtout[17])，.a(a[17])，.b(b[17])，.c(c[17])，.sel(sel))； xtmux3bi18(.xtout(xtout[18])，.a(a[18])，.b(b[18])，.c(c[18])，.sel(sel))； xtmux3bi19(.xtout(xtout[19])，.a(a[19])，.b(b[19])，.c(c[19])，.sel(sel))； xtmux3bi20(.xtout(xtout[20])，.a(a[20])，.b(b[20])，.c(c[20])，.sel(sel))； xtmux3bi21(.xtout(xtout[21])，.a(a[21])，.b(b[21])，.c(c[21])，.sel(sel))； xtmux3bi22(.xtout(xtout[22])，.a(a[22])，.b(b[22])，.c(c[22])，.sel(sel))； xtmux3bi23(.xtout(xtout[23])，.a(a[23])，.b(b[23])，.c(c[23])，.sel(sel))； xtmux3bi24(.xtout(xtout[24])，.a(a[24])，.b(b[24])，.c(c[24])，.sel(sel))； xtmux3bi25(.xtout(xtout[25])，.a(a[25])，.b(b[25])，.c(c[25])，.sel(sel))； xtmux3bi26(.xtout(xtout[26])，.a(a[26])，.b(b[26])，.c(c[26])，.sel(sel))； xtmux3bi27(.xtout(xtout[27])，.a(a[27])，.b(b[27])，.c(c[27])，.sel(sel))； xtmux3bi28(.xtout(xtout[28])，.a(a[28])，.b(b[28])，.c(c[28])，.sel(sel))； xtmux3bi29(.xtout(xtout[29])，.a(a[29])，.b(b[29])，.c(c[29])，.sel(sel))； xtmux3bi30(.xtout(xtout[30])，.a(a[30])，.b(b[30])，.c(c[30])，.sel(sel))； xtmux3bi31(.xtout(xtout[31])，.a(a[31])，.b(b[31])，.c(c[31])，.sel(sel))； xtmux3bi32(.xtout(xtout[32])，.a(a[32])，.b(b[32])，.c(c[32])，.sel(sel))； xtmux3bi33(.xtout(xtout[33])，.a(a[33])，.b(b[33])，.c(c[33])，.sel(sel))；<dpn="d191"/> xtmux3bi34(.xtout(xtout[34])，.a(a[34])，.b(b[34])，.c(c[34])，.sel(sel))； xtmux3bi35(.xtout(xtout[35])，.a(a[35])，.b(b[35])，.c(c[35])，.sel(sel))； xtmux3bi36(.xtout(xtout[36])，.a(a[36])，.b(b[36])，.c(c[36])，.sel(sel))； xtmux3bi37(.xtout(xtout[37])，.a(a[37])，.b(b[37])，.c(c[37])，.sel(sel))； xtmux3bi38(.xtout(xtout[38])，.a(a[38])，.b(b[38])，.c(c[38])，.sel(sel))； xtmux3bi39(.xtout(xtout[39])，.a(a[39])，.b(b[39])，.c(c[39])，.sel(sel))； xtmux3bi40(.xtout(xtout[40])，.a(a[40])，.b(b[40])，.c(c[40])，.sel(sel))； xtmux3bi41(.xtout(xtout[41])，.a(a[41])，.b(b[41])，.c(c[41])，.sel(sel))； xtmux3bi42(.xtout(xtout[42])，.a(a[42])，.b(b[42])，.c(c[42])，.sel(sel))； xtmux3bi43(.xtout(xtout[43])，.a(a[43])，.b(b[43])，.c(c[43])，.sel(sel))； xtmux3bi44(.xtout(xtout[44])，.a(a[44])，.b(b[44])，.c(c[44])，.sel(sel))； xtmux3bi45(.xtout(xtout[45])，.a(a[45])，.b(b[45])，.c(c[45])，.sel(sel))； xtmux3bi46(.xtout(xtout[46])，.a(a[46])，.b(b[46])，.c(c[46])，sel(sel))； xtmux3bi47(.xtout(xtout[47])，.a(a[47])，.b(b[47])，.c(c[47])，.sel(sel))； xtmux3bi48(.xtout(xtout[48])，.a(a[48])，.b(b[48])，.c(c[48])，.sel(sel))； xtmux3bi49(.xtout(xtout[49])，.a(a[49])，.b(b[49])，.c(c[49]).sel(sel))； xtmux3bi50(.xtout(xtout[50])，.a(a[50])，.b(b[50])，.c(c[50])，.sel(sel))； xtmux3bi51(.xtout(xtout[51])，.a(a[51])，.b(b[51])，.c(c[51])，.sel(sel))； xtmux3bi52(.xtout(xtout[52])，.a(a[52])，.b(b[52])，.c(c[52])，.sel(sel))； xtmux3bi53(.xtout(xtout[53])，.a(a[53])，.b(b[53])，.c(c[53])，.sel(sel))； xtmux3bi54(.xtout(xtout[54])，.a(a[54])，.b(b[54])，.c(c[54])，.sel(sel))； xtmux3bi55(.xtout(xtout[55])，.a(a[55])，.b(b[55])，.c(c[55])，.sel(sel))； xtmux3bi56(.xtout(xtout[56])，.a(a[56])，.b(b[56])，.c(c[56])，.sel(sel))； xtmux3bi57(.xtout(xtout[57])，.a(a[57])，.b(b[57])，.c(c[57])，.sel(sel))； xtmux3bi58(.xtout(xtout[58])，.a(a[58])，.b(b[58])，.c(c[58])，.sel(sel))； xtmux3bi59(.xtout(xtout[59])，.a(a[59])，.b(b[59])，.c(c[59])，.sel(sal))； xtmux3bi60(.xtout(xtout[60])，.a(a[60])，.b(b[60])，.c(c[60])，.sel(sel))； xtmux3bi61(.xtout(xtout[61])，.a(a[61])，.b(b[61])，.c(c[61])，.sel(sel))； xtmux3bi62(.xtout(xtout[62])，.a(a[62])，.b(b[62])，.c(c[62])，.sel(sel))； xtmux3bi63(.xtout(xtout[63])，.a(a[63])，.b(b[63])，.c(c[63])，.sel(sel))；<dpn="d192"/> xtmux3bi64(.xtout(xtout[64])，.a(a[64])，.b(b[64])，.c(c[64])，.sel(sel))； xtmux3bi65(.xtout(xtout[65])，.a(a[65])，.b(b[65])，.c(c[65])，.sel(sel))； xtmux3bi66(.xtout(xtout[66])，.a(a[66])，.b(b[66])，.c(c[66])，.sel(sel))； xtmux3bi67(.xtout(xtout[67])，.a(a[67])，.b(b[67])，.c(c[67])，.sel(sel))； xtmux3bi68(.xtout(xtout[68])，.a(a[68])，.b(b[68])，.c(c[68])，.sel(sel))； xtmux3bi69(.xtout(xtout[69])，.a(a[69])，.b(b[69])，.c(c[69])，.sel(sel))； xtmux3bi70(.xtout(xtout[70])，.a(a[70])，.b(b[70])，.c(c[70])，.sel(sel))； xtmux3bi71(.xtout(xtout[71])，.a(a[71])，.b(b[71])，.c(c[71])，.sel(sel))； xtmux3bi72(.xtout(xtout[72])，.a(a[72])，.b(b[72])，.c(c[72])，.sel(sel))； xtmux3bi73(.xtout(xtout[73])，.a(a[73])，.b(b[73])，.c(c[73])，.sel(sel))； xtmux3bi74(.xtout(xtout[74])，.a(a[74])，.b(b[74])，.c(c[74])，.sel(sel))； xtmux3bi75(.xtout(xtout[75])，.a(a[75])，.b(b[75])，.c(c[75])，.sel(sel))； xtmux3bi76(.xtout(xtout[76])，.a(a[76])，.b(b[76])，.c(c[76])，.sel(sel))； xtmux3bi77(.xtout(xtout[77])，.a(a[77])，.b(b[77])，.c(c[77])，.sel(sel))； xtmux3bi78(.xtout(xtout[78])，.a(a[78])，.b(b[78])，.c(c[78])，.sel(sel))； xtmux3bi79(.xtout(xtout[79])，.a(a[79])，.b(b[79])，.c(c[79])，.sel(sel))； xtmux3bi80(.xtout(xtout[80])，.a(a[80])，.b(b[80])，.c(c[80])，.sel(sel))； xtmux3bi81(.xtout(xtout[81])，.a(a[81])，.b(b[81])，.c(c[81])，.sel(sel))； xtmux3bi82(.xtout(xtout[82])，.a(a[82])，.b(b[82])，.c(c[82])，.sel(sel))； xtmux3bi83(.xtout(xtout[83])，.a(a[83])，.b(b[83])，.c(c[83])，.sel(sel))； xtmux3bi84(.xtout(xtout[84])，.a(a[84])，.b(b[84])，.c(c[84])，.sel(sel))； xtmux3bi85(.xtout(xtout[85])，.a(a[85])，.b(b[85])，.c(c[85])，.sel(sel))； xtmux3bi86(.xtout(xtout[86])，.a(a[86])，.b(b[86])，.c(c[86])，.sel(sel))； xtmux3bi87(.xtout(xtout[87])，.a(a[87])，.b(b[87])，.c(c[87])，.sel(sel))； xtmux3bi88(.xtout(xtout[88])，.a(a[88])，.b(b[88])，.c(c[88])，.sel(sel))； xtmux3bi89(.xtout(xtout[89])，.a(a[89])，.b(b[89])，.c(c[89])，.sel(sel))； xtmux3bi90(.xtout(xtout[90])，.a(a[90])，.b(b[90])，.c(c[90])，.sel(sel))； xtmux3bi91(.xtout(xtout[91])，.a(a[91])，.b(b[91])，.c(c[91])，.sel(sel))； xtmux3bi92(.xtout(xtout[92])，.a(a[92])，.b(b[92])，.c(c[92])，.sel(sel))； xtmux3bi93(.xtout(xtout[93])，.a(a[93])，.b(b[93])，.c(c[93])，.sel(sel))；<dpn="d193"/> xtmux3bi94(.xtout(xtout[94])，.a(a[94])，.b(b[94])，.c(c[94])，.sel(sel))； xtmux3bi95(.xtout(xtout[95])，.a(a[95])，.b(b[95])，.c(c[95])，.sel(sel))； xtmux3bi96(.xtout(xtout[96])，.a(a[96])，.b(b[96])，.c(c[96])，.sel(sel))； xtmux3bi97(.xtout(xtout[97])，.a(a[97])，.b(b[97])，.c(c[97])，.sel(sel))； xtmux3bi98(.xtout(xtout[98])，.a(a[98])，.b(b[98])，.c(c[98])，.sel(sel))； xtmux3bi99(.xtout(xtout[99])，.a(a[99])，.b(b[99])，.c(c[99])，.sel(sel))； xtmux3bi100(.xtout(xtout[100])，.a(a[100])，.b(b[100])，.c(c[100])，.sel(sel))； xtmux3bi101(.xtout(xtout[101])，.a(a[101])，.b(b[101])，.c(c[101])，.sel(sel))； xtmux3bi102(.xtout(xtout[102])，.a(a[102])，.b(b[102])，.c(c[102])，.sel(sel))； xtmux3bi103(.xtout(xtout[103])，.a(a[103])，.b(b[103])，.c(c[103])，.sel(sel))； xtmux3bi104(.xtout(xtout[104])，.a(a[104])，.b(b[104])，.c(c[104])，.sel(sel))； xtmux3bi105(.xtout(xtout[105])，.a(a[105])，.b(b[105])，.c(c[105])，.sel(sel))； xtmux3bi106(.xtout(xtout[106])，.a(a[106])，.b(b[106])，.c(c[106])，.sel(sel))； xtmux3bi107(.xtout(xtout[107])，.a(a[107])，.b(b[107])，.c(c[107])，.sel(sel))； xtmux3bi108(.xtout(xtout[108])，.a(a[108])，.b(b[108])，.c(c[108])，.sel(sel))； xtmux3bi109(.xtout(xtout[109])，.a(a[109])，.b(b[109])，.c(c[109])，.sel(sel))； xtmux3bi110(.xtout(xtout[110])，.a(a[110])，.b(b[110])，.c(c[110])，.sel(sel))； xtmux3bi111(.xtout(xtout[111])，.a(a[111])，.b(b[111])，.c(c[111])，.sel(sel))； xtmux3bi112(.xtout(xtout[112])，.a(a[112])，.b(b[112])，.c(c[112])，.sel(sel))； xtmux3bi113(.xtout(xtout[113])，.a(a[113])，.b(b[113])，.c(c[113])，.sel(sel))； xtmux3bi114(.xtout(xtout[114])，.a(a[114])，.b(b[114])，.c(c[114])，.sel(sel))； xtmux3bi115(.xtout(xtout[115])，.a(a[115])，.b(b[115])，.c(c[115])，.sel(sel))； xtmux3bi116(.xtout(xtout[116])，.a(a[116])，.b(b[116])，.c(c[116])，.sel(sel))； xtmux3bi117(.xtout(xtout[117])，.a(a[117])，.b(b[117])，.c(c[117])，.sel(sel))； xtmux3bi118(.xtout(xtout[118])，.a(a[118])，.b(b[118])，.c(c[118])，.sel(sel))； xtmux3bi119(.xtout(xtout[119])，.a(a[119])，.b(b[119])，.c(c[119])，.sel(sel))； xtmux3bi120(.xtout(xtout[120])，.a(a[120])，.b(b[120])，.c(c[120])，.sel(sel))； xtmux3bi121(.xtout(xtout[121])，.a(a[121])，.b(b[121])，.c(c[121])，.sel(sel))； xtmux3bi122(.xtout(xtout[122])，.a(a[122])，.b(b[122])，.c(c[122])，.sel(sel))； xtmux3bi123(.xtout(xtout[123])，.a(a[123])，.b(b[123])，.c(c[123])，.sel(sel))；<dpn="d194"/> xtmux3bi124(.xtout(xtout[124])，.a(a[124])，.b(b[124])，.c(c[124])，.sel(sel))； xtmux3bi125(.xtout(xtout[125])，.a(a[125])，.b(b[125])，.c(c[125])，.sel(sel))； xtmux3bi126(.xtout(xtout[126])，.a(a[126])，.b(b[126])，.c(c[126])，.sel(sel))； xtmux3bi127(.xtout(xtout[127])，.a(a[127])，.b(b[127])，.c(c[127])，.sel(sel))； xtmux3bi128(.xtout(xtout[128])，.a(a[128])，.b(b[128])，.c(c[128])，.sel(sel))； xtmux3bi129(.xtout(xtout[129])，.a(a[129])，.b(b[129])，.c(c[129])，.sel(sel))； xtmux3bi130(.xtout(xtout[130])，.a(a[130])，.b(b[130])，.c(c[130])，.sel(sel))； xtmux3bi131(.xtout(xtout[131])，.a(a[131])，.b(b[131])，.c(c[131])，.sel(sel))； xtmux3bi132(.xtout(xtout[132])，.a(a[132])，.b(b[132])，.c(c[132])，.sel(sel))； xtmux3bi133(.xtout(xtout[133])，.a(a[133])，.b(b[133])，.c(c[133])，.sel(sel))； xtmux3bi134(.xtout(xtout[134])，.a(a[134])，.b(b[134])，.c(c[134])，.sel(sel))； xtmux3bi135(.xtout(xtout[135])，.a(a[135])，.b(b[135])，.c(c[135])，.sel(sel))； xtmux3bi136(.xtout(xtout[136])，.a(a[136])，.b(b[136])，.c(c[136])，.sel(sel))； xtmux3bi137(.xtout(xtout[137])，.a(a[137])，.b(b[137])，.c(c[137])，.sel(sel))； xtmux3bi138(.xtout(xtout[138])，.a(a[138])，.b(b[138])，.c(c[138])，.sel(sel))； xtmux3bi139(.xtout(xtout[139])，.a(a[139])，.b(b[139])，.c(c[139])，.sel(sel))； xtmux3bi140(.xtout(xtout[140])，.a(a[140])，.b(b[140])，.c(c[140])，.sel(sel))； xtmux3bi141(.xtout(xtout[141])，.a(a[141])，.b(b[141])，.c(c[141])，.sel(sel))； xtmux3bi142(.xtout(xtout[142])，.a(a[142])，.b(b[142])，.c(c[142])，.sel(sel))； xtmux3bi143(.xtout(xtout[143])，.a(a[143])，.b(b[143])，.c(c[143])，.sel(sel))； xtmux3bi144(.xtout(xtout[144])，.a(a[144])，.b(b[144])，.c(c[144])，.sel(sel))； xtmux3bi145(.xtout(xtout[145])，.a(a[145])，.b(b[145])，.c(c[145])，.sel(sel))； xtmux3bi146(.xtout(xtout[146])，.a(a[146])，.b(b[146])，.c(c[146])，.sel(sel))； xtmux3bi147(.xtout(xtout[147])，.a(a[147])，.b(b[147])，.c(c[147])，.sel(sel))； xtmux3bi148(.xtout(xtout[148])，.a(a[148])，.b(b[148])，.c(c[148])，.sel(sel))； xtmux3bi149(.xtout(xtout[149])，.a(a[149])，.b(b[149])，.c(c[149])，.sel(sel))； xtmux3bi150(.xtout(xtout[150])，.a(a[150])，.b(b[150])，.c(c[150])，.sel(sel))； xtmux3bi151(.xtout(xtout[151])，.a(a[151])，.b(b[151])，.c(c[151])，.sel(sel))； xtmux3bi152(.xtout(xtout[152])，.a(a[152])，.b(b[152])，.c(c[152])，.sel(sel))； xtmux3bi153(.xtout(xtout[153])，.a(a[153])，.b(b[153])，.c(c[153])，.sel(sel))；<dpn="d195"/> xtmux3bi154(.xtout(xtout[154])，.a(a[154])，.b(b[154])，.c(c[154])，.sel(sel))； xtmux3bi155(.xtout(xtout[155])，.a(a[155])，.b(b[155])，.c(c[155])，.sel(sel))； xtmux3bi156(.xtout(xtout[156])，.a(a[156])，.b(b[156])，.c(c[156])，.sel(sel))； xtmux3bi157(.xtout(xtout[157])，.a(a[157])，.b(b[157])，.c(c[157])，.sel(sel))； xtmux3bi158(.xtout(xtout[158])，.a(a[158])，.b(b[158])，.c(c[158])，.sel(sel))； xtmux3bi159(.xtout(xtout[159])，.a(a[159])，.b(b[159])，.c(c[159])，.sel(sel))； xtmux3bi160(.xtout(xtout[160])，.a(a[160])，.b(b[160])，.c(c[160])，.sel(sel))； xtmux3bi161(.xtout(xtout[161])，.a(a[161])，.b(b[161])，.c(c[161])，.sel(sel))； xtmux3bi162(.xtout(xtout[162])，.a(a[162])，.b(b[162])，.c(c[162])，.sel(sel))； xtmux3bi163(.xtout(xtout[163])，.a(a[163])，.b(b[163])，.c(c[163])，.sel(sel))； xtmux3bi164(.xtout(xtout[164])，.a(a[164])，.b(b[164])，.c(c[164])，.sel(sel))； xtmux3bi165(.xtout(xtout[165])，.a(a[165])，.b(b[165])，.c(c[165])，.sel(sel))； xtmux3bi166(.xtout(xtout[166])，.a(a[166])，.b(b[166])，.c(c[166])，.sel(sel))； xtmux3bi167(.xtout(xtout[167])，.a(a[167])，.b(b[167])，.c(c[167])，.sel(sel))； xtmux3bi168(.xtout(xtout[168])，.a(a[168])，.b(b[168])，.c(c[168])，.sel(sel))； xtmux3bi169(.xtout(xtout[169])，.a(a[169])，.b(b[169])，.c(c[169])，.sel(sel))； xtmux3bi170(.xtout(xtout[170])，.a(a[170])，.b(b[170])，.c(c[170])，.sel(sel))； xtmux3bi171(.xtout(xtout[171])，.a(a[171])，.b(b[171])，.c(c[171])，.sel(sel))； xtmux3bi172(.xtout(xtout[172])，.a(a[172])，.b(b[172])，.c(c[172])，.sel(sel))； xtmux3bi173(.xtout(xtout[173])，.a(a[173])，.b(b[173])，.c(c[173])，.sel(sel))； xtmux3bi174(.xtout(xtout[174])，.a(a[174])，.b(b[174])，.c(c[174])，.sel(sel))； xtmux3bi175(.xtout(xtout[175])，.a(a[175])，.b(b[175])，.c(c[175])，.sel(sel))； xtmux3bi176(.xtout(xtout[176])，.a(a[176])，.b(b[176])，.c(c[176])，.sel(sel))； xtmux3bi177(.xtout(xtout[177])，.a(a[177])，.b(b[177])，.c(c[177])，.sel(sel))； xtmux3bi178(.xtout(xtout[178])，.a(a[178])，.b(b[178])，.c(c[178])，.sel(sel))； xtmux3bi179(.xtout(xtout[179])，.a(a[179])，.b(b[179])，.c(c[179])，.sel(sel))； xtmux3bi180(.xtout(xtout[180])，.a(a[180])，.b(b[180])，.c(c[180])，.sel(sel))； xtmux3bi181(.xtout(xtout[181])，.a(a[181])，.b(b[181])，.c(c[181])，.sel(sel))； xtmux3bi182(.xtout(xtout[182])，.a(a[182])，.b(b[182])，.c(c[182])，.sel(sel))； xtmux3bi183(.xtout(xtout[183])，.a(a[183])，.b(b[183])，.c(c[183])，.sel(sel))；<dpn="d196"/> xtmux3bi184(.xtout(xtout[184])，.a(a[184])，.b(b[184])，.c(c[l84])，.sel(sel))； xtmux3bi185(.xtout(xtout[185])，.a(a[185])，.b(b[185])，.c(c[185])，.sel(sel))； xtmux3bi186(.xtout(xtout[186])，.a(a[186])，.b(b[186])，.c(c[186])，.sel(sel))； xtmux3bi187(.xtout(xtout[187])，.a(a[187])，.b(b[187])，.c(c[187])，.sel(sel))； xtmux3bi188(.xtout(xtout[188])，.a(a[188])，.b(b[188])，.c(c[188])，.sel(sel))； xtmux3bi189(.xtout(xtout[189])，.a(a[189])，.b(b[189])，.c(c[189])，.sel(sel))； xtmux3bi190(.xtout(xtout[190])，.a(a[190])，.b(b[190])，.c(c[190])，.sel(sel))； xtmux3bi191(.xtout(xtout[191])，.a(a[191])，.b(b[191])，.c(c[191])，.sel(sel))； xtmux3bi192(.xtout(xtout[192])，.a(a[192])，.b(b[192])，.c(c[192])，.sel(sel))； xtmux3bi193(.xtout(xtout[193])，.a(a[193])，.b(b[193])，.c(c[193])，.sel(sel))； xtmux3bi194(.xtout(xtout[194])，.a(a[194])，.b(b[194])，.c(c[194])，.sel(sel))； xtmux3bi195(.xtout(xtout[195])，.a(a[195])，.b(b[195])，.c(c[195])，.sel(sel))； xtmux3bi196(.xtout(xtout[196])，.a(a[196])，.b(b[196])，.c(c[196])，.sel(sel))； xtmux3bi197(.xtout(xtout[197])，.a(a[197])，.b(b[197])，.c(c[197])，.sel(sel))； xtmux3bi198(.xtout(xtout[198])，.a(a[198])，.b(b[198])，.c(c[198])，.sel(sel))； xtmux3bi199(.xtout(xtout[199])，.a(a[199])，.b(b[199])，.c(c[199])，.sel(sel))； xtmux3bi200(.xtout(xtout[200])，.a(a[200])，.b(b[200])，.c(c[200])，.sel(sel))； xtmux3bi201(.xtout(xtout[201])，.a(a[201])，.b(b[201])，.c(c[201])，.sel(sel))； xtmux3bi202(.xtout(xtout[202])，.a(a[202])，.b(b[202])，.c(c[202])，.sel(sel))； xtmux3bi203(.xtout(xtout[203])，.a(a[203])，.b(b[203])，.c(c[203])，.sel(sel))； xtmux3bi204(.xtout(xtout[204])，.a(a[204])，.b(b[204])，.c(c[204])，.sel(sel))； xtmux3bi205(.xtout(xtout[205])，.a(a[205])，.b(b[205])，.c(c[205])，.sel(sel))； xtmux3bi206(.xtout(xtout[206])，.a(a[206])，.b(b[206])，.c(c[206])，.sel(sel))； xtmux3bi207(.xtout(xtout[207])，.a(a[207])，.b(b[207])，.c(c[207])，.sel(sel))； xtmux3bi208(.xtout(xtout[208])，.a(a[208])，.b(b[208])，.c(c[208])，.sel(sel))； xtmux3bi209(.xtout(xtout[209])，.a(a[209])，.b(b[209])，.c(c[209])，.sel(sel))； xtmux3bi210(.xtout(xtout[210])，.a(a[210])，.b(b[210])，.c(c[210])，.sel(sel))； xtmux3bi211(.xtout(xtout[211])，.a(a[211])，.b(b[211])，.c(c[211])，.sel(sel))； xtmux3bi212(.xtout(xtout[212])，.a(a[212])，.b(b[212])，.c(c[212])，.sel(sel))； xtmux3bi213(.xtout(xtout[213])，.a(a[213])，.b(b[213])，.c(c[213])，.sel(sel))；<dpn="d197"/> xtmux3bi214(.xtout(xtout[214])，.a(a[214])，.b(b[214])，.c(c[214])，.sel(sel))； xtmux3bi215(.xtout(xtout[215])，.a(a[215])，.b(b[215])，.c(c[215])，.sel(sel))； xtmux3bi216(.xtout(xtout[216])，.a(a[216])，.b(b[216])，.c(c[216])，.sel(sel))； xtmux3bi217(.xtout(xtout[217])，.a(a[217])，.b(b[217])，.c(c[217])，.sel(sel))； xtmux3bi218(.xtout(xtout[218])，.a(a[218])，.b(b[218])，.c(c[218])，.sel(sel))； xtmux3bi219(.xtout(xtout[219])，.a(a[219])，.b(b[219])，.c(c[219])，.sel(sel))； xtmux3bi220(.xtout(xtout[220])，.a(a[220])，.b(b[220])，.c(c[220])，.sel(sel))； xtmux3bi221(.xtout(xtout[221])，.a(a[221])，.b(b[221])，.c(c[221])，.sel(sel))； xtmux3bi222(.xtout(xtout[222])，.a(a[222])，.b(b[222])，.c(c[222])，.sel(sel))； xtmux3bi223(.xtout(xtout[223])，.a(a[223])，.b(b[223])，.c(c[223])，.sel(sel))； xtmux3bi224(.xtout(xtout[224])，.a(a[224])，.b(b[224])，.c(c[224])，.sel(sel))； xtmux3bi225(.xtout(xtout[225])，.a(a[225])，.b(b[225])，.c(c[225])，.sel(sel))； xtmux3bi226(.xtout(xtout[226])，.a(a[226])，.b(b[226])，.c(c[226])，.sel(sel))； xtmux3bi227(.xtout(xtout[227])，.a(a[227])，.b(b[227])，.c(c[227])，.sel(sel)； xtmux3bi228(.xtout(xtout[228])，.a(a[228])，.b(b[228])，.c(c[228])，.sel(sel))； xtmux3bi229(.xtout(xtout[229])，.a(a[229])，.b(b[229])，.c(c[229])，.sel(sel))； xtmux3bi230(.xtout(xtout[230])，.a(a[230])，.b(b[230])，.c(c[230])，.sel(sel))； xtmux3bi231(.xtout(xtout[231])，.a(a[231])，.b(b[231])，.c(c[231])，.sel(sel))； xtmux3bi232(.xtout(xtout[232])，.a(a[232])，.b(b[232])，.c(c[232])，.sel(sel))； xtmux3bi233(.xtout(xtout[233])，.a(a[233])，.b(b[233])，.c(c[233])，.sel(sel))； xtmux3bi234(.xtout(xtout[234])，.a(a[234])，.b(b[234])，.c(c[234])，.sel(sel))； xtmux3bi235(.xtout(xtout[235])，.a(a[235])，.b(b[235])，.c(c[235])，.sel(sel))； xtmux3bi236(.xtout(xtout[236])，.a(a[236])，.b(b[236])，.c(c[236])，.sel(sel))； xtmux3bi237(.xtout(xtout[237])，.a(a[237])，.b(b[237])，.c(c[237])，.sel(sel))； xtmux3bi238(.xtout(xtout[238])，.a(a[238])，.b(b[238])，.c(c[238])，.sel(sel))； xtmux3bi239(.xtout(xtout[239])，.a(a[239])，.b(b[239])，.c(c[239])，.sel(sel))； xtmux3bi240(.xtout(xtout[240])，.a(a[240])，.b(b[240])，.c(c[240])，.sel(se1))； xtmux3bi241(.xtout(xtout[241])，.a(a[241])，.b(b[241])，.c(c[241])，.sel(sel))； xtmux3bi242(.xtout(xtout[242])，.a(a[242])，.b(b[242])，.c(c[242])，.sel(sel))； xtmux3bi243(.xtout(xtout[243])，.a(a[243])，.b(b[243])，.c(c[243])，.sel(sel))；<dpn="d198"/> xtmux3bi244(.xtout(xtout[244])，.a(a[244])，.b(b[244])，.c(c[244])，.sel(sel))； xtmux3bi245(.xtout(xtout[245])，.a(a[245])，.b(b[245])，.c(c[245])，.sel(sel))； xtmux3bi246(.xtout(xtout[246])，.a(a[246])，.b(b[246])，.c(c[246])，.sel(sel))； xtmux3bi247(.xtout(xtout[247])，.a(a[247])，.b(b[247])，.c(c[247])，.sel(sel))； xtmux3bi248(.xtout(xtout[248])，.a(a[248])，.b(b[248])，.c(c[248])，.sel(sel))； xtmux3bi249(.xtout(xtout[249])，.a(a[249])，.b(b[249])，.c(c[249])，.sel(sel))； xtmux3bi250(.xtout(xtout[250])，.a(a[250])，.b(b[250])，.c(c[250])，.sel(sel))； xtmux3bi251(.xtout(xtout[251])，.a(a[251])，.b(b[251])，.c(c[251])，.sel(sel))； xtmux3bi252(.xtout(xtout[252])，.a(a[252])，.b(b[252])，.c(c[252])，.sel(sel))； xtmux3bi253(.xtout(xtout[253])，.a(a[253])，.b(b[253])，.c(c[253])，.sel(sel))； xtmux3bi254(.xtout(xtout[254])，.a(a[254])，.b(b[254])，.c(c[254])，.sel(sel))； xtmux3bi255(.xtout(xtout[255])，.a(a[255])，.b(b[255])，.c(c[255])，.sel(sel))； xtmux3bi256(.xtout(xtout[256])，.a(a[256])，.b(b[256])，.c(c[256])，.sel(sel))； xtmux3bi257(.xtout(xtout[257])，.a(a[257])，.b(b[257])，.c(c[257])，.sel(sel))； xtmux3bi258(.xtout(xtout[258])，.a(a[258])，.b(b[258])，.c(c[258])，.sel(sel))； xtmux3bi259(.xtout(xtout[259])，.a(a[259])，.b(b[259])，.c(c[259])，.sel(sel))； xtmux3bi260(.xtout(xtout[260])，.a(a[260])，.b(b[260])，.c(c[260])，.sel(sel))； xtmux3bi261(.xtout(xtout[261])，.a(a[261])，.b(b[261])，.c(c[261])，.sel(sel))； xtmux3bi262(.xtout(xtout[262])，.a(a[262])，.b(b[262])，.c(c[262])，.sel(sel))； xtmux3bi263(.xtout(xtout[263])，.a(a[263])，.b(b[263])，.c(c[263])，.sel(sel))； xtmux3bi264(.xtout(xtout[264])，.a(a[264])，.b(b[264])，.c(c[264])，.sel(sel))； xtmux3bi265(.xtout(xtout[265])，.a(a[265])，.b(b[265])，.c(c[265])，.sel(sel))； xtmux3bi266(.xtout(xtout[266])，.a(a[266])，.b(b[266])，.c(c[266])，.sel(sel))； xtmux3bi267(.xtout(xtout[267])，.a(a[267])，.b(b[267])，.c(c[267])，.sel(sel))； xtmux3bi268(.xtout(xtout[268])，.a(a[268])，.b(b[268])，.c(c[268])，.sel(sel))； xtmux3bi269(.xtout(xtout[269])，.a(a[269])，.b(b[269])，.c(c[269])，.sel(sel))； xtmux3bi270(.xtout(xtout[270])，.a(a[270])，.b(b[270])，.c(c[270])，.sel(sel))； xtmux3bi271(.xtout(xtout[271])，.a(a[271])，.b(b[271])，.c(c[271])，.sel(sel))； xtmux3bi272(.xtout(xtout[272])，.a(a[272])，.b(b[272])，.c(c[272])，.sel(sel))； xtmux3bi273(.xtout(xtout[273])，.a(a[273])，.b(b[273])，.c(c[273])，.sel(sel))；<dpn="d199"/> xtmux3bi274(.xtout(xtout[274])，.a(a[274])，.b(b[274])，.c(c[274])，.sel(sel))； xtmux3bi275(.xtout(xtout[275])，.a(a[275])，.b(b[275])，.c(c[275])，.sel(sel))； xtmux3bi276(.xtout(xtout[276])，.a(a[276])，.b(b[276])，.c(c[276])，.sel(sel))； xtmux3bi277(.xtout(xtout[277])，.a(a[277])，.b(b[277])，.c(c[277])，.sel(sel))； xtmux3bi278(.xtout(xtout[278])，.a(a[278])，.b(b[278])，.c(c[278])，.sel(sel))； xtmux3bi279(.xtout(xtout[279])，.a(a[279])，.b(b[279])，.c(c[279])，.sel(sel))； xtmux3bi280(.xtout(xtout[280])，.a(a[280])，.b(b[280])，.c(c[280])，.sel(sel))； xtmux3bi281(.xtout(xtout[281])，.a(a[281])，.b(b[281])，.c(c[281])，.sel(sel))； xtmux3bi282(.xtout(xtout[282])，.a(a[282])，.b(b[282])，.c(c[282])，.sel(sel))； xtmux3bi283(.xtout(xtout[283])，.a(a[283])，.b(b[283])，.c(c[283])，.sel(sel))； xtmux3bi284(.xtout(xtout[284])，.a(a[284])，.b(b[284])，.c(c[284])，.sel(sel))； xtmux3bi285(.xtout(xtout[285])，.a(a[285])，.b(b[285])，.c(c[285])，.sel(sel))； xtmux3bi286(.xtout(xtout[286])，.a(a[286])，.b(b[286])，.c(c[286])，.sel(sel))； xtmux3bi287(.xtout(xtout[287])，.a(a[287])，.b(b[287])，.c(c[287])，.sel(sel))； xtmux3bi288(.xtout(xtout[288])，.a(a[288])，.b(b[288])，.c(c[288])，.sel(sel))； xtmux3bi289(.xtout(xtout[289])，.a(a[289])，.b(b[289])，.c(c[289])，.sel(sel))； xtmux3bi290(.xtout(xtout[290])，.a(a[290])，.b(b[290])，.c(c[290])，.sel(sel))； xtmux3bi291(.xtout(xtout[291])，.a(a[291])，.b(b[291])，.c(c[291])，.sel(sel))； xtmux3bi292(.xtout(xtout[292])，.a(a[292])，.b(b[292])，.c(c[292])，.sel(sel))； xtmux3bi293(.xtout(xtout[293])，.a(a[293])，.b(b[293])，.c(c[293])，.sel(sel))； xtmux3bi294(.xtout(xtout[294])，.a(a[294])，.b(b[294])，.c(c[294])，.sel(sel))； xtmux3bi295(.xtout(xtout[295])，.a(a[295])，.b(b[295])，.c(c[295])，.sel(sel))； xtmux3bi296(.xtout(xtout[296])，.a(a[296])，.b(b[296])，.c(c[296])，.sel(sel))； xtmux3bi297(.xtout(xtout[297])，.a(a[297])，.b(b[297])，.c(c[297])，.sel(sel))； xtmux3bi298(.xtout(xtout[298])，.a(a[298])，.b(b[298])，.c(c[298])，.sel(sel))； xtmux3bi299(.xtout(xtout[299])，.a(a[299])，.b(b[299])，.c(c[299])，.sel(sel))； xtmux3bi300(.xtout(xtout[300])，.a(a[300])，.b(b[300])，.c(c[300])，.sel(sel))； xtmux3bi301(.xtout(xtout[301])，.a(a[301])，.b(b[301])，.c(c[301])，.sel(sel))； xtmux3bi302(.xtout(xtout[302])，.a(a[302])，.b(b[302])，.c(c[302])，.sel(sel))； xtmux3bi303(.xtout(xtout[303])，.a(a[303])，.b(b[303])，.c(c[303])，.sel(sel))；<dpn="d200"/> xtmux3bi304(.xtout(xtout[304])，.a(a[304])，.b(b[304])，.c(c[304])，.sel(sel))； xtmux3bi305(.xtout(xtout[305])，.a(a[305])，.b(b[305])，.c(c[305])，.sel(sel))； xtmux3bi306(.xtout(xtout[306])，.a(a[306])，.b(b[306])，.c(c[306])，.sel(sel))； xtmux3bi307(.xtout(xtout[307])，.a(a[307])，.b(b[307])，.c(c[307])，.sel(sel))； xtmux3bi308(.xtout(xtout[308])，.a(a[308])，.b(b[308])，.c(c[308])，.sel(sel))； xtmux3bi309(.xtout(xtout[309])，.a(a[309])，.b(b[309])，.c(c[309])，.sel(sel))； xtmux3bi310(.xtout(xtout[310])，.a(a[310])，.b(b[310])，.c(c[310])，.sel(sel))； xtmux3bi311(.xtout(xtout[311])，.a(a[311])，.b(b[311])，.c(c[311])，.sel(sel))； xtmux3bi312(.xtout(xtout[312])，.a(a[312])，.b(b[312])，.c(c[312])，.sel(sel))； xtmux3bi313(.xtout(xtout[313])，.a(a[313])，.b(b[313])，.c(c[313])，.sel(sel))； xtmux3bi314(.xtout(xtout[314])，.a(a[314])，.b(b[314])，.c(c[314])，.sel(sel))； xtmux3bi315(.xtout(xtout[315])，.a(a[315])，.b(b[315])，.c(c[315])，.sel(sel))； xtmux3bi316(.xtout(xtout[316])，.a(a[316])，.b(b[316])，.c(c[316])，.sel(sel)； xtmux3bi317(.xtout(xtout[317])，.a(a[317])，.b(b[317])，.c(c[317])，.sel(sel)； xtmux3bi318(.xtout(xtout[318])，.a(a[318])，.b(b[318])，.c(c[318])，.sel(sel)； xtmux3bi319(.xtout(xtout[319])，.a(a[319])，.b(b[319])，.c(c[319])，.sel(sel)； xtmux3bi320(.xtout(xtout[320])，.a(a[320])，.b(b[320])，.c(c[320])，.sel(sel)； xtmux3bi321(.xtout(xtout[321])，.a(a[321])，.b(b[321])，.c(c[321])，.sel(sel)； xtmux3bi322(.xtout(xtout[322])，.a(a[322])，.b(b[322])，.c(c[322])，.sel(sel)； xtmux3bi323(.xtout(xtout[323])，.a(a[323])，.b(b[323])，.c(c[323])，.sel(sel))； xtmux3bi324(.xtout(xtout[324])，.a(a[324])，.b(b[324])，.c(c[324])，.sel(sel))； xtmux3bi325(.xtout(xtout[325])，.a(a[325])，.b(b[325])，.c(c[325])，.sel(sel))； xtmux3bi326(.xtout(xtout[326])，.a(a[326])，.b(b[326])，.c(c[326])，.sel(sel))； xtmux3bi327(.xtout(xtout[327])，.a(a[327])，.b(b[327])，.c(c[327])，.sel(sel))； xtmux3bi328(.xtout(xtout[328])，.a(a[328])，.b(b[328])，.c(c[328])，.sel(sel))； xtmux3bi329(.xtout(xtout[329])，.a(a[329])，.b(b[329])，.c(c[329])，.sel(sel))； xtmux3bi330(.xtout(xtout[330])，.a(a[330])，.b(b[330])，.c(c[330])，.sel(sel))； xtmux3bi331(.xtout(xtout[331])，.a(a[331])，.b(b[331])，.c(c[331])，.sel(sel))； xtmux3bi332(.xtout(xtout[332])，.a(a[332])，.b(b[332])，.c(c[332])，.sel(sel))； xtmux3bi333(.xtout(xtout[333])，.a(a[333])，.b(b[333])，.c(c[333])，.sel(sel))；<dpn="d201"/> xtmux3bi334(.xtout(xtout[334])，.a(a[334])，.b(b[334])，.c(c[334])，.sel(sel))； xtmux3bi335(.xtout(xtout[335])，.a(a[335])，.b(b[335])，.c(c[335])，.sel(sel))； xtmux3bi336(.xtout(xtout[336])，.a(a[336])，.b(b[336])，.c(c[336])，.sel(sel))； xtmux3bi337(.xtout(xtout[337])，.a(a[337])，.b(b[337])，.c(c[337])，.sel(sel))； xtmux3bi338(.xtout(xtout[338])，.a(a[338])，.b(b[338])，.c(c[338])，.sel(sel))； xtmux3bi339(.xtout(xtout[339])，.a(a[339])，.b(b[339])，.c(c[339])，.sel(sel))； xtmux3bi340(.xtout(xtout[340])，.a(a[340])，.b(b[340])，.c(c[340])，.sel(sel))； xtmux3bi341(.xtout(xtout[341])，.a(a[341])，.b(b[341])，.c(c[341])，.sel(sel))； xtmux3bi342(.xtout(xtout[342])，.a(a[342])，.b(b[342])，.c(c[342])，.sel(sel))； xtmux3bi343(.xtout(xtout[343])，.a(a[343])，.b(b[343])，.c(c[343])，.sel(sel))； xtmux3bi344(.xtout(xtout[344])，.a(a[344])，.b(b[344])，.c(c[344])，.sel(sel))； xtmux3bi345(.xtout(xtout[345])，.a(a[345])，.b(b[345])，.c(c[345])，.sel(sel))； xtmux3bi346(.xtout(xtout[346])，.a(a[346])，.b(b[346])，.c(c[346])，.sel(sel))； xtmux3bi347(.xtout(xtout[347])，.a(a[347])，.b(b[347])，.c(c[347])，.sel(sel))； xtmux3bi348(.xtout(xtout[348])，.a(a[348])，.b(b[348])，.c(c[348])，.sel(sel))； xtmux3bi349(.xtout(xtout[349])，.a(a[349])，.b(b[349])，.c(c[349])，.sel(sel))； xtmux3bi350(.xtout(xtout[350])，.a(a[350])，.b(b[350])，.c(c[350])，.sel(sel))； xtmux3bi351(.xtout(xtout[351])，.a(a[351])，.b(b[351])，.c(c[351])，.sel(sel))； xtmux3bi352(.xtout(xtout[352])，.a(a[352])，.b(b[352])，.c(c[352])，.sel(sel))； xtmux3bi353(.xtout(xtout[353])，.a(a[353])，.b(b[353])，.c(c[353])，.sel(sel))； xtmux3bi354(.xtout(xtout[354])，.a(a[354])，.b(b[354])，.c(c[354])，.sel(sel))； xtmux3bi355(.xtout(xtout[355])，.a(a[355])，.b(b[355])，.c(c[355])，.sel(sel))； xtmux3bi356(.xtout(xtout[356])，.a(a[356])，.b(b[356])，.c(c[356])，.sel(sel))； xtmux3bi357(.xtout(xtout[357])，.a(a[357])，.b(b[357])，.c(c[357])，.sel(sel))； xtmux3bi358(.xtout(xtout[358])，.a(a[358])，.b(b[358])，.c(c[358])，.sel(sel))； xtmux3bi359(.xtout(xtout[359])，.a(a[359])，.b(b[359])，.c(c[359])，.sel(sel))； xtmux3bi360(.xtout(xtout[360])，.a(a[360])，.b(b[360])，.c(c[360])，.sel(sel))； xtmux3bi361(.xtout(xtout[361])，.a(a[361])，.b(b[361])，.c(c[361])，.sel(sel))； xtmux3bi362(.xtout(xtout[362])，.a(a[362])，.b(b[362])，.c(c[362])，.sel(sel))； xtmux3bi363(.xtout(xtout[363])，.a(a[363])，.b(b[363])，.c(c[363])，.sel(sel))；<dpn="d202"/> xtmux3bi364(.xtout(xtout[364])，.a(a[364])，.b(b[364])，.c(c[364])，.sel(sel))； xtmux3bi365(.xtout(xtout[365])，.a(a[365])，.b(b[365])，.c(c[365])，.sel(sel))； xtmux3bi366(.xtout(xtout[366])，.a(a[366])，.b(b[366])，.c(c[366])，.sel(sel))； xtmux3bi367(.xtout(xtout[367])，.a(a[367])，.b(b[367])，.c(c[367])，.sel(sel))； xtmux3bi368(.xtout(xtout[368])，.a(a[368])，.b(b[368])，.c(c[368])，.sel(sel))； xtmux3bi369(.xtout(xtout[369])，.a(a[369])，.b(b[369])，.c(c[369])，.sel(sel))； xtmux3bi370(.xtout(xtout[370])，.a(a[370])，.b(b[370])，.c(c[370])，.sel(sel))； xtmux3bi371(.xtout(xtout[371])，.a(a[371])，.b(b[371])，.c(c[371])，.sel(sel))； xtmux3bi372(.xtout(xtout[372])，.a(a[372])，.b(b[372])，.c(c[372])，.sel(sel))； xtmux3bi373(.xtout(xtout[373])，.a(a[373])，.b(b[373])，.c(c[373])，.sel(sel))； xtmux3bi374(.xtout(xtout[374])，.a(a[374])，.b(b[374])，.c(c[374])，.sel(sel))； xtmux3bi375(.xtout(xtout[375])，.a(a[375])，.b(b[375])，.c(c[375])，.sel(sel))； xtmux3bi376(.xtout(xtout[376])，.a(a[376])，.b(b[376])，.c(c[376])，.sel(sel))； xtmux3bi377(.xtout(xtout[377])，.a(a[377])，.b(b[377])，.c(c[377])，.sel(sel))； xtmux3bi378(.xtout(xtout[378])，.a(a[378])，.b(b[378])，.c(c[378])，.sel(sel))； xtmux3bi379(.xtout(xtout[379])，.a(a[379])，.b(b[379])，.c(c[379])，.sel(sel))； xtmux3bi380(.xtout(xtout[380])，.a(a[380])，.b(b[380])，.c(c[380])，.sel(sel))； xtmux3bi381(.xtout(xtout[381])，.a(a[381])，.b(b[381])，.c(c[381])，.sel(sel))； xtmux3bi382(.xtout(xtout[382])，.a(a[382])，.b(b[382])，.c(c[382])，.sel(sel))； xtmux3bi383(.xtout(xtout[383])，.a(a[383])，.b(b[383])，.c(c[383])，.sel(sel))； xtmux3bi384(.xtout(xtout[384])，.a(a[384])，.b(b[384])，.c(c[384])，.sel(sel))； xtmux3bi385(.xtout(xtout[385])，.a(a[385])，.b(b[385])，.c(c[385])，.sel(sel))； xtmux3bi386(.xtout(xtout[386])，.a(a[386])，.b(b[386])，.c(c[386])，.sel(sel))； xtmux3bi387(.xtout(xtout[387])，.a(a[387])，.b(b[387])，.c(c[387])，.sel(sel))； xtmux3bi388(.xtout(xtout[388])，.a(a[388])，.b(b[388])，.c(c[388])，.sel(sel))； xtmux3bi389(.xtout(xtout[389])，.a(a[389])，.b(b[389])，.c(c[389])，.sel(sel))； xtmux3bi390(.xtout(xtout[390])，.a(a[390])，.b(b[390])，.c(c[390])，.sel(sel))； xtmux3bi391(.xtout(xtout[391])，.a(a[391])，.b(b[391])，.c(c[391])，.sel(sel))； xtmux3bi392(.xtout(xtout[392])，.a(a[392])，.b(b[392])，.c(c[392])，.sel(sel))； xtmux3bi393(.xtout(xtout[393])，.a(a[393])，.b(b[393])，.c(c[393])，.sel(sel))；<dpn="d203"/> xtmux3bi394(.xtout(xtout[394])，.a(a[394])，.b(b[394])，.c(c[394])，.sel(sel))； xtmux3bi395(.xtout(xtout[395])，.a(a[395])，.b(b[395])，.c(c[395])，.sel(sel))； xtmux3bi396(.xtout(xtout[396])，.a(a[396])，.b(b[396])，.c(c[396])，.sel(sel))； xtmux3bi397(.xtout(xtout[397])，.a(a[397])，.b(b[397])，.c(c[397])，.sel(sel))； xtmux3bi398(.xtout(xtout[398])，.a(a[398])，.b(b[398])，.c(c[398])，.sel(sel))； xtmux3bi399(.xtout(xtout[399])，.a(a[399])，.b(b[399])，.c(c[399])，.sel(sel))； xtmux3bi400(.xtout(xtout[400])，.a(a[400])，.b(b[400])，.c(c[400])，.sel(sel))； xtmux3bi401(.xtout(xtout[401])，.a(a[401])，.b(b[401])，.c(c[401])，.sel(sel))； xtmux3bi402(.xtout(xtout[402])，.a(a[402])，.b(b[402])，.c(c[402])，.sel(sel))； xtmux3bi403(.xtout(xtout[403])，.a(a[403])，.b(b[403])，.c(c[403])，.sel(sel))； xtmux3bi404(.xtout(xtout[404])，.a(a[404])，.b(b[404])，.c(c[404])，.sel(sel))； xtmux3bi405(.xtout(xtout[405])，.a(a[405])，.b(b[405])，.c(c[405])，.sel(sel))； xtmux3bi406(.xtout(xtout[406])，.a(a[406])，.b(b[406])，.c(c[406])，.sel(sel))； xtmux3bi407(.xtout(xtout[407])，.a(a[407])，.b(b[407])，.c(c[407])，.sel(sel))； xtmux3bi408(.xtout(xtout[408])，.a(a[408])，.b(b[408])，.c(c[408])，.sel(sel))； xtmux3bi409(.xtout(xtout[409])，.a(a[409])，.b(b[409])，.c(c[409])，.sel(sel))； xtmux3bi410(.xtout(xtout[410])，.a(a[410])，.b(b[410])，.c(c[410])，.sel(sel))； xtmux3bi411(.xtout(xtout[411])，.a(a[411])，.b(b[411])，.c(c[411])，.sel(sel))； xtmux3bi412(.xtout(xtout[412])，.a(a[412])，.b(b[412])，.c(c[412])，.sel(sel))； xtmux3bi413(.xtout(xtout[413])，.a(a[413])，.b(b[413])，.c(c[413])，.sel(sel))； xtmux3bi414(.xtout(xtout[414])，.a(a[414])，.b(b[414])，.c(c[414])，.sel(sel))； xtmux3bi415(.xtout(xtout[415])，.a(a[415])，.b(b[415])，.c(c[415])，.sel(sel))； xtmux3bi416(.xtout(xtout[416])，.a(a[416])，.b(b[416])，.c(c[416])，.sel(sel))； xtmux3bi417(.xtout(xtout[417])，.a(a[417])，.b(b[417])，.c(c[417])，.sel(sel))； xtmux3bi418(.xtout(xtout[418])，.a(a[418])，.b(b[418])，.c(c[418])，.sel(sel))； xtmux3bi419(.xtout(xtout[419])，.a(a[419])，.b(b[419])，.c(c[419])，.sel(sel))； xtmux3bi420(.xtout(xtout[420])，.a(a[420])，.b(b[420])，.c(c[420])，.sel(sel))； xtmux3bi421(.xtout(xtout[421])，.a(a[421])，.b(b[421])，.c(c[421])，.sel(sal))； xtmux3bi422(.xtout(xtout[422])，.a(a[422])，.b(b[422])，.c(c[422])，.sel(sel))； xtmux3bi423(.xtout(xtout[423])，.a(a[423])，.b(b[423])，.c(c[423])，.sel(sel))；<dpn="d204"/> xtmux3bi424(.xtout(xtout[424])，.a(a[424])，.b(b[424])，.c(c[424])，.sel(sel))； xtmux3bi425(.xtout(xtout[425])，.a(a[425])，.b(b[425])，.c(c[425])，.sel(sel))； xtmux3bi426(.xtout(xtout[426])，.a(a[426])，.b(b[426])，.c(c[426])，.sel(sel))； xtmux3bi427(.xtout(xtout[427])，.a(a[427])，.b(b[427])，.c(c[427])，.sel(sel))； xtmux3bi428(.xtout(xtout[428])，.a(a[428])，.b(b[428])，.c(c[428])，.sel(sel))； xtmux3bi429(.xtout(xtout[429])，.a(a[429])，.b(b[429])，.c(c[429])，.sel(sel))； xtmux3bi430(.xtout(xtout[430])，.a(a[430])，.b(b[430])，.c(c[430])，.sel(sel))； xtmux3bi431(.xtout(xtout[431])，.a(a[431])，.b(b[431])，.c(c[431])，.sel(sel))； xtmux3bi432(.xtout(xtout[432])，.a(a[432])，.b(b[432])，.c(c[432])，.sel(sel))； xtmux3bi433(.xtout(xtout[433])，.a(a[433])，.b(b[433])，.c(c[433])，.sel(sel))； xtmux3bi434(.xtout(xtout[434])，.a(a[434])，.b(b[434])，.c(c[434])，.sel(sel))； xtmux3bi435(.xtout(xtout[435])，.a(a[435])，.b(b[435])，.c(c[435])，.sel(sel))； xtmux3bi436(.xtout(xtout[436])，.a(a[436])，.b(b[436])，.c(c[436])，.sel(sel))； xtmux3bi437(.xtout(xtout[437])，.a(a[437])，.b(b[437])，.c(c[437])，.sel(sel))； xtmux3bi438(.xtout(xtout[438])，.a(a[438])，.b(b[438])，.c(c[438])，.sel(sel))； xtmux3bi439(.xtout(xtout[439])，.a(a[439])，.b(b[439])，.c(c[439])，.sel(sel))； xtmux3bi440(.xtout(xtout[440])，.a(a[440])，.b(b[440])，.c(c[440])，.sel(sel))； xtmux3bi441(.xtout(xtout[441])，.a(a[441])，.b(b[441])，.c(c[441])，.sel(sel))； xtmux3bi442(.xtout(xtout[442])，.a(a[442])，.b(b[442])，.c(c[442])，.sel(sel))； xtmux3bi443(.xtout(xtout[443])，.a(a[443])，.b(b[443])，.c(c[443])，.sel(sel))； xtmux3bi444(.xtout(xtout[444])，.a(a[444])，.b(b[444])，.c(c[444])，.sel(sel))； xtmux3bi445(.xtout(xtout[445])，.a(a[445])，.b(b[445])，.c(c[445])，.sel(sel))； xtmux3bi446(.xtout(xtout[446])，.a(a[446])，.b(b[446])，.c(c[446])，.sel(sel))； xtmux3bi447(.xtout(xtout[447])，.a(a[447])，.b(b[447])，.c(c[447])，.sel(sel))； xtmux3bi448(.xtout(xtout[448])，.a(a[448])，.b(b[448])，.c(c[448])，.sel(sel))； xtmux3bi449(.xtout(xtout[449])，.a(a[449])，.b(b[449])，.c(c[449])，.sel(sel))； xtmux3bi450(.xtout(xtout[450])，.a(a[450])，.b(b[450])，.c(c[450])，.sel(sel))； xtmux3bi451(.xtout(xtout[451])，.a(a[451])，.b(b[451])，.c(c[451])，.sel(sel))； xtmux3bi452(.xtout(xtout[452])，.a(a[452])，.b(b[452])，.c(c[452])，.sel(sel))； xtmux3bi453(.xtout(xtout[453])，.a(a[453])，.b(b[453])，.c(c[453])，.sel(sel))；<dpn="d205"/> xtmux3bi454(.xtout(xtout[454])，.a(a[454])，.b(b[454])，.c(c[454])，.sel(sel))； xtmux3bi455(.xtout(xtout[455])，.a(a[455])，.b(b[455])，.c(c[455])，.sel(sel))； xtmux3bi456(.xtout(xtout[456])，.a(a[456])，.b(b[456])，.c(c[456])，.sel(sel))； xtmux3bi457(.xtout(xtout[457])，.a(a[457])，.b(b[457])，.c(c[457])，.sel(sel))； xtmux3bi458(.xtout(xtout[458])，.a(a[458])，.b(b[458])，.c(c[458])，.sel(sel))； xtmux3bi459(.xtout(xtout[459])，.a(a[459])，.b(b[459])，.c(c[459])，.sel(sel))； xtmux3bi460(.xtout(xtout[460])，.a(a[460])，.b(b[460])，.c(c[460])，.sel(sel))； xtmux3bi461(.xtout(xtout[461])，.a(a[461])，.b(b[461])，.c(c[461])，.sel(sel))； xtmux3bi462(.xtout(xtout[462])，.a(a[462])，.b(b[462])，.c(c[462])，.sel(sel))； xtmux3bi463(.xtout(xtout[463])，.a(a[463])，.b(b[463])，.c(c[463])，.sel(sel))； xtmux3bi464(.xtout(xtout[464])，.a(a[464])，.b(b[464])，.c(c[464])，.sel(sel))； xtmux3bi465(.xtout(xtout[465])，.a(a[465])，.b(b[465])，.c(c[465])，.sel(sel))； xtmux3bi466(.xtout(xtout[466])，.a(a[466])，.b(b[466])，.c(c[466])，.sel(sel))； xtmux3bi467(.xtout(xtout[467])，.a(a[467])，.b(b[467])，.c(c[467])，.sel(sel))； xtmux3bi468(.xtout(xtout[468])，.a(a[468])，.b(b[468])，.c(c[468])，.sel(sel))； xtmux3bi469(.xtout(xtout[469])，.a(a[469])，.b(b[469])，.c(c[469])，.sel(sel))； xtmux3bi470(.xtout(xtout[470])，.a(a[470])，.b(b[470])，.c(c[470])，.sel(sel))； xtmux3bi471(.xtout(xtout[471])，.a(a[471])，.b(b[471])，.c(c[471])，.sel(sel))； xtmux3bi472(.xtout(xtout[472])，.a(a[472])，.b(b[472])，.c(c[472])，.sel(sel))； xtmux3bi473(.xtout(xtout[473])，.a(a[473])，.b(b[473])，.c(c[473])，.sel(sel))； xtmux3bi474(.xtout(xtout[474])，.a(a[474])，.b(b[474])，.c(c[474])，.sel(sel))； xtmux3bi475(.xtout(xtout[475])，.a(a[475])，.b(b[475])，.c(c[475])，.sel(sel))； xtmux3bi476(.xtout(xtout[476])，.a(a[476])，.b(b[476])，.c(c[476])，.sel(sel))； xtmux3bi477(.xtout(xtout[477])，.a(a[477])，.b(b[477])，.c(c[477])，.sel(sel))； xtmux3bi478(.xtout(xtout[478])，.a(a[478])，.b(b[478])，.c(c[478])，.sel(sel))； xtmux3bi479(.xtout(xtout[479])，.a(a[479])，.b(b[479])，.c(c[479])，.sel(sel))； xtmux3bi480(.xtout(xtout[480])，.a(a[480])，.b(b[480])，.c(c[480])，.sel(sel))； xtmux3bi481(.xtout(xtout[481])，.a(a[481])，.b(b[481])，.c(c[481])，.sel(sel))； xtmux3bi482(.xtout(xtout[482])，.a(a[482])，.b(b[482])，.c(c[482])，.sel(sel))； xtmux3bi483(.xtout(xtout[483])，.a(a[483])，.b(b[483])，.c(c[483])，.sel(sel))；<dpn="d206"/> xtmux3bi484(.xtout(xtout[484])，.a(a[484])，.b(b[484])，.c(c[484])，.sel(sel))； xtmux3bi485(.xtout(xtout[485])，.a(a[485])，.b(b[485])，.c(c[485])，.sel(sel))； xtmux3bi486(.xtout(xtout[486])，.a(a[486])，.b(b[486])，.c(c[486])，.sel(sel))； xtmux3bi487(.xtout(xtout[487])，.a(a[487])，.b(b[487])，.c(c[487])，.sel(sel))； xtmux3bi488(.xtout(xtout[488])，.a(a[488])，.b(b[488])，.c(c[488])，.sel(sel))； xtmux3bi489(.xtout(xtout[489])，.a(a[489])，.b(b[489])，.c(c[489])，.sel(sel))； xtmux3bi490(.xtout(xtout[490])，.a(a[490])，.b(b[490])，.c(c[490])，.sel(sel))； xtmux3bi491(.xtout(xtout[491])，.a(a[491])，.b(b[491])，.c(c[491])，.sel(sel))； xtmux3bi492(.xtout(xtout[492])，.a(a[492])，.b(b[492])，.c(c[492])，.sel(sel))； xtmux3bi493(.xtout(xtout[493])，.a(a[493])，.b(b[493])，.c(c[493])，.sel(sel))； xtmux3bi494(.xtout(xtout[494])，.a(a[494])，.b(b[494])，.c(c[494])，.sel(sel))； xtmux3bi495(.xtout(xtout[495])，.a(a[495])，.b(b[495])，.c(c[495])，.sel(sel))； xtmux3bi496(.xtout(xtout[496])，.a(a[496])，.b(b[496])，.c(c[496])，.sel(sel))； xtmux3bi497(.xtout(xtout[497])，.a(a[497])，.b(b[497])，.c(c[497])，.sel(sel))； xtmux3bi498(.xtout(xtout[498])，.a(a[498])，.b(b[498])，.c(c[498])，.sel(sel))； xtmux3bi499(.xtout(xtout[499])，.a(a[499])，.b(b[499])，.c(c[499])，.sel(sel))； xtmux3bi500(.xtout(xtout[500])，.a(a[500])，.b(b[500])，.c(c[500])，.sel(sel))； xtmux3bi501(.xtout(xtout[501])，.a(a[501])，.b(b[501])，.c(c[501])，.sel(sel))； xtmux3bi502(.xtout(xtout[502])，.a(a[502])，.b(b[502])，.c(c[502])，.sel(sel))； xtmux3bi503(.xtout(xtout[503])，.a(a[503])，.b(b[503])，.c(c[503])，.sel(sel))； xtmux3bi504(.xtout(xtout[504])，.a(a[504])，.b(b[504])，.c(c[504])，.sel(sel))； xtmux3bi505(.xtout(xtout[505])，.a(a[505])，.b(b[505])，.c(c[505])，.sel(sel))； xtmux3bi506(.xtout(xtout[506])，.a(a[506])，.b(b[506])，.c(c[506])，.sel(sel))； xtmux3bi507(.xtout(xtout[507])，.a(a[507])，.b(b[507])，.c(c[507])，.sel(sel))； xtmux3bi508(.xtout(xtout[508])，.a(a[508])，.b(b[508])，.c(c[508])，.sel(sel))； xtmux3bi509(.xtout(xtout[509])，.a(a[509])，.b(b[509])，.c(c[509])，.sel(sel))； xtmux3bi510(.xtout(xtout[510])，.a(a[510])，.b(b[510])，.c(c[510])，.sel(sel))； xtmux3bi511(.xtout(xtout[511])，.a(a[511])，.b(b[511])，.c(c[511])，.sel(sel))； xtmux3bi512(.xtout(xtout[512])，.a(a[512])，.b(b[512])，.c(c[512])，.sel(sel))； xtmux3bi513(.xtout(xtout[513])，.a(a[513])，.b(b[513])，.(c[513])，.sel(sel))；<dpn="d207"/> xtmux3bi514(.xtout(xtout[514])，.a(a[514])，.b(b[514])，.c(c[514])，.sel(sel))； xtmux3bi515(.xtout(xtout[515])，.a(a[515])，.b(b[515])，.c(c[515])，.sel(sel))； xtmux3bi516(.xtout(xtout[516])，.a(a[516])，.b(b[516])，.c(c[516])，.sel(sel))； xtmux3bi517(.xtout(xtout[517])，.a(a[517])，.b(b[517])，.c(c[517])，.sel(sel))； xtmux3bi518(.xtout(xtout[518])，.a(a[518])，.b(b[518])，.c(c[518])，.sel(sel))； xtmux3bi519(.xtout(xtout[519])，.a(a[519])，.b(b[519])，.c(c[519])，.sel(sel))； xtmux3bi520(.xtout(xtout[520])，.a(a[520])，.b(b[520])，.c(c[520])，.sel(sel))； xtmux3bi521(.xtout(xtout[521])，.a(a[521])，.b(b[521])，.c(c[521])，.sel(sel))； xtmux3bi522(.xtout(xtout[522])，.a(a[522])，.b(b[522])，.c(c[522])，.sel(sel))； xtmux3bi523(.xtout(xtout[523])，.a(a[523])，.b(b[523])，.c(c[523])，.sel(sel))； xtmux3bi524(.xtout(xtout[524])，.a(a[524])，.b(b[524])，.c(c[524])，.sel(sel))； xtmux3bi525(.xtout(xtout[525])，.a(a[525])，.b(b[525])，.c(c[525])，.sel(sel))； xtmux3bi526(.xtout(xtout[526])，.a(a[526])，.b(b[526])，.c(c[526])，.sel(sel))； xtmux3bi527(.xtout(xtout[527])，.a(a[527])，.b(b[527])，.c(c[527])，.sel(sel))； xtmux3bi528(.xtout(xtout[528])，.a(a[528])，.b(b[528])，.c(c[528])，.sel(sel))； xtmux3bi529(.xtout(xtout[529])，.a(a[529])，.b(b[529])，.c(c[529])，.sel(sel))； xtmux3bi530(.xtout(xtout[530])，.a(a[530])，.b(b[530])，.c(c[530])，.sel(sel))； xtmux3bi531(.xtout(xtout[531])，.a(a[531])，.b(b[531])，.c(c[531])，.sel(sel))； xtmux3bi532(.xtout(xtout[532])，.a(a[532])，.b(b[532])，.c(c[532])，.sel(sel))； xtmux3bi533(.xtout(xtout[533])，.a(a[533])，.b(b[533])，.c(c[533])，.sel(sel))； xtmux3bi534(.xtout(xtout[534])，.a(a[534])，.b(b[534])，.c(c[534])，.sel(sel))； xtmux3bi535(.xtout(xtout[535])，.a(a[535])，.b(b[535])，.c(c[535])，.sel(sel))； xtmux3bi536(.xtout(xtout[536])，.a(a[536])，.b(b[536])，.c(c[536])，.sel(sel))； xtmux3bi537(.xtout(xtout[537])，.a(a[537])，.b(b[537])，.c(c[537])，.sel(sel))； xtmux3bi538(.xtout(xtout[538])，.a(a[538])，.b(b[538])，.c(c[538])，.sel(sel))； xtmux3bi539(.xtout(xtout[539])，.a(a[539])，.b(b[539])，.c(c[539])，.sel(sel))； xtmux3bi540(.xtout(xtout[540])，.a(a[540])，.b(b[540])，.c(c[540])，.sel(sel))； xtmux3bi541(.xtout(xtout[541])，.a(a[541])，.b(b[541])，.c(c[541])，.sel(sel))； xtmux3bi542(.xtout(xtout[542])，.a(a[542])，.b(b[542])，.c(c[542])，.sel(sel))；xtmux3bi543(.xtout(xtout[543])，.a(a[543])，.b(b[543])，.c(c[543])，.sel(sel))；<dpn="d208"/> xtmux3bi544(.xtout(xtout[544])，.a(a[544])，.b(b[544])，.c(c[544])，.sel(sel))； xtmux3bi545(.xtout(xtout[545])，.a(a[545])，.b(b[545])，.c(c[545])，.sel(sel))； xtmux3bi546(.xtout(xtout[546])，.a(a[546])，.b(b[546])，.c(c[546])，.sel(sel))； xtmux3bi547(.xtout(xtout[547])，.a(a[547])，.b(b[547])，.c(c[547])，.sel(sel))； xtmux3bi548(.xtout(xtout[548])，.a(a[548])，.b(b[548])，.c(c[548])，.sel(sel))； xtmux3bi549(.xtout(xtout[549])，.a(a[549])，.b(b[549])，.c(c[549])，.sel(sel))； xtmux3bi550(.xtout(xtout[550])，.a(a[550])，.b(b[550])，.c(c[550])，.sel(sel))； xtmux3bi551(.xtout(xtout[551])，.a(a[551])，.b(b[551])，.c(c[551])，.sel(sel))； xtmux3bi552(.xtout(xtout[552])，.a(a[552])，.b(b[552])，.c(c[552])，.sel(sel))； xtmux3bi553(.xtout(xtout[553])，.a(a[553])，.b(b[553])，.c(c[553])，.sel(sel))； xtmux3bi554(.xtout(xtout[554])，.a(a[554])，.b(b[554])，.c(c[554])，.sel(sel))； xtmux3bi555(.xtout(xtout[555])，.a(a[555])，.b(b[555])，.c(c[555])，.sel(sel))； xtmux3bi556(.xtout(xtout[556])，.a(a[556])，.b(b[556])，.c(c[556])，.sel(sel))； xtmux3bi557(.xtout(xtout[557])，.a(a[557])，.b(b[557])，.c(c[557])，.sel(sel))； xtmux3bi558(.xtout(xtout[558])，.a(a[558])，.b(b[558])，.c(c[558])，.sel(sel))； xtmux3bi559(.xtout(xtout[559])，.a(a[559])，.b(b[559])，.c(c[559])，.sel(sel))； xtmux3bi560(.xtout(xtout[560])，.a(a[560])，.b(b[560])，.c(c[560])，.sel(sel))； xtmux3bi561(.xtout(xtout[561])，.a(a[561])，.b(b[561])，.c(c[561])，.sel(sel))； xtmux3bi562(.xtout(xtout[562])，.a(a[562])，.b(b[562])，.c(c[562])，.sel(sel))； xtmux3bi563(.xtout(xtout[563])，.a(a[563])，.b(b[563])，.c(c[563])，.sel(sel))； xtmux3bi564(.xtout(xtout[564])，.a(a[564])，.b(b[564])，.c(c[564])，.sel(sel))； xtmux3bi565(.xtout(xtout[565])，.a(a[565])，.b(b[565])，.c(c[565])，.sel(sel))； xtmux3bi566(.xtout(xtout[566])，.a(a[566])，.b(b[566])，.c(c[566])，.sel(sel))； xtmux3bi567(.xtout(xtout[567])，.a(a[567])，.b(b[567])，.c(c[567])，.sel(sel))； xtmux3bi568(.xtout(xtout[568])，.a(a[568])，.b(b[568])，.c(c[568])，.sel(sel))； xtmux3bi569(.xtout(xtout[569])，.a(a[569])，.b(b[569])，.c(c[569])，.sel(sel))； xtmux3bi570(.xtout(xtout[570])，.a(a[570])，.b(b[570])，.c(c[570])，.sel(sel))； xtmux3bi571(.xtout(xtout[571])，.a(a[571])，.b(b[571])，.c(c[571])，.sel(sel))； xtmux3bi572(.xtout(xtout[572])，.a(a[572])，.b(b[572])，.c(c[572])，.sel(sel))； xtmux3bi573(.xtout(xtout[573])，.a(a[573])，.b(b[573])，.c(c[573])，.sel(sel))；<dpn="d209"/> xtmux3bi574(.xtout(xtout[574])，.a(a[574])，.b(b[574])，.c(c[574])，.sel(sel))； xtmux3bi575(.xtout(xtout[575])，.a(a[575])，.b(b[575])，.c(c[575])，.sel(sel))； xtmux3bi576(.xtout(xtout[576])，.a(a[576])，.b(b[576])，.c(c[576])，.sel(sel))； xtmux3bi577(.xtout(xtout[577])，.a(a[577])，.b(b[577])，.c(c[577])，.sel(sel))； xtmux3bi578(.xtout(xtout[578])，.a(a[578])，.b(b[578])，.c(c[578])，.sel(sel))； xtmux3bi579(.xtout(xtout[579])，.a(a[579])，.b(b[579])，.c(c[579])，.sel(sel))； xtmux3bi580(.xtout(xtout[580])，.a(a[580])，.b(b[580])，.c(c[580])，.sel(sel))； xtmux3bi581(.xtout(xtout[581])，.a(a[581])，.b(b[581])，.c(c[581])，.sel(sel))； xtmux3bi582(.xtout(xtout[582])，.a(a[582])，.b(b[582])，.c(c[582])，.sel(sel))； xtmux3bi583(.xtout(xtout[583])，.a(a[583])，.b(b[583])，.c(c[583])，.sel(sel))； xtmux3bi584(.xtout(xtout[584])，.a(a[584])，.b(b[584])，.c(c[584])，.sel(sel))； xtmux3bi585(.xtout(xtout[585])，.a(a[585])，.b(b[585])，.c(c[585])，.sel(sel))； xtmux3bi586(.xtout(xtout[586])，.a(a[586])，.b(b[586])，.c(c[586])，.sel(sel))； xtmux3bi587(.xtout(xtout[587])，.a(a[587])，.b(b[587])，.c(c[587])，.sel(sel))； xtmux3bi588(.xtout(xtout[588])，.a(a[588])，.b(b[588])，.c(c[588])，.sel(sel))； xtmux3bi589(.xtout(xtout[589])，.a(a[589])，.b(b[589])，.c(c[589])，.sel(sel))； xtmux3bi590(.xtout(xtout[590])，.a(a[590])，.b(b[590])，.c(c[590])，.sel(sel))； xtmux3bi591(.xtout(xtout[591])，.a(a[591])，.b(b[591])，.c(c[591])，.sel(sel))； xtmux3bi592(.xtout(xtout[592])，.a(a[592])，.b(b[592])，.c(c[592])，.sel(sel))； xtmux3bi593(.xtout(xtout[593])，.a(a[593])，.b(b[593])，.c(c[593])，.sel(sel))； xtmux3bi594(.xtout(xtout[594])，.a(a[594])，.b(b[594])，.c(c[594])，.sel(sel))； xtmux3bi595(.xtout(xtout[595])，.a(a[595])，.b(b[595])，.c(c[595])，.sel(sel))； xtmux3bi596(.xtout(xtout[596])，.a(a[596])，.b(b[596])，.c(c[596])，.sel(sel))； xtmux3bi597(.xtout(xtout[597])，.a(a[597])，.b(b[597])，.c(c[597])，.sel(sel))； xtmux3bi598(.xtout(xtout[598])..a(a[598])，.b(b[598])，.c(c[598])，.sel(sel))； xtmux3bi599(.xtout(xtout[599])，.a(a[599])，.b(b[599])，.c(c[599])，.sel(sel))； xtmux3bi600(.xtout(xtout[600])，.a(a[600])，.b(b[600])，.c(c[600])，.sel(sel))； xtmux3bi601(.xtout(xtout[601])，.a(a[60l])，.b(b[601])，.c(c[601])，.sel(sel))； xtmux3bi602(.xtout(xtout[602])，.a(a[602])，.b(b[602])，.c(c[602])，.sel(sel))； xtmux3bi603(.xtout(xtout[603])，.a(a[603])，.b(b[603])，.c(c[603])，.sel(sel))；<dpn="d210"/> xtmux3bi604(.xtout(xtout[604])，.a(a[604])，.b(b[604])，.c(c[604])，.sel(sel))； xtmux3bi605(.xtout(xtout[605])，.a(a[605])，.b(b[605])，.c(c[605])，.sel(sel))； xtmux3bi606(.xtout(xtout[606])，.a(a[606])，.b(b[606])，.c(c[606])，.sel(sel))； xtmux3bi607(.xtout(xtout[607])，.a(a[607])，.b(b[607])，.c(c[607])，.sel(sel))； xtmux3bi608(.xtout(xtout[608])，.a(a[608])，.b(b[608])，.c(c[608])，.sel(sel))； xtmux3bi609(.xtout(xtout[609])，.a(a[609])，.b(b[609])，.c(c[609])，.sel(sel))； xtmux3bi610(.xtout(xtout[610])，.a(a[610])，.b(b[610])，.c(c[610])，.sel(sel))； xtmux3bi611(.xtout(xtout[611])，.a(a[611])，.b(b[611])，.c(c[611])，.sel(sel))； xtmux3bi612(.xtout(xtout[612])，.a(a[612])，.b(b[612])，.c(c[612])，.sel(sel))； xtmux3bi613(.xtout(xtout[613])，.a(a[613])，.b(b[613])，.c(c[613])，.sel(sel))； xtmux3bi614(.xtout(xtout[614])，.a(a[614])，.b(b[614])，.c(c[614])，.el(sel))； xtmux3bi615(.xtout(xtout[615])，.a(a[615])，.b(b[615])，.c(c[615])，.sel(sel))； xtmux3bi616(.xtout(xtout[616])，.a(a[616])，.b(b[616])，.c(c[616])，.sel(sel))； xtmux3bi617(.xtout(xtout[617])，.a(a[617])，.b(b[617])，.c(c[617])，.sel(sel))； xtmux3bi618(.xtout(xtout[618])，.a(a[618])，.b(b[618])，.c(c[618])，.sel(sel))； xtmux3bi619(.xtout(xtout[619])，.a(a[619])，.b(b[619])，.c(c[619])，.sel(sel))； xtmux3bi620(.xtout(xtout[620])，.a(a[620])，.b(b[620])，.c(c[620])，.sel(sel))； xtmux3bi621(.xtout(xtout[621])，.a(a[621])，.b(b[621])，.c(c[621])，.sel(sel))； xtmux3bi622(.xtout(xtout[622])，.a(a[622])，.b(b[622])，.c(c[622])，.sel(sel))； xtmux3bi623(.xtout(xtout[623])，.a(a[623])，.b(b[623])，.c(c[623])，.sel(sel))； xtmux3bi624(.xtout(xtout[624])，.a(a[624])，.b(b[624])，.c(c[624])，.sel(sel))； xtmux3bi625(.xtout(xtout[625])，.a(a[625])，.b(b[625])，.c(c[625])，.sel(sel))； xtmux3bi626(.xtout(xtout[626])，.a(a[626])，.b(b[626])，.c(c[626])，.sel(sel))； xtmux3bi627(.xtout(xtout[627])，.a(a[627])，.b(b[627])，.c(c[627])，.sel(sel))； xtmux3bi628(.xtout(xtout[628])，.a(a[628])，.b(b[628])，.c(c[628])，.sel(sel))； xtmux3bi629(.xtout(xtout[629])，.a(a[629])，.b(b[629])，.c(c[629])，.sel(sel))； xtmux3bi630(.xtout(xtout[630])，.a(a[630])，.b(b[630])，.c(c[630])，.sel(sel))； xtmux3bi631(.xtout(xtout[631])，.a(a[631])，.b(b[631])，.c(c[631])，.sel(sel))； xtmux3bi632(.xtout(xtout[632])，.a(a[632])，.b(b[632])，.c(c[632])，.sel(sel))； xtmux3bi633(.xtout(xtout[633])，.a(a[633])，.b(b[633])，.c(c[633])，.sel(sel))；<dpn="d211"/> xtmux3bi634(.xtout(xtout[634])，.a(a[634])，.b(b[634])，.c(c[634])，.sel(sel))； xtmux3bi635(.xtout(xtout[635])，.a(a[635])，.b(b[635])，.c(c[635])，.sel(sel))； xtmux3bi636(.xtout(xtout[636])，.a(a[636])，.b(b[636])，.c(c[636])，.sel(sel))； xtmux3bi637(.xtout(xtout[637])，.a(a[637])，.b(b[637])，.c(c[637])，.sel(sel))； xtmux3bi638(.xtout(xtout[638])，.a(a[638])，.b(b[638])，.c(c[638])，.sel(sel))； xtmux3bi639(.xtout(xtout[639])，.a(a[639])，.b(b[639])，.c(c[639])，.sel(sel))； xtmux3bi640(.xtout(xtout[640])，.a(a[640])，.b(b[640])，.c(c[640])，.sel(sel))； xtmux3bi641(.xtout(xtout[641])，.a(a[641])，.b(b[641])，.c(c[641])，.sel(sel))； xtmux3bi642(.xtout(xtout[642])，.a(a[642])，.b(b[642])，.c(c[642])，.sel(sel))； xtmux3bi643(.xtout(xtout[643])，.a(a[643])，.b(b[643])，.c(c[643])，.sel(sel))； xtmux3bi644(.xtout(xtout[644])，.a(a[644])，.b(b[644])，.c(c[644])，.sel(sel))； xtmux3bi645(.xtout(xtout[645])，.a(a[645])，.b(b[645])，.c(c[645])，.sel(sel))； xtmux3bi646(.xtout(xtout[646])，.a(a[646])，.b(b[646])，.c(c[646])，.sel(sel))； xtmux3bi647(.xtout(xtout[647])，.a(a[647])，.b(b[647])，.c(c[647])，.sel(sel))； xtmux3bi648(.xtout(xtout[648])，.a(a[648])，.b(b[648])，.c(c[648])，.sel(sel))； xtmux3bi649(.xtout(xtout[649])，.a(a[649])，.b(b[649])，.c(c[649])，.sel(sel))； xtmux3bi650(.xtout(xtout[650])，.a(a[650])，.b(b[650])，.c(c[650])，.sel(sel))； xtmux3bi651(.xtout(xtout[651])，.a(a[651])，.b(b[651])，.c(c[651])，.sel(sel))； xtmux3bi652(.xtout(xtout[652])，.a(a[652])，.b(b[652])，.c(c[652])，.sel(sel))； xtmux3bi653(.xtout(xtout[653])，.a(a[653])，.b(b[653])，.c(c[653])，.sel(sel))； xtmux3bi654(.xtout(xtout[654])，.a(a[654])，.b(b[654])，.c(c[654])，.sel(sel))； xtmux3bi655(.xtout(xtout[655])，.a(a[655])，.b(b[655])，.c(c[655])，.sel(sel))； xtmux3bi656(.xtout(xtout[656])，.a(a[656])，.b(b[656])，.c(c[656])，.sel(sel))； xtmux3bi657(.xtout(xtout[657])，.a(a[657])，.b(b[657])，.c(c[657])，.sel(sel))； xtmux3bi658(.xtout(xtout[658])，.a(a[658])，.b(b[658])，.c(c[658])，.sel(sel))； xtmux3bi659(.xtout(xtout[659])，.a(a[659])，.b(b[659])，.c(c[659])，.sel(sel))； xtmux3bi660(.xtout(xtout[660])，.a(a[660])，.b(b[660])，.c(c[660])，.sel(sel))； xtmux3bi661(.xtout(xtout[661])，.a(a[661])，.b(b[661])，.c(c[661])，.sel(sel))； xtmux3bi662(.xtout(xtout[662])，.a(a[662])，.b(b[662])，.c(c[662])，.sel(sel))； xtmux3bi663(.xtout(xtout[663])，.a(a[663])，.b(b[663])，.c(c[663])，.sel(sel))；<dpn="d212"/> xtmux3bi664(.xtout(xtout[664])，.a(a[664])，.b(b[664])，.c(c[664])，.sel(sel))； xtmux3bi665(.xtout(xtout[665])，.a(a[665])，.b(b[665])，.c(c[665])，.sel(sel))； xtmux3bi666(.xtout(xtout[666])，.a(a[666])，.b(b[666])，.c(c[666])，.sel(sel))； xtmux3bi667(.xtout(xtout[667])，.a(a[667])，.b(b[667])，.c(c[667])，.sel(sel))； xtmux3bi668(.xtout(xtout[668])，.a(a[668])，.b(b[668])，.c(c[668])，.sel(sel))； xtmux3bi669(.xtout(xtout[669])，.a(a[669])，.b(b[669])，.c(c[669])，.sel(sel))； xtmux3bi670(.xtout(xtout[670])，.a(a[670])，.b(b[670])，.c(c[670])，.sel(sel))； xtmux3bi671(.xtout(xtout[671])，.a(a[671])，.b(b[671])，.c(c[671])，.sel(sel))； xtmux3bi672(.xtout(xtout[672])，.a(a[672])，.b(b[672])，.c(c[672])，.sel(sel))； xtmux3bi673(.xtout(xtout[673])，.a(a[673])，.b(b[673])，.c(c[673])，.sel(sel))； xtmux3bi674(.xtout(xtout[674])，.a(a[674])，.b(b[674])，.c(c[674])，.sel(sel))； xtmux3bi675(.xtout(xtout[675])，.a(a[675])，.b(b[675])，.c(c[675])，.sel(sel))； xtmux3bi676(.xtout(xtout[676])，.a(a[676])，.b(b[676])，.c(c[676])，.sel(sel))； xtmux3bi677(.xtout(xtout[677])，.a(a[677])，.b(b[677])，.c(c[677])，.sel(sel))； xtmux3bi678(.xtout(xtout[678])，.a(a[678])，.b(b[678])，.c(c[678])，.sel(sel))； xtmux3bi679(.xtout(xtout[679])，.a(a[679])，.b(b[679])，.c(c[679])，.sel(sel))； xtmux3bi680(.xtout(xtout[680])，.a(a[680])，.b(b[680])，.c(c[680])，.sel(sel))； xtmux3bi681(.xtout(xtout[681])，.a(a[681])，.b(b[681])，.c(c[681])，.sel(sel))； xtmux3bi682(.xtout(xtout[682])，.a(a[682])，.b(b[682])，.c(c[682])，.sel(sel))； xtmux3bi683(.xtout(xtout[683])，.a(a[683])，.b(b[683])，.c(c[683])，.sel(sel))； xtmux3bi684(.xtout(xtout[684])，.a(a[684])，.b(b[684])，.c(c[684])，.sel(sel))； xtmux3bi685(.xtout(xtout[685])，.a(a[685])，.b(b[685])，.c(c[685])，.sel(sel))； xtmux3bi686(.xtout(xtout[686])，.a(a[686])，.b(b[686])，.c(c[686])，.sel(sel))； xtmux3bi687(.xtout(xtout[687])，.a(a[687])，.b(b[687])，.c(c[687])，.sel(sel))； xtmux3bi688(.xtout(xtout[688])，.a(a[688])，.b(b[688])，.c(c[688])，.sel(sel))； xtmux3bi689(.xtout(xtout[689])，.a(a[689])，.b(b[689])，.c(c[689])，.sel(sel))； xtmux3bi690(.xtout(xtout[690])，.a(a[690])，.b(b[690])，.c(c[690])，.sel(sel))； xtmux3bi691(.xtout(xtout[691])，.a(a[691])，.b(b[691])，.c(c[691])，.sel(sel))； xtmux3bi692(.xtout(xtout[692])，.a(a[692])，.b(b[692])，.c(c[692])，.sel(sel))； xtmux3bi693(.xtout(xtout[693])，.a(a[693])，.b(b[693])，.c(c[693])，.sel(sel))；<dpn="d213"/> xtmux3bi694(.xtout(xtout[694])，.a(a[694])，.b(b[694])，.c(c[694])，.sel(sel))； xtmux3bi695(.xtout(xtout[695])，.a(a[695])，.b(b[695])，.c(c[695])，.sel(sel))； xtmux3bi696(.xtout(xtout[696])，.a(a[696])，.b(b[696])，.c(c[696])，.sel(sel))； xtmux3bi697(.xtout(xtout[697])，.a(a[697])，.b(b[697])，.c(c[697])，.sel(sel))； xtmux3bi698(.xtout(xtout[698])，.a(a[698])，.b(b[698])，.c(c[698])，.sel(sel))； xtmux3bi699(.xtout(xtout[699])，.a(a[699])，.b(b[699])，.c(c[699])，.sel(sel))； xtmux3bi700(.xtout(xtout[700])，.a(a[700])，.b(b[700])，.c(c[700])，.sel(sel))； xtmux3bi701(.xtout(xtout[701])，.a(a[701])，.b(b[701])，.c(c[701])，.sel(sel))； xtmux3bi702(.xtout(xtout[702])，.a(a[702])，.b(b[702])，.c(c[702])，.sel(sel))； xtmux3bi703(.xtout(xtout[703])，.a(a[703])，.b(b[703])，.c(c[703])，.sel(sel))； xtmux3bi704(.xtout(xtout[704])，.a(a[704])，.b(b[704])，.c(c[704])，.sel(sel))； xtmux3bi705(.xtout(xtout[705])，.a(a[705])，.b(b[705])，.c(c[705])，.sel(sel))； xtmux3bi706(.xtout(xtout[706])，.a(a[706])，.b(b[706])，.c(c[706])，.sel(sel))； xtmux3bi707(.xtout(xtout[707])，.a(a[707])，.b(b[707])，.c(c[707])，.sel(sel))； xtmux3bi708(.xtout(xtout[708])，.a(a[708])，.b(b[708])，.c(c[708])，.sel(sel))； xtmux3bi709(.xtout(xtout[709])，.a(a[709])，.b(b[709])，.c(c[709])，.sel(sel))； xtmux3bi710(.xtout(xtout[710])，.a(a[710])，.b(b[710])，.c(c[710])，.sel(sel))； xtmux3bi711(.xtout(xtout[711])，.a(a[711])，.b(b[711])，.c(c[711])，.sel(sel))； xtmux3bi712(.xtout(xtout[712])，.a(a[712])，.b(b[712])，.c(c[712])，.sel(sel))； xtmux3bi713(.xtout(xtout[713])，.a(a[713])，.b(b[713])，.c(c[713])，.sel(sel))； xtmux3bi714(.xtout(xtout[714])，.a(a[714])，.b(b[714])，.c(c[714])，.sel(sel))； xtmux3bi715(.xtout(xtout[715])，.a(a[715])，.b(b[715])，.c(c[715])，.sel(sel))； xtmux3bi716(.xtout(xtout[716])，.a(a[716])，.b(b[716])，.c(c[716])，.sel(sel))； xtmux3bi717(.xtout(xtout[717])，.a(a[717])，.b(b[717])，.c(c[717])，.sel(sel))； xtmux3bi718(.xtout(xtout[718])，.a(a[718])，.b(b[718])，.c(c[718])，.sel(sel))； xtmux3bi719(.xtout(xtout[719])，.a(a[719])，.b(b[719])，.c(c[719])，.sel(sel))； xtmux3bi720(.xtout(xtout[720])，.a(a[720])，.b(b[720])，.c(c[720])，.sel(sel))； xtmux3bi721(.xtout(xtout[721])，.a(a[721])，.b(b[721])，.c(c[721])，.sel(sel))； xtmux3bi722(.xtout(xtout[722])，.a(a[722])，.b(b[722])，.c(c[722])，.sel(sel))； xtmux3bi723(.xtout(xtout[723])，.a(a[723])，.b(b[723])，.c(c[723])，.sel(sel))；<dpn="d214"/> xtmux3bi724(.xtout(xtout[724])，.a(a[724])，.b(b[724])，.c(c[724])，.sel(sel))； xtmux3bi725(.xtout(xtout[725])，.a(a[725])，.b(b[725])，.c(c[725])，.sel(sel))； xtmux3bi726(.xtout(xtout[726])，.a(a[726])，.b(b[726])，.c(c[726])，.sel(sel))； xtmux3bi727(.xtout(xtout[727])，.a(a[727])，.b(b[727])，.c(c[727])，.sel(sel))； xtmux3bi728(.xtout(xtout[728])，.a(a[728])，.b(b[728])，.c(c[728])，.sel(sel))； xtmux3bi729(.xtout(xtout[729])，.a(a[729])，.b(b[729])，.c(c[729])，.sel(sel))； xtmux3bi730(.xtout(xtout[730])，.a(a[730])，.b(b[730])，.c(c[730])，.sel(sel))； xtmux3bi731(.xtout(xtout[731])，.a(a[731])，.b(b[731])，.c(c[731])，.sel(sel))； xtmux3bi732(.xtout(xtout[732])，.a(a[732])，.b(b[732])，.c(c[732])，.sel(sel))； xtmux3bi733(.xtout(xtout[733])，.a(a[733])，.b(b[733])，.c(c[733])，.sel(sel))； xtmux3bi734(.xtout(xtout[734])，.a(a[734])，.b(b[734])，.c(c[734])，.sel(sel))； xtmux3bi735(.xtout(xtout[735])，.a(a[735])，.b(b[735])，.c(c[735])，.sel(sel))； xtmux3bi736(.xtout(xtout[736])，.a(a[736])，.b(b[736])，.c(c[736])，.sel(sel))； xtmux3bi737(.xtout(xtout[737])，.a(a[737])，.b(b[737])，.c(c[737])，.sel(sel))； xtmux3bi738(.xtout(xtout[738])，.a(a[738])，.b(b[738])，.c(c[738])，.sel(sel))； xtmux3bi739(.xtout(xtout[739])，.a(a[739])，.b(b[739])，.c(c[739])，.sel(sel))； xtmux3bi740(.xtout(xtout[740])，.a(a[740])，.b(b[740])，.c(c[740])，.sel(sel))； xtmux3bi741(.xtout(xtout[741])，.a(a[741])，.b(b[741])，.c(c[741])，.sel(sel))； xtmux3bi742(.xtout(xtout[742])，.a(a[742])，.b(b[742])，.c(c[742])，.sel(sel))； xtmux3bi743(.xtout(xtout[743])，.a(a[743])，.b(b[743])，.c(c[743])，.sel(sel))； xtmux3bi744(.xtout(xtout[744])，.a(a[744])，.b(b[744])，.c(c[744])，.sel(sel))； xtmux3bi745(.xtout(xtout[745])，.a(a[745])，.b(b[745])，.c(c[745])，.sel(sel))； xtmux3bi746(.xtout(xtout[746])，.a(a[746])，.b(b[746])，.c(c[746])，.sel(sel))； xtmux3bi747(.xtout(xtout[747])，.a(a[747])，.b(b[747])，.c(c[747])，.sel(sel))； xtmux3bi748(.xtout(xtout[748])，.a(a[748])，.b(b[748])，.c(c[748])，.sel(sel))； xtmux3bi749(.xtout(xtout[749])，.a(a[749])，.b(b[749])，.c(c[749])，.sel(sel))； xtmux3bi750(.xtout(xtout[750])，.a(a[750])，.b(b[750])，.c(c[750])，.sel(sel))； xtmux3bi751(.xtout(xtout[751])，.a(a[751])，.b(b[751])，.c(c[751])，.sel(sel))； xtmux3bi752(.xtout(xtout[752])，.a(a[752])，.b(b[752])，.c(c[752])，.sel(sel))； xtmux3bi753(.xtout(xtout[753])，.a(a[753])，.b(b[753])，.c(c[753])，.sel(sel))；<dpn="d215"/> xtmux3bi754(.xtout(xtout[754])，.a(a[754])，.b(b[754])，.c(c[754])，.sel(sel))； xtmux3bi755(.xtout(xtout[755])，.a(a[755])，.b(b[755])，.c(c[755])，.sel(sel))；xtmux3bi756(.xtout(xtout[756])，.a(a[756])，.b(b[756])，.c(c[756])，.sel(sel))； xtmux3bi757(.xtout(xtout[757])，.a(a[757])，.b(b[757])，.c(c[757])，.sel(sel))； xtmux3bi758(.xtout(xtout[758])，.a(a[758])，.b(b[758])，.c(c[758])，.sel(sel))； xtmux3bi759(.xtout(xtout[759])，.a(a[759])，.b(b[759])，.c(c[759])，.sel(sel))； xtmux3bi760(.xtout(xtout[760])，.a(a[760])，.b(b[760])，.c(c[760])，.sel(sel))； xtmux3bi761(.xtout(xtout[761])，.a(a[761])，.b(b[761])，.c(c[761])，.sel(sel))； xtmux3bi762(.xtout(xtout[762])，.a(a[762])，.b(b[762])，.c(c[762])，.sel(sel))； xtmux3bi763(.xtout(xtout[763])，.a(a[763])，.b(b[763])，.c(c[763])，.sel(sel))； xtmux3bi764(.xtout(xtout[764])，.a(a[764])，.b(b[764])，.c(c[764])，.sel(sel))； xtmux3bi765(.xtout(xtout[765])，.a(a[765])，.b(b[765])，.c(c[765])，.sel(sel))； xtmux3bi766(.xtout(xtout[766])，.a(a[766])，.b(b[766])，.c(c[766])，.sel(sel))； xtmux3bi767(.xtout(xtout[767])，.a(a[767])，.b(b[767])，.c(c[767])，.sel(sel))； xtmux3bi768(.xtout(xtout[768])，.a(a[768])，.b(b[768])，.c(c[768])，.sel(sel))； xtmux3bi769(.xtout(xtout[769])，.a(a[769])，.b(b[769])，.c(c[769])，.sel(sel))； xtmux3bi770(.xtout(xtout[770])，.a(a[770])，.b(b[770])，.c(c[770])，.sel(sel))； xtmux3bi771(.xtout(xtout[771])，.a(a[771])，.b(b[771])，.c(c[771])，.sel(sel))； xtmux3bi772(.xtout(xtout[772])，.a(a[772])，.b(b[772])，.c(c[772])，.sel(sel))； xtmux3bi773(.xtout(xtout[773])，.a(a[773])，.b(b[773])，.c(c[773])，.sel(sel))； xtmux3bi774(.xtout(xtout[774])，.a(a[774])，.b(b[774])，.c(c[774])，.sel(sel))； xtmux3bi775(.xtout(xtout[775])，.a(a[775])，.b(b[775])，.c(c[775])，.sel(sel))； xtmux3bi776(.xtout(xtout[776])，.a(a[776])，.b(b[776])，.c(c[776])，.sel(sel))； xtmux3bi777(.xtout(xtout[777])，.a(a[777])，.b(b[777])，.c(c[777])，.sel(sel))； xtmux3bi778(.xtout(xtout[778])，.a(a[778])，.b(b[778])，.c(c[778])，.sel(sel))； xtmux3bi779(.xtout(xtout[779])，.a(a[779])，.b(b[779])，.c(c[779])，.sel(sel))； xtmux3bi780(.xtout(xtout[780])，.a(a[780])，.b(b[780])，.c(c[780])，.sel(sel))； xtmux3bi781(.xtout(xtout[781])，.a(a[781])，.b(b[781])，.c(c[781])，.sel(sel))； xtmux3bi782(.xtout(xtout[782])，.a(a[782])，.b(b[782])，.c(c[782])，.sel(sel))； xtmux3bi783(.xtout(xtout[783])，.a(a[783])，.b(b[783])，.c(c[783])，.sel(sel))；<dpn="d216"/> xtmux3bi784(.xtout(xtout[784])，.a(a[784])，.b(b[784])，.c(c[784])，.sel(sel))； xtmux3bi785(.xtout(xtout[785])，.a(a[785])，.b(b[785])，.c(c[785])，.sel(sel))； xtmux3bi786(.xtout(xtout[786])，.a(a[786])，.b(b[786])，.c(c[786])，.sel(sel))； xtmux3bi787(.xtout(xtout[787])，.a(a[787])，.b(b[787])，.c(c[787])，.sel(sel))； xtmux3bi788(.xtout(xtout[788])，.a(a[788])，.b(b[788])，.c(c[788])，.sel(sel))； xtmux3bi789(.xtout(xtout[789])，.a(a[789])，.b(b[789])，.c(c[789])，.sel(sel))； xcmux3bi790(.xtout(xtout[790])，.a(a[790])，.b(b[790])，.c(c[790])，.sel(sel))； xtmux3bi791(.xtout(xtout[791])，.a(a[791])，.b(b[791])，.c(c[791])，.sel(sel))； xtmux3bi792(.xtout(xtout[792])，.a(a[792])，.b(b[792])，.c(c[792])，.sel(sel))； xtmux3bi793(.xtout(xtout[793])，.a(a[793])，.b(b[793])，.c(c[793])，.sel(sel))； xtmux3bi794(.xtout(xtout[794])，.a(a[794])，.b(b[794])，.c(c[794])，.sel(sel))； xtmux3bi795(.xtout(xtout[795])，.a(a[795])，.b(b[795])，.c(c[795])，.sel(sel))； xtmux3bi796(.xtout(xtout[796])，.a(a[796])，.b(b[796])，.c(c[796])，.sel(sel))； xtmux3bi797(.xtout(xtout[797])，.a(a[797])，.b(b[797])，.c(c[797])，.sel(sel))； xtmux3bi798(.xtout(xtout[798])，.a(a[798])，.b(b[798])，.c(c[798])，.sel(sel))； xtmux3bi799(.xtout(xtout[799])，.a(a[799])，.b(b[799])，.c(c[799])，.sel(sel))； xtmux3bi800(.xtout(xtout[800])，.a(a[800])，.b(b[800])，.c(c[800])，.sel(sel))； xtmux3bi801(.xtout(xtout[801])，.a(a[801])，.b(b[801])，.c(c[801])，.sel(sel))； xtmux3bi802(.xtout(xtout[802])，.a(a[802])，.b(b[802])，.c(c[802])，.sel(sel))； xtmux3bi803(.xtout(xtout[803])，.a(a[803])，.b(b[803])，.c(c[803])，.sel(sel))； xtmux3bi804(.xtout(xtout[804])，.a(a[804])，.b(b[804])，.c(c[804])，.sel(sel))； xtmux3bi805(.xtout(xtout[805])，.a(a[805])，.b(b[805])，.c(c[805])，.sel(sel))； xtmux3bi806(.xtout(xtout[806])，.a(a[806])，.b(b[806])，.c(c[806])，.sel(sel))； xtmux3bi807(.xtout(xtout[807])，.a(a[807])，.b(b[807])，.c(c[807])，.sel(sel))； xtmux3bi808(.xtout(xtout[808])，.a(a[808])，.b(b[808])，.c(c[808])，.sel(sel))； xtmux3bi809(.xtout(xtout[809])，.a(a[809])，.b(b[809])，.c(c[809])，.sel(sel))； xtmux3bi810(.xtout(xtout[810])，.a(a[810])，.b(b[810])，.c(c[810])，.sel(sel))； xtmux3bi811(.xtout(xtout[811])，.a(a[811])，.b(b[811])，.c(c[811])，.sel(sel))； xtmux3bi812(.xtout(xtout[812])，.a(a[812])，.b(b[812])，.c(c[812])，.sel(sel))； xtmux3bi813(.xtout(xtout[813])，.a(a[813])，.b(b[813])，c(c[813])，.sel(sel))；<dpn="d217"/> xtmux3bi814(.xtout(xtout[814])，.a(a[814])，.b(b[814])，.c(c[814])，.sel(sel))； xtmux3bi815(.xtout(xtout[815])，.a(a[815])，.b(b[815])，.c(c[815])，.sel(sel))； xtmux3bi816(.xtout(xtout[816])，.a(a[816])，.b(b[816])，.c(c[816])，.sel(sel))； xtmux3bi817(.xtout(xtout[817])，.a(a[817])，.b(b[817])，.c(c[817])，.sel(sel))； xtmux3bi818(.xtout(xtout[818])，.a(a[818])，.b(b[818])，.c(c[818])，.sel(sel))； xtmux3bi819(.xtout(xtout[819])，.a(a[819])，.b(b[819])，.c(c[819])，.sel(sel))； xtmux3bi820(.xtout(xtout[820])，.a(a[820])，.b(b[820])，.c(c[820])，.sel(sel))； xtmux3bi821(.xtout(xtout[821])，.a(a[821])，.b(b[821])，.c(c[821])，.sel(sel))； xtmux3bi822(.xtout(xtout[822])，.a(a[822])，.b(b[822])，.c(c[822])，.sel(sel))； xtmux3bi823(.xtout(xtout[823])，.a(a[823])，.b(b[823])，.c(c[823])，.sel(sel))； xtmux3bi824(.xtout(xtout[824])，.a(a[824])，.b(b[824])，.c(c[824])，.sel(sel))； xtmux3bi825(.xtout(xtout[825])，.a(a[825])，.b(b[825])，.c(c[825])，.sel(sel))； xtmux3bi826(.xtout(xtout[826])，.a(a[826])，.b(b[826])，.c(c[826])，.sel(sel))； xtmux3bi827(.xtout(xtout[827])，.a(a[827])，.b(b[827])，.c(c[827])，.sel(sel))； xtmux3bi828(.xtout(xtout[828])，.a(a[828])，.b(b[828])，.c(c[828])，.sel(sel))； xtmux3bi829(.xtout(xtout[829])，.a(a[829])，.b(b[829])，.c(c[829])，.sel(sel))； xtmux3bi830(.xtout(xtout[830])，.a(a[830])，.b(b[830])，.c(c[830])，.sel(sel))； xtmux3bi831(.xtout(xtout[831])，.a(a[831])，.b(b[831])，.c(c[831])，.sel(sel))； xtmux3bi832(.xtout(xtout[832])，.a(a[832])，.b(b[832])，.c(c[832])，.sel(sel))； xtmux3bi833(.xtout(xtout[833])，.a(a[833])，.b(b[833])，.c(c[833])，.sel(sel))； xtmux3bi834(.xtout(xtout[834])，.a(a[834])，.b(b[834])，.c(c[834])，.sel(sel))； xtmux3bi835(.xtout(xtout[835])，.a(a[835])，.b(b[835])，.c(c[835])，.sel(sel))； xtmux3bi836(.xtout(xtout[836])，.a(a[836])，.b(b[836])，.c(c[836])，.sel(sel))； xtmux3bi837(.xtout(xtout[837])，.a(a[837])，.b(b[837])，.c(c[837])，.sel(sel))； xtmux3bi838(.xtout(xtout[838])，.a(a[838])，.b(b[838])，.c(c[838])，.sel(sel))； xtmux3bi839(.xtout(xtout[839])，.a(a[839])，.b(b[839])，.c(c[839])，.sel(sel))； xtmux3bi840(.xtout(xtout[840])，.a(a[840])，.b(b[840])，.c(c[840])，.sel(sel))； xtmux3bi841(.xtout(xtout[841])，.a(a[841])，.b(b[841])，.c(c[841])，.sel(sel))； xtmux3bi842(.xtout(xtout[842])，.a(a[842])，.b(b[842])，.c(c[842])，.sel(sel))； xtmux3bi843(.xtout(xtout[843])，.a(a[843])，.b(b[843])，.c(c[843])，.sel(sel))；<dpn="d218"/> xtmux3bi844(.xtout(xtout[844])，.a(a[844])，.b(b[844])，.c(c[844])，.sel(sel))； xtmux3bi845(.xtout(xtout[845])，.a(a[845])，.b(b[845])，.c(c[845])，.sel(sel))； xtmux3bi846(.xtout(xtout[846])，.a(a[846])，.b(b[846])，.c(c[846])，.sel(sel))； xtmux3bi847(.xtout(xtout[847])，.a(a[847])，.b(b[847])，.c(c[847])，.sel(sel))； xtmux3bi848(.xtout(xtout[848])，.a(a[848])，.b(b[848])，.c(c[848])，.sel(sel))； xtmux3bi849(.xtout(xtout[849])，.a(a[849])，.b(b[849])，.c(c[849])，.sel(sel))； xtmux3bi850(.xtout(xtout[850])，.a(a[850])，.b(b[850])，.c(c[850])，.sel(sel))； xtmux3bi851(.xtout(xtout[851])，.a(a[851])，.b(b[851])，.c(c[851])，.sel(sel))； xtmux3bi852(.xtout(xtout[852])，.a(a[852])，.b(b[852])，.c(c[852])，.sel(sel))； xtmux3bi853(.xtout(xtout[853])，.a(a[853])，.b(b[853])，.c(c[853])，.sel(sel))； xtmux3bi854(.xtout(xtout[854])，.a(a[854])，.b(b[854])，.c(c[854])，.sel(sel))； xtmux3bi855(.xtout(xtout[855])，.a(a[855])，.b(b[855])，.c(c[855])，.sel(sel))； xtmux3bi856(.xtout(xtout[856])，.a(a[856])，.b(b[856])，.c(c[856])，.sel(sel))； xtmux3bi857(.xtout(xtout[857])，.a(a[857])，.b(b[857])，.c(c[857])，.sel(sel))； xtmux3bi858(.xtout(xtout[858])，.a(a[858])，.b(b[858])，.c(c[858])，.sel(sel))； xtmux3bi859(.xtout(xtout[859])，.a(a[859])，.b(b[859])，.c(c[859])，.sel(sel))； xtmux3bi860(.xtout(xtout[860])，.a(a[860])，.b(b[860])，.c(c[860])，.sel(sel))； xtmux3bi861(.xtout(xtout[861])，.a(a[861])，.b(b[861])，.c(c[861])，.sel(sel))； xtmux3bi862(.xtout(xtout[862])，.a(a[862])，.b(b[862])，.c(c[862])，.sel(sel))； xtmux3bi863(.xtout(xtout[863])，.a(a[863])，.b(b[863])，.c(c[863])，.sel(sel))； xtmux3bi864(.xtout(xtout[864])，.a(a[864])，.b(b[864])，.c(c[864])，.sel(sel))； xtmux3bi865(.xtout(xtout[865])，.a(a[865])，.b(b[865])，.c(c[865])，.sel(sel))； xtmux3bi866(.xtout(xtout[866])，.a(a[866])，.b(b[866])，.c(c[866])，.sel(sel))； xtmux3bi867(.xtout(xtout[867])，.a(a[867])，.b(b[867])，.c(c[867])，.sel(sel))； xtmux3bi868(.xtout(xtout[868])，.a(a[868])，.b(b[868])，.c(c[868])，.sel(sel))； xtmux3bi869(.xtout(xtout[869])，.a(a[869])，.b(b[869])，.c(c[869])，.sel(sel))； xtmux3bi870(.xtout(xtout[870])，.a(a[870])，.b(b[870])，.c(c[870])，.sel(sel))； xtmux3bi871(.xtout(xtout[871])，.a(a[871])，.b(b[871])，.c(c[871])，.sel(sel))； xtmux3bi872(.xtout(xtout[872])，.a(a[872])，.b(b[872])，.c(c[872])，.sel(sel))； xtmux3bi873(.xtout(xtout[873])，.a(a[873])，.b(b[873])，.c(c[873])，.sel(sel))；<dpn="d219"/> xtmux3bi874(.xtout(xtout[874])，.a(a[874])，.b(b[874])，.c(c[874])，.sel(sel))； xtmux3bi875(.xtout(xtout[875])，.a(a[875])，.b(b[875])，.c(c[875])，.sel(sel))； xtmux3bi876(.xtout(xtout[876])，.a(a[876])，.b(b[876])，.c(c[876])，.sel(sel))； xtmux3bi877(.xtout(xtout[877])，.a(a[877])，.b(b[877])，.c(c[877])，.sel(sel))； xtmux3bi878(.xtout(xtout[878])，.a(a[878])，.b(b[878])，.c(c[878])，.sel(sel))； xtmux3bi879(.xtout(xtout[879])，.a(a[879])，.b(b[879])，.c(c[879])，.sel(sel))； xtmux3bi880(.xtout(xtout[880])，.a(a[880])，.b(b[880])，.c(c[880])，.sel(sel))； xtmux3bi881(.xtout(xtout[881])，.a(a[881])，.b(b[881])，.c(c[881])，.sel(sel))； xtmux3bi882(.xtout(xtout[882])，.a(a[882])，.b(b[882])，.c(c[882])，.sel(sel))； xtmux3bi883(.xtout(xtout[883])，.a(a[883])，.b(b[883])，.c(c[883])，.sel(sel))； xtmux3bi884(.xtout(xtout[884])，.a(a[884])，.b(b[884])，.c(c[884])，.sel(sel))； xtmux3bi885(.xtout(xtout[885])，.a(a[885])，.b(b[885])，.c(c[885])，.sel(sel))； xtmux3bi886(.xtout(xtout[886])，.a(a[886])，.b(b[886])，.c(c[886])，.sel(sel))； xtmux3bi887(.xtout(xtout[887])，.a(a[887])，.b(b[887])，.c(c[887])，.sel(sel))； xtmux3bi888(.xtout(xtout[888])，.a(a[888])，.b(b[888])，.c(c[888])，.sel(sel))； xtmux3bi889(.xtout(xtout[889])，.a(a[889])，.b(b[889])，.c(c[889])，.sel(sel))； xtmux3bi890(.xtout(xtout[890])，.a(a[890])，.b(b[890])，.c(c[890])，.sel(sel))； xtmux3bi891(.xtout(xtout[891])，.a(a[891])，.b(b[891])，.c(c[891])，.sel(sel))； xtmux3bi892(.xtout(xtout[892])，.a(a[892])，.b(b[892])，.c(c[892])，.sel(sel))； xtmux3bi893(.xtout(xtout[893])，.a(a[893])，.b(b[893])，.c(c[893])，.sel(sel))； xtmux3bi894(.xtout(xtout[894])，.a(a[894])，.b(b[894])，.c(c[894])，.sel(sel))； xtmux3bi895(.xtout(xtout[895])，.a(a[895])，.b(b[895])，.c(c[895])，.sel(sel))； xtmux3bi896(.xtout(xtout[896])，.a(a[896])，.b(b[896])，.c(c[896])，.sel(sel))； xtmux3bi897(.xtout(xtout[897])，.a(a[897])，.b(b[897])，.c(c[897])，.sel(sel))； xtmux3bi898(.xtout(xtout[898])，.a(a[898])，.b(b[898])，.c(c[898])，.sel(sel))； xtmux3bi899(.xtout(xtout[899])，.a(a[899])，.b(b[899])，.c(c[899])，.sel(sel))； xtmux3bi900(.xtout(xtout[900])，.a(a[900])，.b(b[900])，.c(c[900])，.sel(sel))； xtmux3bi901(.xtout(xtout[901])，.a(a[901])，.b(b[901])，.c(c[901])，.sel(sel))； xtmux3bi902(.xtout(xtout[902])，.a(a[902])，.b(b[902])，.c(c[902])，.sel(sel))； xtmux3bi903(.xtout(xtout[903])，.a(a[903])，.b(b[903])，.c(c[903])，.sel(sel))；<dpn="d220"/> xtmux3bi904(.xtout(xtout[904])，.a(a[904])，.b(b[904])，.c(c[904])，.sel(sel))； xtmux3bi905(.xtout(xtout[905])，.a(a[905])，.b(b[905])，.c(c[905])，.sel(sel))； xtmux3bi906(.xtout(xtout[906])，.a(a[906])，.b(b[906])，.c(c[906])，.sel(sel))； xtmux3bi907(.xtout(xtout[907])，.a(a[907])，.b(b[907])，.c(c[907])，.sel(sel))； xtmux3bi908(.xtout(xtout[908])，.a(a[908])，.b(b[908])，.c(c[908])，.sel(sel))； xtmux3bi909(.xtout(xtout[909])，.a(a[909])，.b(b[909])，.c(c[909])，.sel(sel))； xtmux3bi910(.xtout(xtout[910])，.a(a[910])，.b(b[910])，.c(c[910])，.sel(sel))； xtmux3bi911(.xtout(xtout[911])，.a(a[911])，.b(b[911])，.c(c[911])，.sel(sel))； xtmux3bi912(.xtout(xtout[912])，.a(a[912])，.b(b[912])，.c(c[912])，.sel(sel))； xtmux3bi913(.xtout(xtout[913])，.a(a[913])，.b(b[913])，.c(c[913])，.sel(sel))； xtmux3bi914(.xtout(xtout[914])，.a(a[914])，.b(b[914])，.c(c[914])，.sel(sel))； xtmux3bi915(.xtout(xtout[915])，.a(a[915])，.b(b[915])，.c(c[915])，.sel(sel))； xtmux3bi916(.xtout(xtout[916])，.a(a[916])，.b(b[916])，.c(c[916])，.sel(sel))； xtmux3bi917(.xtout(xtout[917])，.a(a[917])，.b(b[917])，.c(c[917])，.sel(sel))； xtmux3bi918(.xtout(xtout[918])，.a(a[918])，.b(b[918])，.c(c[918])，.sel(sel))； xtmux3bi919(.xtout(xtout[919])，.a(a[919])，.b(b[919])，.c(c[919])，.sel(sel))； xtmux3bi920(.xtout(xtout[920])，.a(a[920])，.b(b[920])，.c(c[920])，.sel(sel))； xtmux3bi921(.xtout(xtout[921])，.a(a[921])，.b(b[921])，.c(c[921])，.sel(sel))； xtmux3bi922(.xtout(xtout[922])，.a(a[922])，.b(b[922])，.c(c[922])，.sel(sel))； xtmux3bi923(.xtout(xtout[923])，.a(a[923])，.b(b[923])，.c(c[923])，.sel(sel))； xtmux3bi924(.xtout(xtout[924])，.a(a[924])，.b(b[924])，.c(c[924])，.sel(sel))； xtmux3bi925(.xtout(xtout[925])，.a(a[925])，.b(b[925])，.c(c[925])，.sel(sel))； xtmux3bi926(.xtout(xtout[926])，.a(a[926])，.b(b[926])，.c(c[926])，.sel(sel))； xtmux3bi927(.xtout(xtout[927])，.a(a[927])，.b(b[927])，.c(c[927])，.sel(sel))； xtmux3bi928(.xtout(xtout[928])，.a(a[928])，.b(b[928])，.c(c[928])，.sel(sel))； xtmux3bi929(.xtout(xtout[929])，.a(a[929])，.b(b[929])，.c(c[929])，.sel(sel))； xtmux3bi930(.xtout(xtout[930])，.a(a[930])，.b(b[930])，.c(c[930])，.sel(sel))； xtmux3bi931(.xtout(xtout[931])，.a(a[931])，.b(b[931])，.c(c[931])，.sel(sel))； xtmux3bi932(.xtout(xtout[932])，.a(a[932])，.b(b[932])，.c(c[932])，.sel(sel))； xtmux3bi933(.xtout(xtout[933])，.a(a[933])，.b(b[933])，.c(c[933])，.sel(sel))；<dpn="d221"/> xtmux3bi934(.xtout(xtout[934])，.a(a[934])，.b(b[934])，.c(c[934])，.sel(sel))； xtmux3bi935(.xtout(xtout[935])，.a(a[935])，.b(b[935])，.c(c[935])，.sel(sel))； xtmux3bi936(.xtout(xtout[936])，.a(a[936])，.b(b[936])，.c(c[936])，.sel(sel))； xtmux3bi937(.xtout(xtout[937])，.a(a[937])，.b(b[937])，.c(c[937])，.sel(sel))； xtmux3bi938(.xtout(xtout[938])，.a(a[938])，.b(b[938])，.c(c[938])，.sel(sel))； xtmux3bi939(.xtout(xtout[939])，.a(a[939])，.b(b[939])，.c(c[939])，.sel(sel))； xtmux3bi940(.xtout(xtout[940])，.a(a[940])，.b(b[940])，.c(c[940])，.sel(sel))； xtmux3bi941(.xtout(xtout[941])，.a(a[941])，.b(b[941])，.c(c[941])，.sel(sel))； xtmux3bi942(.xtout(xtout[942])，.a(a[942])，.b(b[942])，.c(c[942])，.sel(sel))； xtmux3bi943(.xtout(xtout[943])，.a(a[943])，.b(b[943])，.c(c[943])，.sel(sel))； xtmux3bi944(.xtout(xtout[944])，.a(a[944])，.b(b[944])，.c(c[944])，.sel(sel))； xtmux3bi945(.xtout(xtout[945])，.a(a[945])，.b(b[945])，.c(c[945])，.sel(sel))； xtmux3bi946(.xtout(xtout[946])，.a(a[946])，.b(b[946])，.c(c[946])，.sel(sel))； xtmux3bi947(.xtout(xtout[947])，.a(a[947])，.b(b[947])，.c(c[947])，.sel(sel))； xtmux3bi948(.xtout(xtout[948])，.a(a[948])，.b(b[948])，.c(c[948])，.sel(sel))； xtmux3bi949(.xtout(xtout[949])，.a(a[949])，.b(b[949])，.c(c[949])，.sel(sel))； xtmux3bi950(.xtout(xtout[950])，.a(a[950])，.b(b[950])，.c(c[950])，.sel(sel))； xtmux3bi951(.xtout(xtout[951])，.a(a[951])，.b(b[951])，.c(c[951])，.sel(sel))； xtmux3bi952(.xtout(xtout[952])，.a(a[952])，.b(b[952])，.c(c[952])，.sel(sel))； xtmux3bi953(.xtout(xtout[953])，.a(a[953])，.b(b[953])，.c(c[953])，.sel(sel))； xtmux3bi954(.xtout(xtout[954])，.a(a[954])，.b(b[954])，.c(c[954])，.sel(sel))； xtmux3bi955(.xtout(xtout[955])，.a(a[955])，.b(b[955])，.c(c[955])，.sel(sel))； xtmux3bi956(.xtout(xtout[956])，.a(a[956])，.b(b[956])，.c(c[956])，.sel(sel))； xtmux3bi957(.xtout(xtout[957])，.a(a[957])，.b(b[957])，.c(c[957])，.sel(sel))； xtmux3bi958(.xtout(xtout[958])，.a(a[958])，.b(b[958])，.c(c[958])，.sel(sel))； xtmux3bi959(.xtout(xtout[959])，.a(a[959])，.b(b[959])，.c(c[959])，.sel(sel))； xtmux3bi960(.xtout(xtout[960])，.a(a[960])，.b(b[960])，.c(c[960])，.sel(sel))； xtmux3bi961(.xtout(xtout[961])，.a(a[961])，.b(b[961])，.c(c[961])，.sel(sel))； xtmux3bi962(.xtout(xtout[962])，.a(a[962])，.b(b[962])，.c(c[962])，.sel(sel))； xtmux3bi963(.xtout(xtout[963])，.a(a[963])，.b(b[963])，.c(c[963])，.sel(sel))；<dpn="d222"/> xtmux3bi964(.xtout(xtout[964])，.a(a[964])，.b(b[964])，.c(c[964])，.sel(sel)； xtmux3bi965(.xtout(xtout[965])，.a(a[965])，.b(b[965])，.c(c[965])，.sel(sel))； xtmux3bi966(.xtout(xtout[966])，.a(a[966])，.b(b[966])，.c(c[966])，.sel(sel))； xtmux3bi967(.xtout(xtout[967])，.a(a[967])，.b(b[967])，.c(c[967])，.sel(sel))； xtmux3bi968(.xtout(xtout[968])，.a(a[968])，.b(b[968])，.c(c[968])，.sel(sel))； xtmux3bi969(.xtout(xtout[969])，.a(a[969])，.b(b[969])，.c(c[969])，.sel(sel))； xtmux3bi970(.xtout(xtout[970])，.a(a[970])，.b(b[970])，.c(c[970])，.sel(sel))； xtmux3bi971(.xtout(xtout[971])，.a(a[971])，.b(b[971])，.c(c[971])，.sel(sel))； xtmux3bi972(.xtout(xtout[972])，.a(a[972])，.b(b[972])，.c(c[972])，.sel(sel))； xtmux3bi973(.xtout(xtout[973])，.a(a[973])，.b(b[973])，.c(c[973])，.sel(sel))； xtmux3bi974(.xtout(xtout[974])，.a(a[974])，.b(b[974])，.c(c[974])，.sel(sel))； xtmux3bi975(.xtout(xtout[975])，.a(a[975])，.b(b[975])，.c(c[975])，.sel(sel))； xtmux3bi976(.xtout(xtout[976])，.a(a[976])，.b(b[976])，.c(c[976])，.sel(sel))； xtmux3bi977(.xtout(xtout[977])，.a(a[977])，.b(b[977])，.c(c[977])，.sel(sel))； xtmux3bi978(.xtout(xtout[978])，.a(a[978])，.b(b[978])，.c(c[978])，.sel(sel))； xtmux3bi979(.xtout(xtout[979])，.a(a[979])，.b(b[979])，.c(c[979])，.sel(sel))； xtmux3bi980(.xtout(xtout[980])，.a(a[980])，.b(b[980])，.c(c[980])，.sel(sel))； xtmux3bi981(.xtout(xtout[981])，.a(a[981])，.b(b[981])，.c(c[981])，.sel(sel))； xtmux3bi982(.xtout(xtout[982])，.a(a[982])，.b(b[982])，.c(c[982])，.sel(sel))； xtmux3bi983(.xtout(xtout[983])，.a(a[983])，.b(b[983])，.c(c[983])，.sel(sel))； xtmux3bi984(.xtout(xtout[984])，.a(a[984])，.b(b[984])，.c(c[984])，.sel(sel))； xtmux3bi985(.xtout(xtout[985])，.a(a[985])，.b(b[985])，.c(c[985])，.sel(sel))； xtmux3bi986(.xtout(xtout[986])，.a(a[986])，.b(b[986])，.c(c[986])，.sel(sel))； xtmux3bi987(.xtout(xtout[987])，.a(a[987])，.b(b[987])，.c(c[987])，.sel(sel))； xtmux3bi988(.xtout(xtout[988])，.a(a[988])，.b(b[988])，.c(c[988])，.sel(sel))； xtmux3bi989(.xtout(xtout[989])，.a(a[989])，.b(b[989])，.c(c[989])，.sel(sel))； xtmux3bi990(.xtout(xtout[990])，.a(a[990])，.b(b[990])，.c(c[990])，.sel(sel))； xtmux3bi991(.xtout(xtout[991])，.a(a[991])，.b(b[991])，.c(c[991])，.sel(sel))； xtmux3bi992(.xtout(xtout[992])，.a(a[992])，.b(b[992])，.c(c[992])，.sel(sel))； xtmux3bi993(.xtout(xtout[993])，.a(a[993])，.b(b[993])，.c(c[993])，.sel(sel))；<dpn="d223"/> xtmux3bi994(.xtout(xtout[994])，.a(a[994])，.b(b[994])，.c(c[994])，.sel(sel))； xtmux3bi995(.xtout(xtout[995])，.a(a[995])，.b(b[995])，.c(c[995])，.sel(sel))； xtmux3bi996(.xtout(xtout[996])，.a(a[996])，.b(b[996])，.c(c[996])，.sel(sel))； xtmux3bi997(.xtout(xtout[997])，.a(a[997])，.b(b[997])，.c(c[997])，.sel(sel))； xtmux3bi998(.xtout(xtout[998])，.a(a[998])，.b(b[998])，.c(c[998])，.sel(sel))； xtmux3bi999(.xtout(xtout[999])，.a(a[999])，.b(b[999])，.c(c[999])，.sel(sel))； xtmux3bi1000(.xtout(xtout[1000])，.a(a[1000])，.b(b[1000])，.c(c[1000])，.sel(sel))； xtmux3bi1001(.xtout(xtout[1001])，.a(a[1001])，.b(b[1001])，.c(c[1001])，.sel(sel))； xtmux3bi1002(.xtout(xtout[1002])，.a(a[1002])，.b(b[1002])，.c(c[1002])，.sel(sel))； xtmux3bi1003(.xtout(xtout[1003])，.a(a[1003])，.b(b[1003])，.c(c[1003])，.sel(sel))； xtmux3bi1004(.xtout(xtout[1004])，.a(a[1004])，.b(b[1004])，.c(c[1004])，.sel(sel))； xtmux3bi1005(.xtout(xtout[1005])，.a(a[1005])，.b(b[1005])，.c(c[1005])，.sel(sel))； xtmux3bi1006(.xtout(xtout[1006])，.a(a[1006])，.b(b[1006])，.c(c[1006])，.sel(sel))； xtmux3bi1007(.xtout(xtout[1007])，.a(a[1007])，.b(b[1007])，.c(c[1007])，.sel(sel))； xtmux3bi1008(.xtout(xtout[1008])，.a(a[1008])，.b(b[1008])，.c(c[1008])，.sel(sel))； xtmux3bi1009(.xtout(xtout[1009])，.a(a[1009])，.b(b[1009])，.c(c[1009])，.sel(sel))； xtmux3bi1010(.xtout(xtout[1010])，.a(a[1010])，.b(b[1010])，.c(c[1010])，.sel(sel))； xtmux3bi1011(.xtout(xtout[1011])，.a(a[1011])，.b(b[1011])，.c(c[1011])，.sel(sel))； xtmux3bi1012(.xtout(xtout[1012])，.a(a[1012])，.b(b[1012])，.c(c[1012])，.sel(sel))； xtmux3bi1013(.xtout(xtout[1013])，.a(a[1013])，.b(b[1013])，.c(c[1013])，.sel(sel))； xtmux3bi1014(.xtout(xtout[1014])，.a(a[1014])，.b(b[1014])，.c(c[1014])，.sel(sel))； xtmux3bi1015(.xtout(xtout[1015])，.a(a[1015])，.b(b[1015])，.c(c[1015])，.sel(sel))； xtmux3bi1016(.xtout(xtout[1016])，.a(a[1016])，.b(b[1016])，.c(c[1016])，.sel(sel))； xtmux3bi1017(.xtout(xtout[1017])，.a(a[1017])，.b(b[1017])，.c(c[1017])，.sel(sel))； xtmux3bi1018(.xtout(xtout[1018])，.a(a[1018])，.b(b[1018])，.c(c[1018])，.sel(sel))； xtmux3bi1019(.xtout(xtout[1019])，.a(a[1019])，.b(b[1019])，.c(c[1019])，.sel(sel))； xtmux3bi1020(.xtout(xtout[1020])，.a(a[1020])，.b(b[1020])，.c(c[1020])，.sel(sel))； xtmux3bi1021(.xtout(xtout[1021])，.a(a[1021])，.b(b[1021])，.c(c[1021])，.sel(sel))； xtmux3bi1022(.xtout(xtout[1022])，.a(a[1022])，.b(b[1022])，.c(c[1022])，.sel(sel))； xtmux3bi1023(.xtout(xtout[1023])，.a(a[1023])，.b(b[1023])，.c(c[1023])，.sel(sel))；<dpn="d224"/>endmodulemodulextmux4e_1024(xtout，a，b，c，d，sel)；output[10230]xtout；input[10230]a，b，c，d；input[10]sel； xtmux4bi0(.xtout(xtout)，.a(a)，.b(b)，.c(c0])，.d(d)，.sel(sel))； xtmux4bi1(.xtout(xtout[1])，.a(a[1])，.b(b[1])，.c(c[1])，.d(d[1])，.sel(sel))； xtmux4bi2(.xtout(xtout[2])，.a(a[2])，.b(b[2])，.c(c[2])，.d(d[2])，.sel(sel))； xtmux4bi3(.xtout(xtout[3])，.a(a[3])，.b(b[3])，.c(c[3])，.d(d[3])，.sel(sel))； xtmux4bi4(.xtout(xtout[4])，.a(a[4])，.b(b[4])，.c(c[4])，.d(d[4])，.sel(sel))； xtmux4bi5(.xtout(xtout[5])，.a(a[5])，.b(b[5])，.c(c[5])，.d(d[5])，.sel(sel))； xtmux4bi6(.xtout(xtout[6])，.a(a[6])，.b(b[6])，.c(c[6])，.d(d[6])，.sel(sel))； xtmux4bi7(.xtout(xtout[7])，.a(a[7])，.b(b[7])，.c(c[7])，.d(d[7])，.sel(sel))； xtmux4bi8(.xtout(xtout[8])，.a(a[8])，.b(b[8])，.c(c[8])，.d(d[8])，.sel(sel))； xtmux4bi9(.xtout(xtout[9])，.a(a[9])，.b(b[9])，.c(c[9])，.d(d[9])，.sel(sel))； xtmux4bi10(.xtout(xtout[10])，.a(a[10])，.b(b[10])，.c(c[10])，.d(d[10])，.sel(sel))； xtmux4bi11(.xtout(xtout[11])，.a(a[11])，.b(b[11])，.c(c[11])，.d(d[11])，.sel(sel))； xtmux4bi12(.xtout(xtout[12])，.a(a[12])，.b(b[12])，.c(c[12])，.d(d[12])，.sel(sel))； xtmux4bi13(.xtout(xtout[13])，.a(a[13])，.b(b[13])，.c(c[13])，.d(d[13])，.sel(sel))； xtmux4bi14(.xtout(xtout[14])，.a(a[14])，.b(b[14])，.c(c[14])，.d(d[14])，.sel(sel))； xtmux4bi15(.xtout(xtout[15])，.a(a[15])，.b(b[15])，.c(c[15])，.d(d[15])，.sel(sel))； xtmux4bi16(.xtout(xtout[16])，.a(a[16])，.b(b[16])，.c(c[16])，.d(d[16])，.sel(sel))； xtmux4bi17(.xtout(xtout[17])，.a(a[17])，.b(b[17])，.c(c[17])，.d(d[17])，.sel(sel))； xtmux4bi18(.xtout(xtout[18])，.a(a[18])，.b(b[18])，.c(c[18])，.d(d[18])，.sel(sel))； xtmux4bi19(.xtout(xtout[19])，.a(a[19])，.b(b[19])，.c(c[19])，.d(d[19])，.sel(sel))； xtmux4bi20(.xtout(xtout[20])，.a(a[20])，.b(b[20])，.c(c[20])，.d(d[20])，.sel(sel))； xtmux4bi21(.xtout(xtout[21])，.a(a[21])，.b(b[21])，.c(c[21])，.d(d[21])，.sel(sel))； xtmux4bi22(.xtout(xtout[22])，.a(a[22])，.b(b[22])，.c(c[22])，.d(d[22])，.sel(sel))； xtmux4bi23(.xtout(xtout[23])，.a(a[23])，.b(b[23])，.c(c[23])，.d(d[23])，.sel(sel))； xtmux4bi24(.xtout(xtout[24])，.a(a[24])，.b(b[24])，.c(c[24])，.d(d[24])，.sel(sel))； xtmux4bi25(.xtout(xtout[25])，.a(a[25])，.b(b[25])，.c(c[25])，.d(d[25])，.sel(sel))； xtmux4bi26(.xtout(xtout[26])，.a(a[26])，.b(b[26])，.c(c[26])，.d(d[26])，.sel(sel))；<dpn="d225"/> xtmux4bi27(.xtout(xtout[27])，.a(a[27])，.b(b[27])，.c(c[27])，.d(d[27])，.sel(sel))； xtmux4bi28(.xtout(xtout[28])，.a(a[28])，.b(b[28])，.c(c[28])，.d(d[28])，.sel(sel))； xtmux4bi29(.xtout(xtout[29])，.a(a[29])，.b(b[29])，.c(c[29])，.d(d[29])，.sel(sel))； xtmux4bi30(.xtout(xtout[30])，.a(a[30])，.b(b[30])，.c(c[30])，.d(d[30])，.sel(sel))； xtmux4bi31(.xtout(xtout[31])，.a(a[31])，.b(b[31])，.c(c[31])，.d(d[31])，.sel(sel))； xtmux4bi32(.xtout(xtout[32])，.a(a[32])，.b(b[32])，.c(c[32])，.d(d[32])，.sel(sel))； xtmux4bi33(.xtout(xtout[33])，.a(a[33])，.b(b[33])，.c(c[33])，.d(d[33])，.sel(sel))； xtmux4bi34(.xtout(xtout[34])，.a(a[34])，.b(b[34])，.c(c[34])，.d(d[34])，.sel(sel))； xtmux4bi35(.xtout(xtout[35])，.a(a[35])，.b(b[35])，.c(c[35])，.d(d[35])，.sel(sel))； xtmux4bi36(.xtout(xtout[36])，.a(a[36])，.b(b[36])，.c(c[36])，.d(d[36])，.sel(sel))； xtmux4bi37(.xtout(xtout[37])，.a(a[37])，.b(b[37])，.c(c[37])，.d(d[37])，.sel(sel))； xtmux4bi38(.xtout(xtout[38])，.a(a[38])，.b(b[38])，.c(c[38])，.d(d[38])，.sel(sel))； xtmux4bi39(.xtout(xtout[39])，.a(a[39])，.b(b[39])，.c(c[39])，.d(d[39])，.sel(sel))； xtmux4bi40(.xtout(xtout[40])，.a(a[40])，.b(b[40])，.c(c[40])，.d(d[40])，.sel(sel))； xtmux4bi41(.xtout(xtout[41])，.a(a[41])，.b(b[41])，.c(c[41])，.d(d[41])，.sel(sel))； xtmux4bi42(.xtout(xtout[42])，.a(a[42])，.b(b[42])，.c(c[42])，.d(d[42])，.sel(sel))； xtmux4bi43(.xtout(xtout[43])，.a(a[43])，.b(b[43])，.c(c[43])，.d(d[43])，.sel(sel))； xtmux4bi44(.xtout(xtout[44])，.a(a[44])，.b(b[44])，.c(c[44])，.d(d[44])，.sel(sel))； xtmux4bi45(.xtout(xtout[45])，.a(a[45])，.b(b[45])，.c(c[45])，.d(d[45])，.sel(sel))； xtmux4bi46(.xtout(xtout[46])，.a(a[46])，.b(b[46])，.c(c[46])，.d(d[46])，.sel(sel))； xtmux4bi47(.xtout(xtout[47])，.a(a[47])，.b(b[47])，.c(c[47])，.d(d[47])，.sel(sel))； xtmux4bi48(.xtout(xtout[48])，.a(a[48])，.b(b[48])，.c(c[48])，.d(d[48])，.sel(sel))； xtmux4bi49(.xtout(xtout[49])，.a(a[49])，.b(b[49])，.c(c[49])，.d(d[49])，.sel(sel))； xtmux4bi50(.xtout(xtout[50])，.a(a[50])，.b(b[50])，.c(c[50])，.d(d[50])，.sel(sel))； xtmux4bi51(.xtout(xtout[51])，.a(a[51])，.b(b[51])，.c(c[51])，.d(d[51])，.sel(sel))； xtmux4bi52(.xtout(xtout[52])，.a(a[52])，.b(b[52])，.c(c[52])，.d(d[52])，.sel(sel))； xtmux4bi53(.xtout(xtout[53])，.a(a[53])，.b(b[53])，.c(c[53])，.d(d[53])，.sel(sel))； xtmux4bi54(.xtout(xtout[54])，.a(a[54])，.b(b[54])，.c(c[54])，.d(d[54])，.sel(sel))； xtmux4bi55(.xtout(xtout[55])，.a(a[55])，.b(b[55])，.c(c[55])，.d(d[55])，.sel(sel))； xtmux4bi56(.xtout(xtout[56])，.a(a[56])，.b(b[56])，.c(c[56])，.d(d[56])，.sel(sel))；<dpn="d226"/> xtmux4bi57(.xtout(xtout[57])，.a(a[57])，.b(b[57])，.c(c[57])，.d(d[57])，.sel(sel))； xtmux4bi58(.xtout(xtout[58])，.a(a[58])，.b(b[58])，.c(c[58])，.d(d[58])，.sel(sel))； xtmux4bi59(.xtout(xtout[59])，.a(a[59])，.b(b[59])，.c(c[59])，.d(d[59])，.sel(sel))； xtmux4bi60(.xtout(xtout[60])，.a(a[60])，.b(b[60])，.c(c[60])，.d(d[60])，.sel(sel))； xtmux4bi61(.xtout(xtout[61])，.a(a[61])，.b(b[61])，.c(c[61])，.d(d[61])，.sel(sel))； xtmux4bi62(.xtout(xtout[62])，.a(a[62])，.b(b[62])，.c(c[62])，.d(d[62])，.sel(sel))； xtmux4bi63(.xtout(xtout[63])，.a(a[63])，.b(b[63])，.c(c[63])，.d(d[63])，.sel(sel))； xtmux4bi64(.xtout(xtout[64])，.a(a[64])，.b(b[64])，.c(c[64])，.d(d[64])，.sel(sel))； xtmux4bi65(.xtout(xtout[65])，.a(a[65])，.b(b[65])，.c(c[65])，.d(d[65])，.sel(sel))； xtmux4bi66(.xtout(xtout[66])，.a(a[66])，.b(b[66])，.c(c[66])，.d(d[66])，.sel(sel))； xtmux4bi67(.xtout(xtout[67])，.a(a[67])，.b(b[67])，.c(c[67])，.d(d[67])，.sel(sel))； xtmux4bi68(.xtout(xtout[68])，.a(a[68])，.b(b[68])，.c(c[68])，.d(d[68])，.sel(sel))； xtmux4bi69(.xtout(xtout[69])，.a(a[69])，.b(b[69])，.c(c[69])，.d(d[69])，.sel(sel))； xtmux4bi70(.xtout(xtout[70])，.a(a[70])，.b(b[70])，.c(c[70])，.d(d[70])，.sel(sel))； xtmux4bi71(.xtout(xtout[71])，.a(a[71])，.b(b[71])，.c(c[71])，.d(d[71])，.sel(sel))； xtmux4bi72(.xtout(xtout[72])，.a(a[72])，.b(b[72])，.c(c[72])，.d(d[72])，.sel(sel))； xtmux4bi73(.xtout(xtout[73])，.a(a[73])，.b(b[73])，.c(c[73])，.d(d[73])，.sel(sel))； xtmux4bi74(.xtout(xtout[74])，.a(a[74])，.b(b[74])，.c(c[74])，.d(d[74])，.sel(sel))； xtmux4bi75(.xtout(xtout[75])，.a(a[75])，.b(b[75])，.c(c[75])，.d(d[75])，.sel(sel))； xtmux4bi76(.xtout(xtout[76])，.a(a[76])，.b(b[76])，.c(c[76])，.d(d[76])，.sel(sel))； xtmux4bi77(.xtout(xtout[77])，.a(a[77])，.b(b[77])，.c(c[77])，.d(d[77])，.sel(sel))； xtmux4bi78(.xtout(xtout[78])，.a(a[78])，.b(b[78])，.c(c[78])，.d(d[78])，.sel(sel))； xtmux4bi79(.xtout(xtout[79])，.a(a[79])，.b(b[79])，.c(c[79])，.d(d[79])，.sel(sel))； xtmux4bi80(.xtout(xtout[80])，.a(a[80])，.b(b[80])，.c(c[80])，.d(d[80])，.sel(sel))； xtmux4bi81(.xtout(xtout[81])，.a(a[81])，.b(b[81])，.c(c[81])，.d(d[81])，.sel(sel))； xtmux4bi82(.xtout(xtout[82])，.a(a[82])，.b(b[82])，.c(c[82])，.d(d[82])，.sel(sel))； xtmux4bi83(.xtout(xtout[83])，.a(a[83])，.b(b[83])，.c(c[83])，.d(d[83])，.sel(sel))； xtmux4bi84(.xtout(xtout[84])，.a(a[84])，.b(b[84])，.c(c[84])，.d(d[84])，.sel(sel))； xtmux4bi85(.xtout(xtout[85])，.a(a[85])，.b(b[85])，.c(c[85])，.d(d[85])，.sel(sel))； xtmux4bi86(.xtout(xtout[86])，.a(a[86])，.b(b[86])，.c(c[86])，.d(d[86])，.sel(sel))；<dpn="d227"/> xtmux4bi87(.xtout(xtout[87])，.a(a[87])，.b(b[87])，.c(c[87])，.d(d[87])，sel(sel))； xtmux4bi88(.xtout(xtout[88])，.a(a[88])，.b(b[88])，.c(c[88])，.d(d[88])，sel(sel))； xtmux4bi89(.xtout(xtout[89])，.a(a[89])，.b(b[89])，.c(c[89])，.d(d[89])，sel(sel))； xtmux4bi90(.xtout(xtout[90])，.a(a[90])，.b(b[90])，.c(c[90])，.d(d[90])，sel(sel))； xtmux4bi91(.xtout(xtout[91])，.a(a[91])，.b(b[91])，.c(c[91])，.d(d[91])，sel(sel))； xtmux4bi92(.xtout(xtout[92])，.a(a[92])，.b(b[92])，.c(c[92])，.d(d[92])，sel(sel))； xtmux4bi93(.xtout(xtout[93])，.a(a[93])，.b(b[93])，.c(c[93])，.d(d[93])，sel(sel))； xtmux4bi94(.xtout(xtout[94])，.a(a[94])，.b(b[94])，.c(c[94])，.d(d[94])，sel(sel))； xtmux4bi95(.xtout(xtout[95])，.a(a[95])，.b(b[95])，.c(c[95])，.d(d[95])，sel(sel))； xtmux4bi96(.xtout(xtout[96])，.a(a[96])，.b(b[96])，.c(c[96])，.d(d[96])，sel(sel))； xtmux4bi97(.xtout(xtout[97])，.a(a[97])，.b(b[97])，.c(c[97])，.d(d[97])，sel(sel))； xtmux4bi98(.xtout(xtout[98])，.a(a[98])，.b(b[98])，.c(c[98])，.d(d[98])，.sel(sel))； xtmux4bi99(.xtout(xtout[99])，.a(a[99])，.b(b[99])，.c(c[99])，.d(d[99])，.sel(sel))； xtmux4bi100(.xtout(xtout[100])，.a(a[100])，.b(b[100])，.c(c[100])，.d(d[100])，.sel(sel))； xtmux4bi101(.xtout(xtout[101])，.a(a[101])，.b(b[101])，.c(c[101])，.d(d[101])，.sel(sel))； xtmux4bi102(.xtout(xtout[102])，.a(a[102])，.b(b[102])，.c(c[102])，.d(d[102])，.sel(sel))； xtmux4bi103(.xtout(xtout[103])，.a(a[103])，.b(b[103])，.c(c[103])，.d(d[103])，.sel(sel))； xtmux4bi104(.xtout(xtout[104])，.a(a[104])，.b(b[104])，.c(c[104])，.d(d[104])，.sel(sel))； xtmux4bi105(.xtout(xtout[105])，.a(a[105])，.b(b[105])，.c(c[105])，.d(d[105])，.sel(sel))； xtmux4bi106(.xtout(xtout[106])，.a(a[106])，.b(b[106])，.c(c[106])，.d(d[106])，.sel(sel))； xtmux4bi107(.xtout(xtout[107])，.a(a[107])，.b(b[107])，.c(c[107])，.d(d[107])，.sel(sel))； xtmux4bi108(.xtout(xtout[108])，.a(a[108])，.b(b[108])，.c(c[108])，.d(d[108])，.sel(sel))； xtmux4bi109(.xtout(xtout[109])，.a(a[109])，.b(b[109])，.c(c[109])，.d(d[109])，.sel(sel))； xtmux4bi110(.xtout(xtout[110])，.a(a[110])，.b(b[110])，.c(c[110])，.d(d[110])，.sel(sel))； xtmux4bi111(.xtout(xtout[111])，.a(a[111])，.b(b[111])，.c(c[111])，.d(d[111])，.sel(sel))； xtmux4bi112(.xtout(xtout[112])，.a(a[112])，.b(b[112])，.c(c[112])，.d(d[112])，.el(sel))； xtmux4bi113(.xtout(xtout[113])，.a(a[113])，.b(b[113])，.c(c[113])，.d(d[113])，.sel(sel))； xtmux4bi114(.xtout(xtout[114])，.a(a[114])，.b(b[114])，.c(c[114])，.d(d[114])，.sel(sel))； xtmux4bi115(.xtout(xtout[115])，.a(a[115])，.b(b[115])，.c(c[115])，.d(d[115])，.sel(sel))； xtmux4bi116(.xtout(xtout[116])，.a(a[116])，.b(b[116])，.c(c[116])，.d(d[116])，.sel(sel))；<dpn="d228"/> xtmux4bi117(.xtout(xtout[117])，.a(a[117])，.b(b[117])，.c(c[117])，.d(d[117])，.sel(sel))； xtmux4bi118(.xtout(xtout[118])，.a(a[118])，.b(b[118])，.c(c[118])，.d(d[118])，.sel(sel))； xtmux4bi119(.xtout(xtout[119])，.a(a[119])，.b(b[119])，.c(c[119])，.d(d[119])，.sel(sel))； xtmux4bi120(.xtout(xtout[120])，.a(a[120])，.b(b[120])，.c(c[120])，.d(d[120])，.sel(sel))； xtmux4bi121(.xtout(xtout[121])，.a(a[121])，.b(b[121])，.c(c[121])，.d(d[121])，.sel(sel))； xtmux4bi122(.xtout(xtout[122])，.a(a[122])，.b(b[122])，.c(c[122])，.d(d[122])，.sel(sel))； xtmux4bi123(.xtout(xtout[123])，.a(a[123])，.b(b[123])，.c(c[123])，.d(d[123])，.sel(sel))； xtmux4bi124(.xtout(xtout[124])，.a(a[124])，.b(b[124])，.c(c[124])，.d(d[124])，.sel(sel))； xtmux4bi125(.xtout(xtout[125])，.a(a[125])，.b(b[125])，.c(c[125])，.d(d[125])，.sel(sel))； xtmux4bi126(.xtout(xtout[126])，.a(a[126])，.b(b[126])，.c(c[126])，.d(d[126])，.sel(sel))； xtmux4bi127(.xtout(xtout[127])，.a(a[127])，.b(b[127])，.c(c[127])，.d(d[127])，.sel(sel))； xtmux4bi128(.xtout(xtout[128])，.a(a[128])，.b(b[128])，.c(c[128])，.d(d[128])，.sel(sel))； xtmux4bi129(.xtout(xtout[129])，.a(a[129])，.b(b[129])，.c(c[129])，.d(d[129])，.sel(sel))； xtmux4bi130(.xtout(xtout[130])，.a(a[130])，.b(b[130])，.c(c[130])，.d(d[130])，.sel(sel))； xtmux4bi131(.xtout(xtout[131])，.a(a[131])，.b(b[131])，.c(c[131])，.d(d[131])，.sel(sel))； xtmux4bi132(.xtout(xtout[132])，.a(a[132])，.b(b[132])，.c(c[132])，.d(d[132])，.sel(sel))； xtmux4bi133(.xtout(xtout[133])，.a(a[133])，.b(b[133])，.c(c[133])，.d(d[133])，.sel(sel))； xtmux4bi134(.xtout(xtout[134])，.a(a[134])，.b(b[134])，.c(c[134])，.d(d[134])，.sel(sel))； xtmux4bi135(.xtout(xtout[135])，.a(a[135])，.b(b[135])，.c(c[135])，.d(d[135])，.sel(sel))； xtmux4bi136(.xtout(xtout[136])，.a(a[136])，.b(b[136])，.c(c[136])，.d(d[136])，.sel(sel))； xtmux4bi137(.xtout(xtout[137])，.a(a[137])，.b(b[137])，.c(c[137])，.d(d[137])，.sel(sel))； xtmux4bi138(.xtout(xtout[138])，.a(a[138])，.b(b[138])，.c(c[138])，.d(d[138])，.sel(sel))； xtmux4bi139(.xtout(xtout[139])，.a(a[139])，.b(b[139])，.c(c[139])，.d(d[139])，.sel(sel))； xtmux4bi140(.xtout(xtout[140])，.a(a[140])，.b(b[140])，.c(c[140])，.d(d[140])，.sel(sel))； xtmux4bi141(.xtout(xtout[141])，.a(a[141])，.b(b[141])，.c(c[141])，.d(d[141])，.sel(sel))； xtmux4bi142(.xtout(xtout[142])，.a(a[142])，.b(b[142])，.c(c[142])，.d(d[142])，.sel(sel))； xtmux4bi143(.xtout(xtout[143])，.a(a[143])，.b(b[143])，.c(c[143])，.d(d[143])，.sel(sel))； xtmux4bi144(.xtout(xtout[144])，.a(a[144])，.b(b[144])，.c(c[144])，.d(d[144])，.sel(sel))； xtmux4bi145(.xtout(xtout[145])，.a(a[145])，.b(b[145])，.c(c[145])，.d(d[145])，.sel(sel))； xtmux4bi146(.xtout(xtout[146])，.a(a[146])，.b(b[146])，.c(c[146])，.d(d[146])，.sel(sel))；<dpn="d229"/> xtmux4bi147(.xtout(xtout[147])，.a(a[147])，.b(b[147])，.c(c[147])，.d(d[147])，.sel(sel))； xtmux4bi148(.xtout(xtout[148])，.a(a[148])，.b(b[148])，.c(c[148])，.d(d[148])，.sel(sel))； xtmux4bi149(.xtout(xtout[149])，.a(a[149])，.b(b[149])，.c(c[149])，.d(d[149])，.sel(sel))； xtmux4bi150(.xtout(xtout[150])，.a(a[150])，.b(b[150])，.c(c[150])，.d(d[150])，.sel(sel))； xtmux4bi151(.xtout(xtout[151])，.a(a[151])，.b(b[151])，.c(c[151])，.d(d[151])，.sel(sel))； xtmux4bi152(.xtout(xtout[152])，.a(a[152])，.b(b[152])，.c(c[152])，.d(d[152])，.sel(sel))； xtmux4bi153(.xtout(xtout[153])，.a(a[153])，.b(b[153])，.c(c[153])，.d(d[153])，.sel(sel))； xtmux4bi154(.xtout(xtout[154])，.a(a[154])，.b(b[154])，.c(c[154])，.d(d[154])，.sel(sel))； xtmux4bi155(.xtout(xtout[155])，.a(a[155])，.b(b[155])，.c(c[155])，.d(d[155])，.sel(sel))； xtmux4bi156(.xtout(xtout[156])，.a(a[156])，.b(b[156])，.c(c[156])，.d(d[156])，.sel(sel))； xtmux4bi157(.xtout(xtout[157])，.a(a[157])，.b(b[157])，.c(c[157])，.d(d[157])，.sel(sel))； xtmux4bi158(.xtout(xtout[158])，.a(a[158])，.b(b[158])，.c(c[158])，.d(d[158])，.sel(sel))； xtmux4bi159(.xtout(xtout[159])，.a(a[159])，.b(b[159])，.c(c[159])，.d(d[159])，.sel(sel))； xtmux4bi160(.xtout(xtout[160])，.a(a[160])，.b(b[160])，.c(c[160])，.d(d[160])，.sel(sel))； xtmux4bi161(.xtout(xtout[161])，.a(a[161])，.b(b[161])，.c(c[161])，.d(d[161])，.sel(sel))； xtmux4bi162(.xtout(xtout[162])，.a(a[162])，.b(b[162])，.c(c[162])，.d(d[162])，.sel(sel))； xtmux4bi163(.xtout(xtout[163])，.a(a[163])，.b(b[163])，.c(c[163])，.d(d[163])，.sel(sel))； xtmux4bi164(.xtout(xtout[164])，.a(a[164])，.b(b[164])，.c(c[164])，.d(d[164])，.sel(sel))； xtmux4bi165(.xtout(xtout[165])，.a(a[165])，.b(b[165])，.c(c[165])，.d(d[165])，.sel(sel))； xtmux4bi166(.xtout(xtout[166])，.a(a[166])，.b(b[166])，.c(c[166])，.d(d[166])，.sel(sel))； xtmux4bi167(.xtout(xtout[167])，.a(a[167])，.b(b[167])，.c(c[167])，.d(d[167])，.sel(sel))； xtmux4bi168(.xtout(xtout[168])，.a(a[168])，.b(b[168])，.c(c[168])，.d(d[168])，.sel(sel))； xtmux4bi169(.xtout(xtout[169])，.a(a[169])，.b(b[169])，.c(c[169])，.d(d[169])，.sel(sel))； xtmux4bi170(.xtout(xtout[170])，.a(a[170])，.b(b[170])，.c(c[170])，.d(d[170])，.sel(sel))； xtmux4bi171(.xtout(xtout[171])，.a(a[171])，.b(b[171])，.c(c[171])，.d(d[171])，.sel(sel))； xtmux4bi172(.xtout(xtout[172])，.a(a[172])，.b(b[172])，.c(c[172])，.d(d[172])，.sel(sel))； xtmux4bi173(.xtout(xtout[173])，.a(a[173])，.b(b[173])，.c(c[173])，.d(d[173])，.sel(sel))； xtmux4bi174(.xtout(xtout[174])，.a(a[174])，.b(b[174])，.c(c[174])，.d(d[174])，.sel(sel))； xtmux4bi175(.xtout(xtout[175])，.a(a[175])，.b(b[175])，.c(c[175])，.d(d[175])，.sel(sel))； xtmux4bi176(.xtout(xtout[176])，.a(a[176])，.b(b[176])，.c(c[176])，.d(d[176])，.sel(sel))；<dpn="d230"/> xtmux4bi177(.xtout(xtout[177])，.a(a[177])，.b(b[177])，.c(c[177])，.d(d[177])，.sel(sel))； xtmux4bi178(.xtout(xtout[178])，.a(a[178])，.b(b[178])，.c(c[178])，.d(d[178])，.sel(sel))； xtmux4bi179(.xtout(xtout[179])，.a(a[179])，.b(b[179])，.c(c[179])，.d(d[179])，.sel(sel))； xtmux4bi180(.xtout(xtout[180])，.a(a[180])，.b(b[180])，.c(c[180])，.d(d[180])，.sel(sel))； xtmux4bi181(.xtout(xtout[181])，.a(a[181])，.b(b[181])，.c(c[181])，.d(d[181])，.sel(sel))； xtmux4bi182(.xtout(xtout[182])，.a(a[182])，.b(b[182])，.c(c[182])，.d(d[182])，.sel(sel))； xtmux4bi183(.xtout(xtout[183])，.a(a[183])，.b(b[183])，.c(c[183])，.d(d[183])，.sel(sel))； xtmux4bi184(.xtout(xtout[184])，.a(a[184])，.b(b[184])，.c(c[184])，.d(d[184])，.sel(sel))； xtmux4bi185(.xtout(xtout[185])，.a(a[185])，.b(b[185])，.c(c[185])，.d(d[185])，.sel(sel))； xtmux4bi186(.xtout(xtout[186])，.a(a[186])，.b(b[186])，.c(c[186])，.d(d[186])，.sel(sel))； xtmux4bi187(.xtout(xtout[187])，.a(a[187])，.b(b[187])，.c(c[187])，.d(d[187])，.sel(sel))； xtmux4bi188(.xtout(xtout[188])，.a(a[188])，.b(b[188])，.c(c[188])，.d(d[188])，.sel(sel))； xtmux4bi189(.xtout(xtout[189])，.a(a[189])，.b(b[189])，.c(c[189])，.d(d[189])，.sel(sel))； xtmux4bi190(.xtout(xtout[190])，.a(a[190])，.b(b[190])，.c(c[190])，.d(d[190])，.sel(sel))； xtmux4bi191(.xtout(xtout[191])，.a(a[191])，.b(b[191])，.c(c[191])，.d(d[191])，.sel(sel))； xtmux4bi192(.xtout(xtout[192])，.a(a[192])，.b(b[192])，.c(c[192])，.d(d[192])，.sel(sel))； xtmux4bi193(.xtout(xtout[193])，.a(a[193])，.b(b[193])，.c(c[193])，.d(d[193])，.sel(sel))； xtmux4bi194(.xtout(xtout[194])，.a(a[194])，.b(b[194])，.c(c[194])，.d(d[194])，.sel(sel))； xtmux4bi195(.xtout(xtout[195])，.a(a[195])，.b(b[195])，.c(c[195])，.d(d[195])，.sel(sel))； xtmux4bi196(.xtout(xtout[196])，.a(a[196])，.b(b[196])，.c(c[196])，.d(d[196])，.sel(sel))； xtmux4bi197(.xtout(xtout[197])，.a(a[197])，.b(b[197])，.c(c[197])，.d(d[197])，.sel(sel))； xtmux4bi198(.xtout(xtout[198])，.a(a[198])，.b(b[198])，.c(c[198])，.d(d[198])，.sel(sel))； xtmux4bi199(.xtout(xtout[199])，.a(a[199])，.b(b[199])，.c(c[199])，.d(d[199])，.sel(sel))； xtmux4bi200(.xtout(xtout[200])，.a(a[200])，.b(b[200])，.c(c[200])，.d(d[200])，.sel(sel))； xtmux4bi201(.xtout(xtout[201])，.a(a[201])，.b(b[201])，.c(c[201])，.d(d[201])，.sel(sel))； xtmux4bi202(.xtout(xtout[202])，.a(a[202])，.b(b[202])，.c(c[202])，.d(d[202])，.sel(sel))； xtmux4bi203(.xtout(xtout[203])，.a(a[203])，.b(b[203])，.c(c[203])，.d(d[203])，.sel(sel))； xtmux4bi204(.xtout(xtout[204])，.a(a[204])，.b(b[204])，.c(c[204])，.d(d[204])，.sel(sel))； xtmux4bi205(.xtout(xtout[205])，.a(a[205])，.b(b[205])，.c(c[205])，.d(d[205])，.sel(sel))； xtmux4bi206(.xtout(xtout[206])，.a(a[206])，.b(b[206])，.c(c[206])，.d(d[206])，.sel(sel))；<dpn="d231"/> xtmux4bi207(.xtout(xtout[207])，.a(a[207])，.b(b[207])，.c(c[207])，.d(d[207])，.sel(sel))； xtmux4bi208(.xtout(xtout[208])，.a(a[208])，.b(b[208])，.c(c[208])，.d(d[208])，.sel(sel))； xtmux4bi209(.xtout(xtout[209])，.a(a[209])，.b(b[209])，.c(c[209])，.d(d[209])，.sel(sel))； xtmux4bi210(.xtout(xtout[210])，.a(a[210])，.b(b[210])，.c(c[210])，.d(d[210])，.sel(sel))； xtmux4bi211(.xtout(xtout[211])，.a(a[211])，.b(b[211])，.c(c[211])，.d(d[211])，.sel(sel))； xtmux4bi212(.xtout(xtout[212])，.a(a[212])，.b(b[212])，.c(c[212])，.d(d[212])，.sel(sel))； xtmux4bi213(.xtout(xtout[213])，.a(a[213])，.b(b[213])，.c(c[213])，.d(d[213])，.sel(sel))； xtmux4bi214(.xtout(xtout[214])，.a(a[214])，.b(b[214])，.c(c[214])，.d(d[214])，.sel(sel))； xtmux4bi215(.xtout(xtout[215])，.a(a[215])，.b(b[215])，.c(c[215])，.d(d[215])，.sel(sel))； xtmux4bi216(.xtout(xtout[216])，.a(a[216])，.b(b[216])，.c(c[216])，.d(d[216])，.sel(sel))； xtmux4bi217(.xtout(xtout[217])，.a(a[217])，.b(b[217])，.c(c[217])，.d(d[217])，.sel(sel))； xtmux4bi218(.xtout(xtout[218])，.a(a[218])，.b(b[218])，.c(c[218])，.d(d[218])，.sel(sel))； xtmux4bi219(.xtout(xtout[219])，.a(a[219])，.b(b[219])，.c(c[219])，.d(d[219])，.sel(sel))； xtmux4bi220(.xtout(xtout[220])，.a(a[220])，.b(b[220])，.c(c[220])，.d(d[220])，.sel(sel))； xtmux4bi221(.xtout(xtout[221])，.a(a[221])，.b(b[221])，.c(c[221])，.d(d[221])，.sel(sel))； xtmux4bi222(.xtout(xtout[222])，.a(a[222])，.b(b[222])，.c(c[222])，.d(d[222])，.sel(sel))； xtmux4bi223(.xtout(xtout[223])，.a(a[223])，.b(b[223])，.c(c[223])，.d(d[223])，.sel(sel))； xtmux4bi224(.xtout(xtout[224])，.a(a[224])，.b(b[224])，.c(c[224])，.d(d[224])，.sel(sel))； xtmux4bi225(.xtout(xtout[225])，.a(a[225])，.b(b[225])，.c(c[225])，.d(d[225])，.sel(sel))； xtmux4bi226(.xtout(xtout[226])，.a(a[226])，.b(b[226])，.c(c[226])，.d(d[226])，.sel(sel))； xtmux4bi227(.xtout(xtout[227])，.a(a[227])，.b(b[227])，.c(c[227])，.d(d[227])，.sel(sel))； xtmux4bi228(.xtout(xtout[228])，.a(a[228])，.b(b[228])，.c(c[228])，.d(d[228])，.sel(sel))； xtmux4bi229(.xtout(xtout[229])，.a(a[229])，.b(b[229])，.c(c[229])，.d(d[229])，.sel(sel))； xtmux4bi230(.xtout(xtout[230])，.a(a[230])，.b(b[230])，.c(c[230])，.d(d[230])，.sel(sel))； xtmux4bi231(.xtout(xtout[231])，.a(a[231])，.b(b[231])，.c(c[231])，.d(d[231])，.sel(sel))； xtmux4bi232(.xtout(xtout[232])，.a(a[232])，.b(b[232])，.c(c[232])，.d(d[232])，.sel(sel))； xtmux4bi233(.xtout(xtout[233])，.a(a[233])，.b(b[233])，.c(c[233])，.d(d[233])，.sel(sel))； xtmux4bi234(.xtout(xtout[234])，.a(a[234])，.b(b[234])，.c(c[234])，.d(d[234])，.sel(sel))； xtmux4bi235(.xtout(xtout[235])，.a(a[235])，.b(b[235])，.c(c[235])，.d(d[235])，.sel(sel))； xtmux4bi236(.xtout(xtout[236])，.a(a[236])，.b(b[236])，.c(c[236])，.d(d[236])，.sel(sel))；<dpn="d232"/> xtmux4bi237(.xtout(xtout[237])，.a(a[237])，.b(b[237])，.c(c[237])，.d(d[237])，.sel(sel))； xtmux4bi238(.xtout(xtout[238])，.a(a[238])，.b(b[238])，.c(c[238])，.d(d[238])，.sel(sel))； xtmux4bi239(.xtout(xtout[239])，.a(a[239])，.b(b[239])，.c(c[239])，.d(d[239])，.sel(sel))； xtmux4bi240(.xtout(xtout[240])，.a(a[240])，.b(b[240])，.c(c[240])，.d(d[240])，.sel(sel))； xtmux4bi241(.xtout(xtout[241])，.a(a[241])，.b(b[241])，.c(c[241])，.d(d[241])，.sel(sel))； xtmux4bi242(.xtout(xtout[242])，.a(a[242])，.b(b[242])，.c(c[242])，.d(d[242])，.sel(sel))； xtmux4bi243(.xtout(xtout[243])，.a(a[243])，.b(b[243])，.c(c[243])，.d(d[243])，.sel(sel))； xtmux4bi244(.xtout(xtout[244])，.a(a[244])，.b(b[244])，.c(c[244])，.d(d[244])，.sel(sel))； xtmux4bi245(.xtout(xtout[245])，.a(a[245])，.b(b[245])，.c(c[245])，.d(d[245])，.sel(sel))； xtmux4bi246(.xtout(xtout[246])，.a(a[246])，.b(b[246])，.c(c[246])，.d(d[246])，.sel(sel))； xtmux4bi247(.xtout(xtout[247])，.a(a[247])，.b(b[247])，.c(c[247])，.d(d[247])，.sel(sel))； xtmux4bi248(.xtout(xtout[248])，.a(a[248])，.b(b[248])，.c(c[248])，.d(d[248])，.sel(sel))； xtmux4bi249(.xtout(xtout[249])，.a(a[249])，.b(b[249])，.c(c[249])，.d(d[249])，.sel(sel))； xtmux4bi250(.xtout(xtout[250])，.a(a[250])，.b(b[250])，.c(c[250])，.d(d[250])，.sel(sel))； xtmux4bi251(.xtout(xtout[251])，.a(a[251])，.b(b[251])，.c(c[251])，.d(d[251])，.sel(sel))； xtmux4bi252(.xtout(xtout[252])，.a(a[252])，.b(b[252])，.c(c[252])，.d(d[252])，.sel(sel))； xtmux4bi253(.xtout(xtout[253])，.a(a[253])，.b(b[253])，.c(c[253])，.d(d[253])，.sel(sel))； xtmux4bi254(.xtout(xtout[254])，.a(a[254])，.b(b[254])，.c(c[254])，.d(d[254])，.sel(sel))； xtmux4bi255(.xtout(xtout[255])，.a(a[255])，.b(b[255])，.c(c[255])，.d(d[255])，.sel(sel))； xtmux4bi256(.xtout(xtout[256])，.a(a[256])，.b(b[256])，.c(c[256])，.d(d[256])，.sel(sel))； xtmux4bi257(.xtout(xtout[257])，.a(a[257])，.b(b[257])，.c(c[257])，.d(d[257])，.sel(sel))； xtmux4bi258(.xtout(xtout[258])，.a(a[258])，.b(b[258])，.c(c[258])，.d(d[258])，.sel(sel))； xtmux4bi259(.xtout(xtout[259])，.a(a[259])，.b(b[259])，.c(c[259])，.d(d[259])，.sel(sel))； xtmux4bi260(.xtout(xtout[260])，.a(a[260])，.b(b[260])，.c(c[260])，.d(d[260])，.sel(sel))； xtmux4bi261(.xtout(xtout[261])，.a(a[261])，.b(b[261])，.c(c[261])，.d(d[261])，.sel(sel))； xtmux4bi262(.xtout(xtout[262])，.a(a[262])，.b(b[262])，.c(c[262])，.d(d[262])，.sel(sel))； xtmux4bi263(.xtout(xtout[263])，.a(a[263])，.b(b[263])，.c(c[263])，.d(d[263])，.sel(sel))； xtmux4bi264(.xtout(xtout[264])，.a(a[264])，.b(b[264])，.c(c[264])，.d(d[264])，.sel(sel))； xtmux4bi265(.xtout(xtout[265])，.a(a[265])，.b(b[265])，.c(c[265])，.d(d[265])，.sel(sel))； xtmux4bi266(.xtout(xtout[266])，.a(a[266])，.b(b[266])，.c(c[266])，.d(d[266])，.sel(sel))；<dpn="d233"/> xtmux4bi267(.xtout(xtout[267])，.a(a[267])，.b(b[267])，.c(c[267])，.d(d[267])，.sel(sel))； xtmux4bi268(.xtout(xtout[268])，.a(a[268])，.b(b[268])，.c(c[268])，.d(d[268])，.sel(sel))； xtmux4bi269(.xtout(xtout[269])，.a(a[269])，.b(b[269])，.c(c[269])，.d(d[269])，.sel(sel))； xtmux4bi270(.xtout(xtout[270])，.a(a[270])，.b(b[270])，.c(c[270])，.d(d[270])，.sel(sel))； xtmux4bi271(.xtout(xtout[271])，.a(a[271])，.b(b[271])，.c(c[271])，.d(d[271])，.sel(sel))； xtmux4bi272(.xtout(xtout[272])，.a(a[272])，.b(b[272])，.c(c[272])，.d(d[272])，.sel(sel))； xtmux4bi273(.xtout(xtout[273])，.a(a[273])，.b(b[273])，.c(c[273])，.d(d[273])，.sel(sel))； xtmux4bi274(.xtout(xtout[274])，.a(a[274])，.b(b[274])，.c(c[274])，.d(d[274])，.sel(sel))； xtmux4bi275(.xtout(xtout[275])，.a(a[275])，.b(b[275])，.c(c[275])，.d(d[275])，.sel(sel))； xtmux4bi276(.xtout(xtout[276])，.a(a[276])，.b(b[276])，.c(c[276])，.d(d[276])，.sel(sel))； xtmux4bi277(.xtout(xtout[277])，.a(a[277])，.b(b[277])，.c(c[277])，.d(d[277])，.sel(sel))； xtmux4bi278(.xtout(xtout[278])，.a(a[278])，.b(b[278])，.c(c[278])，.d(d[278])，.sel(sel))； xtmux4bi279(.xtout(xtout[279])，.a(a[279])，.b(b[279])，.c(c[279])，.d(d[279])，.sel(sel))； xtmux4bi280(.xtout(xtout[280])，.a(a[280])，.b(b[280])，.c(c[280])，.d(d[280])，.sel(sel))； xtmux4bi281(.xtout(xtout[281])，.a(a[281])，.b(b[281])，.c(c[281])，.d(d[281])，.sel(sel))； xtmux4bi282(.xtout(xtout[282])，.a(a[282])，.b(b[282])，.c(c[282])，.d(d[282])，.sel(sel))； xtmux4bi283(.xtout(xtout[283])，.a(a[283])，.b(b[283])，.c(c[283])，.d(d[283])，.sel(sel))； xtmux4bi284(.xtout(xtout[284])，.a(a[284])，.b(b[284])，.c(c[284])，.d(d[284])，.sel(sel))； xtmux4bi285(.xtout(xtout[285])，.a(a[285])，.b(b[285])，.c(c[285])，.d(d[285])，.sel(sel))； xtmux4bi286(.xtout(xtout[286])，.a(a[286])，.b(b[286])，.c(c[286])，.d(d[286])，.sel(sel))； xtmux4bi287(.xtout(xtout[287])，.a(a[287])，.b(b[287])，.c(c[287])，.d(d[287])，.sel(sel))； xtmux4bi288(.xtout(xtout[288])，.a(a[288])，.b(b[288])，.c(c[288])，.d(d[288])，.sel(sel))； xtmux4bi289(.xtout(xtout[289])，.a(a[289])，.b(b[289])，.c(c[289])，.d(d[289])，.sel(sel))； xtmux4bi290(.xtout(xtout[290])，.a(a[290])，.b(b[290])，.c(c[290])，.d(d[290])，.sel(sel))； xtmux4bi291(.xtout(xtout[291])，.a(a[291])，.b(b[291])，.c(c[291])，.d(d[291])，.sel(sel))； xtmux4bi292(.xtout(xtout[292])，.a(a[292])，.b(b[292])，.c(c[292])，.d(d[292])，.sel(sel))； xtmux4bi293(.xtout(xtout[293])，.a(a[293])，.b(b[293])，.c(c[293])，.d(d[293])，.sel(sel))； xtmux4bi294(.xtout(xtout[294])，.a(a[294])，.b(b[294])，.c(c[294])，.d(d[294])，.sel(sel))； xtmux4bi295(.xtout(xtout[295])，.a(a[295])，.b(b[295])，.c(c[295])，.d(d[295])，.sel(sel))； xtmux4bi296(.xtout(xtout[296])，.a(a[296])，.b(b[296])，.c(c[296])，.d(d[296])，.sel(sel))；<dpn="d234"/> xtmux4bi297(.xtout(xtout[297])，.a(a[297])，.b(b[297])，.c(c[297])，.d(d[297])，.sel(sel))； xtmux4bi298(.xtout(xtout[298])，.a(a[298])，.b(b[298])，.c(c[298])，.d(d[298])，.sel(sel))； xtmux4bi299(.xtout(xtout[299])，.a(a[299])，.b(b[299])，.c(c[299])，.d(d[299])，.sel(sel))； xtmux4bi300(.xtout(xtout[300])，.a(a[300])，.b(b[300])，.c(c[300])，.d(d[300])，.sel(sel))； xtmux4bi301(.xtout(xtout[301])，.a(a[301])，.b(b[301])，.c(c[301])，.d(d[301])，.sel(sel))； xtmux4bi302(.xtout(xtout[302])，.a(a[302])，.b(b[302])，.c(c[302])，.d(d[302])，.sel(sel))； xtmux4bi303(.xtout(xtout[303])，.a(a[303])，.b(b[303])，.c(c[303])，.d(d[303])，.sel(sel))； xtmux4bi304(.xtout(xtout[304])，.a(a[304])，.b(b[304])，.c(c[304])，.d(d[304])，.sel(sel))； xtmux4bi305(.xtout(xtout[305])，.a(a[305])，.b(b[305])，.c(c[305])，.d(d[305])，.sel(sel))； xtmux4bi306(.xtout(xtout[306])，.a(a[306])，.b(b[306])，.c(c[306])，.d(d[306])，.sel(sel))； xtmux4bi307(.xtout(xtout[307])，.a(a[307])，.b(b[307])，.c(c[307])，.d(d[307])，.sel(sel))； xtmux4bi308(.xtout(xtout[308])，.a(a[308])，.b(b[308])，.c(c[308])，.d(d[308])，.sel(sel))； xtmux4bi309(.xtout(xtout[309])，.a(a[309])，.b(b[309])，.c(c[309])，.d(d[309])，.sel(sel))； xtmux4bi310(.xtout(xtout[310])，.a(a[310])，.b(b[310])，.c(c[310])，.d(d[310])，.sel(sel))； xtmux4bi311(.xtout(xtout[311])，.a(a[311])，.b(b[311])，.c(c[311])，.d(d[311])，.sel(sel))； xtmux4bi312(.xtout(xtout[312])，.a(a[312])，.b(b[312])，.c(c[312])，.d(d[312])，.sel(sel))； xtmux4bi313(.xtout(xtout[313])，.a(a[313])，.b(b[313])，.c(c[313])，.d(d[313])，.sel(sel))； xtmux4bi314(.xtout(xtout[314])，.a(a[314])，.b(b[314])，.c(c[314])，.d(d[314])，.sel(sel))； xtmux4bi315(.xtout(xtout[315])，.a(a[315])，.b(b[315])，.c(c[315])，.d(d[315])，.sel(sel))； xtmux4bi316(.xtout(xtout[316])，.a(a[316])，.b(b[316])，.c(c[316])，.d(d[316])，.sel(sel))； xtmux4bi317(.xtout(xtout[317])，.a(a[317])，.b(b[317])，.c(c[317])，.d(d[317])，.sel(sel))； xtmux4bi318(.xtout(xtout[318])，.a(a[318])，.b(b[318])，.c(c[318])，.d(d[318])，.sel(sel))； xtmux4bi319(.xtout(xtout[319])，.a(a[319])，.b(b[319])，.c(c[319])，.d(d[319])，.sel(sel))； xtmux4bi320(.xtout(xtout[320])，.a(a[320])，.b(b[320])，.c(c[320])，.d(d[320])，.sel(sel))； xtmux4bi321(.xtout(xtout[321])，.a(a[321])，.b(b[321])，.c(c[321])，.d(d[321])，.sel(sel))； xtmux4bi322(.xtout(xtout[322])，.a(a[322])，.b(b[322])，.c(c[322])，.d(d[322])，.sel(sel))； xtmux4bi323(.xtout(xtout[323])，.a(a[323])，.b(b[323])，.c(c[323])，.d(d[323])，.sel(sel))； xtmux4bi324(.xtout(xtout[324])，.a(a[324])，.b(b[324])，.c(c[324])，.d(d[324])，.sel(sel))； xtmux4bi325(.xtout(xtout[325])，.a(a[325])，.b(b[325])，.c(c[325])，.d(d[325])，.sel(sel))； xtmux4bi326(.xtout(xtout[326])，.a(a[326])，.b(b[326])，.c(c[326])，.d(d[326])，.sel(sel))；<dpn="d235"/> xtmux4bi327(.xtout(xtout[327])，.a(a[327])，.b(b[327])，.c(c[327])，.d(d[327])，.sel(sel))； xtmux4bi328(.xtout(xtout[328])，.a(a[328])，.b(b[328])，.c(c[328])，.d(d[328])，.sel(sel))； xtmux4bi329(.xtout(xtout[329])，.a(a[329])，.b(b[329])，.c(c[329])，.d(d[329])，.sel(sel))； xtmux4bi330(.xtout(xtout[330])，.a(a[330])，.b(b[330])，.c(c[330])，.d(d[330])，.sel(sel))； xtmux4bi331(.xtout(xtout[331])，.a(a[331])，.b(b[331])，.c(c[331])，.d(d[331])，.sel(sel))； xtmux4bi332(.xtout(xtout[332])，.a(a[332])，.b(b[332])，.c(c[332])，.d(d[332])，.sel(sel))； xtmux4bi333(.xtout(xtout[333])，.a(a[333])，.b(b[333])，.c(c[333])，.d(d[333])，.sel(sel))； xtmux4bi334(.xtout(xtout[334])，.a(a[334])，.b(b[334])，.c(c[334])，.d(d[334])，.sel(sel))； xtmux4bi335(.xtout(xtout[335])，.a(a[335])，.b(b[335])，.c(c[335])，.d(d[335])，.sel(sel))； xtmux4bi336(.xtout(xtout[336])，.a(a[336])，.b(b[336])，.c(c[336])，.d(d[336])，.sel(sel))； xtmux4bi337(.xtout(xtout[337])，.a(a[337])，.b(b[337])，.c(c[337])，.d(d[337])，.sel(sel))； xtmux4bi338(.xtout(xtout[338])，.a(a[338])，.b(b[338])，.c(c[338])，.d(d[338])，.sel(sel))； xtmux4bi339(.xtout(xtout[339])，.a(a[339])，.b(b[339])，.c(c[339])，.d(d[339])，.sel(sel))； xtmux4bi340(.xtout(xtout[340])，.a(a[340])，.b(b[340])，.c(c[340])，.d(d[340])，.sel(sel))； xtmux4bi341(.xtout(xtout[341])，.a(a[341])，.b(b[341])，.c(c[341])，.d(d[341])，.sel(sel))； xtmux4bi342(.xtout(xtout[342])，.a(a[342])，.b(b[342])，.c(c[342])，.d(d[342])，.sel(sel))； xtmux4bi343(.xtout(xtout[343])，.a(a[343])，.b(b[343])，.c(c[343])，.d(d[343])，.sel(sel))； xtmux4bi344(.xtout(xtout[344])，.a(a[344])，.b(b[344])，.c(c[344])，.d(d[344])，.sel(sel))； xtmux4bi345(.xtout(xtout[345])，.a(a[345])，.b(b[345])，.c(c[345])，.d(d[345])，.sel(sel))； xtmux4bi346(.xtout(xtout[346])，.a(a[346])，.b(b[346])，.c(c[346])，.d(d[346])，.sel(sel))； xtmux4bi347(.xtout(xtout[347])，.a(a[347])，.b(b[347])，.c(c[347])，.d(d[347])，.sel(sel))； xtmux4bi348(.xtout(xtout[348])，.a(a[348])，.b(b[348])，.c(c[348])，.d(d[348])，.sel(sel))； xtmux4bi349(.xtout(xtout[349])，.a(a[349])，.b(b[349])，.c(c[349])，.d(d[349])，.sel(sel))； xtmux4bi350(.xtout(xtout[350])，.a(a[350])，.b(b[350])，.c(c[350])，.d(d[350])，.sel(sel))； xtmux4bi351(.xtout(xtout[351])，.a(a[351])，.b(b[351])，.c(c[351])，.d(d[351])，.sel(sel))； xtmux4bi352(.xtout(xtout[352])，.a(a[352])，.b(b[352])，.c(c[352])，.d(d[352])，.sel(sel))； xtmux4bi353(.xtout(xtout[353])，.a(a[353])，.b(b[353])，.c(c[353])，.d(d[353])，.sel(sel))； xtmux4bi354(.xtout(xtout[354])，.a(a[354])，.b(b[354])，.c(c[354])，.d(d[354])，.sel(sel))； xtmux4bi355(.xtout(xtout[355])，.a(a[355])，.b(b[355])，.c(c[355])，.d(d[355])，.sel(sel))； xtmux4bi356(.xtout(xtout[356])，.a(a[356])，.b(b[356])，.c(c[356])，.d(d[356])，.sel(sel))；<dpn="d236"/> xtmux4bi357(.xtout(xtout[357])，.a(a[357])，.b(b[357])，.c(c[357])，.d(d[357])，.sel(sel))； xtmux4bi358(.xtout(xtout[358])，.a(a[358])，.b(b[358])，.c(c[358])，.d(d[358])，.sel(sel))； xtmux4bi359(.xtout(xtout[359])，.a(a[359])，.b(b[359])，.c(c[359])，.d(d[359])，.sel(sel))； xtmux4bi360(.xtout(xtout[360])，.a(a[360])，.b(b[360])，.c(c[360])，.d(d[360])，.sel(sel))； xtmux4bi361(.xtout(xtout[361])，.a(a[361])，.b(b[361])，.c(c[361])，.d(d[361])，.sel(sel))； xtmux4bi362(.xtout(xtout[362])，.a(a[362])，.b(b[362])，.c(c[362])，.d(d[362])，.sel(sel))； xtmux4bi363(.xtout(xtout[363])，.a(a[363])，.b(b[363])，.c(c[363])，.d(d[363])，.sel(sel))； xtmux4bi364(.xtout(xtout[364])，.a(a[364])，.b(b[364])，.c(c[364])，.d(d[364])，.sel(sel))； xtmux4bi365(.xtout(xtout[365])，.a(a[365])，.b(b[365])，.c(c[365])，.d(d[365])，.sel(sel))； xtmux4bi366(.xtout(xtout[366])，.a(a[366])，.b(b[366])，.c(c[366])，.d(d[366])，.sel(sel))； xtmux4bi367(.xtout(xtout[367])，.a(a[367])，.b(b[367])，.c(c[367])，.d(d[367])，.sel(sel))； xtmux4bi368(.xtout(xtout[368])，.a(a[368])，.b(b[368])，.c(c[368])，.d(d[368])，.sel(sel))； xtmux4bi369(.xtout(xtout[369])，.a(a[369])，.b(b[369])，.c(c[369])，.d(d[369])，.sel(sel))； xtmux4bi370(.xtout(xtout[370])，.a(a[370])，.b(b[370])，.c(c[370])，.d(d[370])，.sel(sel))； xtmux4bi371(.xtout(xtout[371])，.a(a[371])，.b(b[371])，.c(c[371])，.d(d[371])，.sel(sel))； xtmux4bi372(.xtout(xtout[372])，.a(a[372])，.b(b[372])，.c(c[372])，.d(d[372])，.sel(sel))； xtmux4bi373(.xtout(xtout[373])，.a(a[373])，.b(b[373])，.c(c[373])，.d(d[373])，.sel(sel))； xtmux4bi374(.xtout(xtout[374])，.a(a[374])，.b(b[374])，.c(c[374])，.d(d[374])，.sel(sel))； xtmux4bi375(.xtout(xtout[375])，.a(a[375])，.b(b[375])，.c(c[375])，.d(d[375])，.sel(sel))； xtmux4bi376(.xtout(xtout[376])，.a(a[376])，.b(b[376])，.c(c[376])，.d(d[376])，.sel(sel))； xtmux4bi377(.xtout(xtout[377])，.a(a[377])，.b(b[377])，.c(c[377])，.d(d[377])，.sel(sel))； xtmux4bi378(.xtout(xtout[378])，.a(a[378])，.b(b[378])，.c(c[378])，.d(d[378])，.sel(sel))； xtmux4bi379(.xtout(xtout[379])，.a(a[379])，.b(b[379])，.c(c[379])，.d(d[379])，.sel(sel))； xtmux4bi380(.xtout(xtout[380])，.a(a[380])，.b(b[380])，.c(c[380])，.d(d[380])，.sel(sel))； xtmux4bi381(.xtout(xtout[381])，.a(a[381])，.b(b[381])，.c(c[381])，.d(d[381])，.sel(sel))； xtmux4bi382(.xtout(xtout[382])，.a(a[382])，.b(b[382])，.c(c[382])，.d(d[382])，.sel(sel))； xtmux4bi383(.xtout(xtout[383])，.a(a[383])，.b(b[383])，.c(c[383])，.d(d[383])，.sel(sel))； xtmux4bi384(.xtout(xtout[384])，.a(a[384])，.b(b[384])，.c(c[384])，.d(d[384])，.sel(sel))； xtmux4bi385(.xtout(xtout[385])，.a(a[385])，.b(b[385])，.c(c[385])，.d(d[385])，.sel(sel))； xtmux4bi386(.xtout(xtout[386])，.a(a[386])，.b(b[386])，.c(c[386])，.d(d[386])，.sel(sel))；<dpn="d237"/> xtmux4bi387(.xtout(xtout[387])，.a(a[387])，.b(b[387])，.c(c[387])，.d(d[387])，.sel(sel))； xtmux4bi388(.xtout(xtout[388])，.a(a[388])，.b(b[388])，.c(c[388])，.d(d[388])，.sel(sel))； xtmux4bi389(.xtout(xtout[389])，.a(a[389])，.b(b[389])，.c(c[389])，.d(d[389])，.sel(sel))； xtmux4bi390(.xtout(xtout[390])，.a(a[390])，.b(b[390])，.c(c[390])，.d(d[390])，.sel(sel))； xtmux4bi391(.xtout(xtout[391])，.a(a[391])，.b(b[391])，.c(c[391])，.d(d[391])，.sel(sel))； xtmux4bi392(.xtout(xtout[392])，.a(a[392])，.b(b[392])，.c(c[392])，.d(d[392])，.sel(sel))； xtmux4bi393(.xtout(xtout[393])，.a(a[393])，.b(b[393])，.c(c[393])，.d(d[393])，.sel(sel))； xtmux4bi394(.xtout(xtout[394])，.a(a[394])，.b(b[394])，.c(c[394])，.d(d[394])，.sel(sel))； xtmux4bi395(.xtout(xtout[395])，.a(a[395])，.b(b[395])，.c(c[395])，.d(d[395])，.sel(sel))； xtmux4bi396(.xtout(xtout[396])，.a(a[396])，.b(b[396])，.c(c[396])，.d(d[396])，.sel(sel))； xtmux4bi397(.xtout(xtout[397])，.a(a[397])，.b(b[397])，.c(c[397])，.d(d[397])，.sel(sel))； xtmux4bi398(.xtout(xtout[398])，.a(a[398])，.b(b[398])，.c(c[398])，.d(d[398])，.sel(sel))； xtmux4bi399(.xtout(xtout[399])，.a(a[399])，.b(b[399])，.c(c[399])，.d(d[399])，sel(sel))； xtmux4bi400(.xtout(xtout[400])，.a(a[400])，.b(b[400])，.c(c[400])，.d(d[400])，.sel(sel))； xtmux4bi401(.xtout(xtout[401])，.a(a[401])，.b(b[401])，.c(c[401])，.d(d[401])，.sel(sel))； xtmux4bi402(.xtout(xtout[402])，.a(a[402])，.b(b[402])，.c(c[402])，.d(d[402])，.sel(sel))； xtmux4bi403(.xtout(xtout[403])，.a(a[403])，.b(b[403])，.c(c[403])，.d(d[403])，.sel(sel))； xtmux4bi404(.xtout(xtout[404])，.a(a[404])，.b(b[404])，.c(c[404])，.d(d[404])，.sel(sel))； xtmux4bi405(.xtout(xtout[405])，.a(a[405])，.b(b[405])，.c(c[405])，.d(d[405])，.sel(sel))； xtmux4bi406(.xtout(xtout[406])，.a(a[406])，.b(b[406])，.c(c[406])，.d(d[406])，.sel(sel))； xtmux4bi407(.xtout(xtout[407])，.a(a[407])，.b(b[407])，.c(c[407])，.d(d[407])，.sel(sel))； xtmux4bi408(.xtout(xtout[408])，.a(a[408])，.b(b[408])，.c(c[408])，.d(d[408])，.sel(sel))； xtmux4bi409(.xtout(xtout[409])，.a(a[409])，.b(b[409])，.c(c[409])，.d(d[409])，.sel(sel))； xtmux4bi410(.xtout(xtout[410])，.a(a[410])，.b(b[410])，.c(c[410])，.d(d[410])，.sel(sel))； xtmux4bi411(.xtout(xtout[411])，.a(a[411])，.b(b[411])，.c(c[411])，.d(d[411])，sel(sel))； xtmux4bi412(.xtout(xtout[412])，.a(a[412])，.b(b[412])，.c(c[412])，.d(d[412])，.sel(sel))； xtmux4bi413(.xtout(xtout[413])，.a(a[413])，.b(b[413])，.c(c[413])，.d(d[413])，.sel(sel))； xtmux4bi414(.xtout(xtout[414])，.a(a[414])，.b(b[414])，.c(c[414])，.d(d[414])，.sel(sel))； xtmux4bi415(.xtout(xtout[415])，.a(a[415])，.b(b[415])，.c(c[415])，.d(d[415])，.sel(sel))； xtmux4bi416(.xtout(xtout[416])，.a(a[416])，.b(b[416])，.c(c[416])，.d(d[416])，.sel(sel))；<dpn="d238"/> xtmux4bi417(.xtout(xtout[417])，.a(a[417])，.b(b[417])，.c(c[417])，.d(d[417])，.sel(sel))； xtmux4bi418(.xtout(xtout[418])，.a(a[418])，.b(b[418])，.c(c[418])，.d(d[418])，.sel(sel))； xtmux4bi419(.xtout(xtout[419])，.a(a[419])，.b(b[419])，.c(c[419])，.d(d[419])，.sel(sel))； xtmux4bi420(.xtout(xtout[420])，.a(a[420])，.b(b[420])，.c(c[420])，.d(d[420])，.sel(sel))； xtmux4bi421(.xtout(xtout[421])，.a(a[421])，.b(b[421])，.c(c[421])，.d(d[421])，.sel(sel))； xtmux4bi422(.xtout(xtout[422])，.a(a[422])，.b(b[422])，.c(c[422])，.d(d[422])，.sel(sel))； xtmux4bi423(.xtout(xtout[423])，.a(a[423])，.b(b[423])，.c(c[423])，.d(d[423])，.sel(sel))； xtmux4bi424(.xtout(xtout[424])，.a(a[424])，.b(b[424])，.c(c[424])，.d(d[424])，.sel(sel))； xtmux4bi425(.xtout(xtout[425])，.a(a[425])，.b(b[425])，.c(c[425])，.d(d[425])，.sel(sel))； xtmux4bi426(.xtout(xtout[426])，.a(a[426])，.b(b[426])，.c(c[426])，.d(d[426])，.sel(sel))； xtmux4bi427(.xtout(xtout[427])，.a(a[427])，.b(b[427])，.c(c[427])，.d(d[427])，.sel(sel))； xtmux4bi428(.xtout(xtout[428])，.a(a[428])，.b(b[428])，.c(c[428])，.d(d[428])，.sel(sel))； xtmux4bi429(.xtout(xtout[429])，.a(a[429])，.b(b[429])，.c(c[429])，.d(d[429])，.sel(sel))； xtmux4bi430(.xtout(xtout[430])，.a(a[430])，.b(b[430])，.c(c[430])，.d(d[430])，.sel(sel))； xtmux4bi431(.xtout(xtout[431])，.a(a[431])，.b(b[431])，.c(c[431])，.d(d[431])，.sel(sel))； xtmux4bi432(.xtout(xtout[432])，.a(a[432])，.b(b[432])，.c(c[432])，.d(d[432])，.sel(sel))； xtmux4bi433(.xtout(xtout[433])，.a(a[433])，.b(b[433])，.c(c[433])，.d(d[433])，.sel(sel))； xtmux4bi434(.xtout(xtout[434])，.a(a[434])，.b(b[434])，.c(c[434])，.d(d[434])，.sel(sel))； xtmux4bi435(.xtout(xtout[435])，.a(a[435])，.b(b[435])，.c(c[435])，.d(d[435])，.sel(sel))； xtmux4bi436(.xtout(xtout[436])，.a(a[436])，.b(b[436])，.c(c[436])，.d(d[436])，.sel(sel))； xtmux4bi437(.xtout(xtout[437])，.a(a[437])，.b(b[437])，.c(c[437])，.d(d[437])，.sel(sel))； xtmux4bi438(.xtout(xtout[438])，.a(a[438])，.b(b[438])，.c(c[438])，.d(d[438])，.sel(sel))； xtmux4bi439(.xtout(xtout[439])，.a(a[439])，.b(b[439])，.c(c[439])，.d(d[439])，.sel(sel))； xtmux4bi440(.xtout(xtout[440])，.a(a[440])，.b(b[440])，.c(c[440])，.d(d[440])，.sel(sel))； xtmux4bi441(.xtout(xtout[441])，.a(a[441])，.b(b[441])，.c(c[441])，.d(d[441])，.sel(sel))； xtmux4bi442(.xtout(xtout[442])，.a(a[442])，.b(b[442])，.c(c[442])，.d(d[442])，.sel(sel))； xtmux4bi443(.xtout(xtout[443])，.a(a[443])，.b(b[443])，.c(c[443])，.d(d[443])，.sel(sel))； xtmux4bi444(.xtout(xtout[444])，.a(a[444])，.b(b[444])，.c(c[444])，.d(d[444])，.sel(sel))； xtmux4bi445(.xtout(xtout[445])，.a(a[445])，.b(b[445])，.c(c[445])，.d(d[445])，.sel(sel))； xtmux4bi446(.xtout(xtout[446])，.a(a[446])，.b(b[446])，.c(c[446])，.d(d[446])，.sel(sel))；<dpn="d239"/> xtmux4bi447(.xtout(xtout[447])，.a(a[447])，.b(b[447])，.c(c[447])，.d(d[447])，.sel(sel))； xtmux4bi448(.xtout(xtout[448])，.a(a[448])，.b(b[448])，.c(c[448])，.d(d[448])，.sel(sel))； xtmux4bi449(.xtout(xtout[449])，.a(a[449])，.b(b[449])，.c(c[449])，.d(d[449])，.sel(sel))； xtmux4bi450(.xtout(xtout[450])，.a(a[450])，.b(b[450])，.c(c[450])，.d(d[450])，.sel(sel))； xtmux4bi451(.xtout(xtout[451])，.a(a[451])，.b(b[451])，.c(c[451])，.d(d[451])，.sel(sel))； xtmux4bi452(.xtout(xtout[452])，.a(a[452])，.b(b[452])，.c(c[452])，.d(d[452])，.sel(sel))； xtmux4bi453(.xtout(xtout[453])，.a(a[453])，.b(b[453])，.c(c[453])，.d(d[453])，.sel(sel))； xtmux4bi454(.xtout(xtout[454])，.a(a[454])，.b(b[454])，.c(c[454])，.d(d[454])，.sel(sel))； xtmux4bi455(.xtout(xtout[455])，.a(a[455])，.b(b[455])，.c(c[455])，.d(d[455])，.sel(sel))； xtmux4bi456(.xtout(xtout[456])，.a(a[456])，.b(b[456])，.c(c[456])，.d(d[456])，.sel(sel))； xtmux4bi457(.xtout(xtout[457])，.a(a[457])，.b(b[457])，.c(c[457])，.d(d[457])，.sel(sel))； xtmux4bi458(.xtout(xtout[458])，.a(a[458])，.b(b[458])，.c(c[458])，.d(d[458])，.sel(sel))； xtmux4bi459(.xtout(xtout[459])，.a(a[459])，.b(b[459])，.c(c[459])，.d(d[459])，.sel(sel))； xtmux4bi460(.xtout(xtout[460])，.a(a[460])，.b(b[460])，.c(c[460])，.d(d[460])，.sel(sel))； xtmux4bi461(.xtout(xtout[461])，.a(a[461])，.b(b[461])，.c(c[461])，.d(d[461])，.sel(sel))； xtmux4bi462(.xtout(xtout[462])，.a(a[462])，.b(b[462])，.c(c[462])，.d(d[462])，.sel(sel))； xtmux4bi463(.xtout(xtout[463])，.a(a[463])，.b(b[463])，.c(c[463])，.d(d[463])，.sel(sel))； xtmux4bi464(.xtout(xtout[464])，.a(a[464])，.b(b[464])，.c(c[464])，.d(d[464])，.sel(sel))； xtmux4bi465(.xtout(xtout[465])，.a(a[465])，.b(b[465])，.c(c[465])，.d(d[465])，.sel(sel))； xtmux4bi466(.xtout(xtout[466])，.a(a[466])，.b(b[466])，.c(c[466])，.d(d[466])，.sel(sel))； xtmux4bi467(.xtout(xtout[467])，.a(a[467])，.b(b[467])，.c(c[467])，.d(d[467])，.sel(sel))； xtmux4bi468(.xtout(xtout[468])，.a(a[468])，.b(b[468])，.c(c[468])，.d(d[468])，.sel(sel))； xtmux4bi469(.xtout(xtout[469])，.a(a[469])，.b(b[469])，.c(c[469])，.d(d[469])，.sel(sel))； xtmux4bi470(.xtout(xtout[470])，.a(a[470])，.b(b[470])，.c(c[470])，.d(d[470])，.sel(sel))； xtmux4bi471(.xtout(xtout[471])，.a(a[471])，.b(b[471])，.c(c[471])，.d(d[471])，.sel(sel))； xtmux4bi472(.xtout(xtout[472])，.a(a[472])，.b(b[472])，.c(c[472])，.d(d[472])，.sel(sel))； xtmux4bi473(.xtout(xtout[473])，.a(a[473])，.b(b[473])，.c(c[473])，.d[d[473])，.sel(sel))； xtmux4bi474(.xtout(xtout[474])，.a(a[474])，.b(b[474])，.c(c[474])，.d(d[474])，.sel(sel))； xtmux4bi475(.xtout(xtout[475])，.a(a[475])，.b(b[475])，.c(c[475])，.d(d[475])，.sel(sel))； xtmux4bi476(.xtout(xtout[476])，.a(a[476])，.b(b[476])，.c(c[476])，.d(d[476])，.sel(sel))；<dpn="d240"/> xtmux4bi477(.xtout(xtout[477])，.a(a[477])，.b(b[477])，.c(c[477])，.d(d[477])，.sel(sel))； xtmux4bi478(.xtout(xtout[478])，.a(a[478])，.b(b[478])，.c(c[478])，.d(d[478])，.sel(sel))； xtmux4bi479(.xtout(xtout[479])，.a(a[479])，.b(b[479])，.c(c[479])，.d(d[479])，.sel(sel))； xtmux4bi480(.xtout(xtout[480])，.a(a[480])，.b(b[480])，.c(c[480])，.d(d[480])，.sel(sel))； xtmux4bi481(.xtout(xtout[481])，.a(a[481])，.b(b[481])，.c(c[481])，.d(d[481])，.sel(sel))； xtmux4bi482(.xtout(xtout[482])，.a(a[482])，.b(b[482])，.c(c[482])，.d(d[482])，.sel(sel))； xtmux4bi483(.xtout(xtout[483])，.a(a[483])，.b(b[483])，.c(c[483])，.d(d[483])，.sel(sel))； xtmux4bi484(.xtout(xtout[484])，.a(a[484])，.b(b[484])，.c(c[484])，.d(d[484])，.sel(sel))； xtmux4bi485(.xtout(xtout[485])，.a(a[485])，.b(b[485])，.c(c[485])，.d(d[485])，.sel(sel))； xtmux4bi486(.xtout(xtout[486])，.a(a[486])，.b(b[486])，.c(c[486])，.d(d[486])，.sel(sel))； xtmux4bi487(.xtout(xtout[487])，.a(a[487])，.b(b[487])，.c(c[487])，.d(d[487])，.sel(sel))； xtmux4bi488(.xtout(xtout[488])，.a(a[488])，.b(b[488])，.c(c[488])，.d(d[488])，.sel(sel))； xtmux4bi489(.xtout(xtout[489])，.a(a[489])，.b(b[489])，.c(c[489])，.d(d[489])，.sel(sel))； xtmux4bi490(.xtout(xtout[490])，.a(a[490])，.b(b[490])，.c(c[490])，.d(d[490])，.sel(sel))； xtmux4bi491(.xtout(xtout[491])，.a(a[491])，.b(b[491])，.c(c[491])，.d(d[491])，.sel(sel))； xtmux4bi492(.xtout(xtout[492])，.a(a[492])，.b(b[492])，.c(c[492])，.d(d[492])，.sel(sel))； xtmux4bi493(.xtout(xtout[493])，.a(a[493])，.b(b[493])，.c(c[493])，.d(d[493])，.sel(sel))； xtmux4bi494(.xtout(xtout[494])，.a(a[494])，.b(b[494])，.c(c[494])，.d(d[494])，.sel(sel))； xtmux4bi495(.xtout(xtout[495])，.a(a[495])，.b(b[495])，.c(c[495])，.d(d[495])，.sel(sel))； xtmux4bi496(.xtout(xtout[496])，.a(a[496])，.b(b[496])，.c(c[496])，.d(d[496])，.sel(sel))； xtmux4bi497(.xtout(xtout[497])，.a(a[497])，.b(b[497])，.c(c[497])，.d(d[497])，.sel(sel))； xtmux4bi498(.xtout(xtout[498])，.a(a[498])，.b(b[498])，.c(c[498])，.d(d[498])，.sel(sel))； xtmux4bi499(.xtout(xtout[499])，.a(a[499])，.b(b[499])，.c(c[499])，.d(d[499])，.sel(sel))； xtmux4bi500(.xtout(xtout[500])，.a(a[500])，.b(b[500])，.c(c[500])，.d(d[500])，.sel(sel))； xtmux4bi501(.xtout(xtout[501])，.a(a[501])，.b(b[501])，.c(c[501])，.d(d[501])，.sel(sel))； xtmux4bi502(.xtout(xtout[502])，.a(a[502])，.b(b[502])，.c(c[502])，.d(d[502])，.sel(sel))； xtmux4bi503(.xtout(xtout[503])，.a(a[503])，.b(b[503])，.c(c[503])，.d(d[503])，.sel(sel))； xtmux4bi504(.xtout(xtout[504])，.a(a[504])，.b(b[504])，.c(c[504])，.d(d[504])，.sel(sel))； xtmux4bi505(.xtout(xtout[505])，.a(a[505])，.b(b[505])，.c(c[505])，.d(d[505])，.sel(sel))； xtmux4bi506(.xtout(xtout[506])，.a(a[506])，.b(b[506])，.c(c[506])，.d(d[506])，.sel(sel))；<dpn="d241"/> xtmux4bi507(.xtout(xtout[507])，.a(a[507])，.b(b[507])，.c(c[507])，.d(d[507])，.sel(sel))； xtmux4bi508(.xtout(xtout[508])，.a(a[508])，.b(b[508])，.c(c[508])，.d(d[508])，.sel(sel))； xtmux4bi509(.xtout(xtout[509])，.a(a[509])，.b(b[509])，.c(c[509])，.d(d[509])，.sel(sel))； xtmux4bi510(.xtout(xtout[510])，.a(a[510])，.b(b[510])，.c(c[510])，.d(d[510])，.sel(sel))； xtmux4bi511(.xtout(xtout[511])，.a(a[511])，.b(b[511])，.c(c[511])，.d(d[511])，.sel(sel))； xtmux4bi512(.xtout(xtout[512])，.a(a[512])，.b(b[512])，.c(c[512])，.d(d[512])，.sel(sel))； xtmux4bi513(.xtout(xtout[513])，.a(a[513])，.b(b[513])，.c(c[513])，.d(d[513])，.sel(sel))； xtmux4bi514(.xtout(xtout[514])，.a(a[514])，.b(b[514])，.c(c[514])，.d(d[514])，.sel(sel))； xtmux4bi515(.xtout(xtout[515])，.a(a[515])，.b(b[515])，.c(c[515])，.d(d[515])，.sel(sel))； xtmux4bi516(.xtout(xtout[516])，.a(a[516])，.b(b[516])，.c(c[516])，.d(d[516])，.sel(sel))； xtmux4bi517(.xtout(xtout[517])，.a(a[517])，.b(b[517])，.c(c[517])，.d(d[517])，.sel(sel))； xtmux4bi518(.xtout(xtout[518])，.a(a[518])，.b(b[518])，.c(c[518])，.d(d[518])，.sel(sel))； xtmux4bi519(.xtout(xtout[519])，.a(a[519])，.b(b[519])，.c(c[519])，.d(d[519])，.sel(sel))； xtmux4bi520(.xtout(xtout[520])，.a(a[520])，.b(b[520])，.c(c[520])，.d(d[520])，.sel(sel))； xtmux4bi521(.xtout(xtout[521])，.a(a[521])，.b(b[521])，.c(c[521])，.d(d[521])，.sel(sel))； xtmux4bi522(.xtout(xtout[522])，.a(a[522])，.b(b[522])，.c(c[522])，.d(d[522])，.sel(sel))； xtuux4bi523(.xtout(xtout[523])，.a(a[523])，.b(b[523])，.c(c[523])，.d(d[523])，.sel(sel))； xtmux4bi524(.xtout(xtout[524])，.a(a[524])，.b(b[524])，.c(c[524])，.d(d[524])，.sel(sel))； xtmux4bi525(.xtout(xtout[525])，.a(a[525])，.b(b[525])，.c(c[525])，.d(d[525])，.sel(sel))； xtmux4bi526(.xtout(xtout[526])，.a(a[526])，.b(b[526])，.c(c[526])，.d(d[526])，.sel(sel))； xtmux4bi527(.xtout(xtout[527])，.a(a[527])，.b(b[527])，.c(c[527])，.d(d[527])，.sel(sel))； xtmux4bi528(.xtout(xtout[528])，.a(a[528])，.b(b[528])，.c(c[528])，.d(d[528])，.sel(sel))； xtmux4bi529(.xtout(xtout[529])，.a(a[529])，.b(b[529])，.c(c[529])，.d(d[529])，.sel(sel))； xtmux4bi530(.xtout(xtout[530])，.a(a[530])，.b(b[530])，.c(c[530])，.d(d[530])，.sel(sel))； xtmux4bi531(.xtout(xtout[531])，.a(a[531])，.b(b[531])，.c(c[531])，.d(d[531])，.sel(sel))； xtmux4bi532(.xtout(xtout[532])，.a(a[532])，.b(b[532])，.c(c[532])，.d(d[532])，.sel(sel))； xtmux4bi533(.xtout(xtout[533])，.a(a[533])，.b(b[533])，.c(c[533])，.d(d[533])，.sel(sel))； xtmux4bi534(.xtout(xtout[534])，.a(a[534])，.b(b[534])，.c(c[534])，.d(d[534])，.sel(sel))； xtmux4bi535(.xtout(xtout[535])，.a(a[535])，.b(b[535])，.c(c[535])，.d(d[535])，.sel(sel))； xtmux4bi536(.xtout(xtout[536])，.a(a[536])，.b(b[536])，.c(c[536])，.d(d[536])，.sel(sel))；<dpn="d242"/> xtmux4bi537(.xtout(xtout[537])，.a(a[537])，.b(b[537])，.c(c[537])，.d(d[537])，.sel(sel))； xtmux4bi538(.xtout(xtout[538])，.a(a[538])，.b(b[538])，.c(c[538])，.d(d[538])，.sel(sel))； xtmux4bi539(.xtout(xtout[539])，.a(a[539])，.b(b[539])，.c(c[539])，.d(d[539])，.sel(sel))； xtmux4bi540(.xtout(xtout[540])，.a(a[540])，.b(b[540])，.c(c[540])，.d(d[540])，.sel(sel))； xtmux4bi541(.xtout(xtout[541])，.a(a[541])，.b(b[541])，.c(c[541])，.d(d[541])，.sel(sel))； xtmux4bi542(.xtout(xtout[542])，.a(a[542])，.b(b[542])，.c(c[542])，.d(d[542])，.sel(sel))； xtmux4bi543(.xtout(xtout[543])，.a(a[543])，.b(b[543])，.c(c[543])，.d(d[543])，.sel(sel))； xtmux4bi544(.xtout(xtout[544])，.a(a[544])，.b(b[544])，.c(c[544])，.d(d[544])，.sel(sel))； xtmux4bi545(.xtout(xtout[545])，.a(a[545])，.b(b[545])，.c(c[545])，.d(d[545])，.sel(sel))； xtmux4bi546(.xtout(xtout[546])，.a(a[546])，.b(b[546])，.c(c[546])，.d(d[546])，.sel(sel))； xtmux4bi547(.xtout(xtout[547])，.a(a[547])，.b(b[547])，.c(c[547])，.d(d[547])，.sel(sel))； xtmux4bi548(.xtout(xtout[548])，.a(a[548])，.b(b[548])，.c(c[548])，.d(d[548])，.sel(sel))； xtmux4bi549(.xtout(xtout[549])，.a(a[549])，.b(b[549])，.c(c[549])，.d(d[549])，.sel(sel))； xtmux4bi550(.xtout(xtout[550])，.a(a[550])，.b(b[550])，.c(c[550])，.d(d[550])，.sel(sel))； xtmux4bi551(.xtout(xtout[551])，.a(a[551])，.b(b[551])，.c(c[551])，.d(d[551])，.sel(sel))； xtmux4bi552(.xtout(xtout[552])，.a(a[552])，.b(b[552])，.c(c[552])，.d(d[552])，.sel(sel))； xtmux4bi553(.xtout(xtout[553])，.a(a[553])，.b(b[553])，.c(c[553])，.d(d[553])，.sel(sel))； xtmux4bi554(.xtout(xtout[554])，.a(a[554])，.b(b[554])，.c(c[554])，.d(d[554])，.sel(sel))； xtmux4bi555(.xtout(xtout[555])，.a(a[555])，.b(b[555])，.c(c[555])，.d(d[555])，.sel(sel))； xtmux4bi556(.xtout(xtout[556])，.a(a[556])，.b(b[556])，.c(c[556])，.d(d[556])，.sel(sel))； xtmux4bi557(.xtout(xtout[557])，.a(a[557])，.b(b[557])，.c(c[557])，.d(d[557])，.sel(sel))； xtmux4bi558(.xtout(xtout[558])，.a(a[558])，.b(b[558])，.c(c[558])，.d(d[558])，.sel(sel))； xtmux4bi559(.xtout(xtout[559])，.a(a[559])，.b(b[559])，.c(c[559])，.d(d[559])，.sel(sel))； xtmux4bi560(.xtout(xtout[560])，.a(a[560])，.b(b[560])，.c(c[560])，.d(d[560])，.sel(sel))； xtmux4bi561(.xtout(xtout[561])，.a(a[561])，.b(b[561])，.c(c[561])，.d(d[561])，.sel(sel))； xtmux4bi562(.xtout(xtout[562])，.a(a[562])，.b(b[562])，.c(c[562])，.d(d[562])，.sel(sel))； xtmux4bi563(.xtout(xtout[563])，.a(a[563])，.b(b[563])，.c(c[563])，.d(d[563])，.sel(sel))； xtmux4bi564(.xtout(xtout[564])，.a(a[564])，.b(b[564])，.c(c[564])，.d(d[564])，.sel(sel))； xtmux4bi565(.xtout(xtout[565])，.a(a[565])，.b(b[565])，.c(c[565])，.d(d[565])，.sel(sel))； xtmux4bi566(.xtout(xtout[566])，.a(a[566])，.b(b[566])，.c(c[566])，.d(d[566])，.sel(sel))；<dpn="d243"/> xtmux4bi567(.xtout(xtout[567])，.a(a[567])，.b(b[567])，.c(c[567])，.d(d[567])，.sel(sel))； xtmttx4bi568(.xtout(xtout[568])，.a(a[568])，.b(b[568])，.c(c[568])，.d(d[568])，.sel(sel))； xtmux4bi569(.xtout(xtout[569])，.a(a[569])，.b(b[569])，.c(c[569])，.d(d[569])，.sel(sel))； xtmux4bi570(.xtout(xtout[570])，.a(a[570])，.b(b[570])，.c(c[570])，.d(d[570])，.sel(sel))； xtmux4bi571(.xtout(xtout[571])，.a(a[571])，.b(b[571])，.c(c[571])，.d(d[571])，.sel(sel))； xtmux4bi572(.xtout(xtout[572])，.a(a[572])，.b(b[572])，.c(c[572])，.d(d[572])，.sel(sel))； xtmux4bi573(.xtout(xtout[573])，.a(a[573])，.b(b[573])，.c(c[573])，.d(d[573])，.sel(sel))； xtmux4bi574(.xtout(xtout[574])，.a(a[574])，.b(b[574])，.c(c[574])，.d(d[574])，.sel(sel))； xtmux4bi575(.xtout(xtout[575])，.a(a[575])，.b(b[575])，.c(c[575])，.d(d[575])，.sel(sel))； xtmux4bi576(.xtout(xtout[576])，.a(a[576])，.b(b[576])，.c(c[576])，.d(d[576]]，.sel(sel))； xtmux4bi577(.xtout(xtout[577])，.a(a[577])，.b(b[577])，.c(c[577])，.d(d[577])，.sel(sel))； xtmux4bi578(.xtout(xtout[578])，.a(a[578])，.b(b[578])，.c(c[578])，.d(d[578])，.sel(sel))； xtmux4bi579(.xtout(xtout[579])，.a(a[579])，.b(b[579])，.c(c[579])，.d(d[579])，.sel(sel))； xtmux4bi580(.xtout(xtout[580])，.a(a[580])，.b(b[580])，.c(c[580])，.d(d[580]]，.sel(sel))； xtmux4bi581(.xtout(xtout[581])，.a(a[581])，.b(b[581])，.c(c[581])，.d(d[581])，.sel(sel))； xtmux4bi582(.xtout(xtout[582])，.a(a[582])，.b(b[582])，.c(c[582])，.d(d[582])，.sel(sel))； xtmux4bi583(.xtout(xtout[583])，.a(a[583])，.b(b[583])，.c(c[583])，.d(d[583])，.sel(sel))； xtmux4bi584(.xtout(xtout[584])，.a(a[584])，.b(b[584])，.c(c[584])，.d(d[584])，.sel(sel))； xtmux4bi585(.xtout(xtout[585])，.a(a[585])，.b(b[585])，.c(c[585])，.d(d[585])，.sel(sel))； xtmux4bi586(.xtout(xtout[586])，.a(a[586])，.b(b[586])，.c(c[586])，.d(d[586])，.sel(8el))； xtmux4bi587(.xtout(xtout[587])，.a(a[587])，.b(b[587])，.c(c[587])，.d(d[587])，.sel(sel))； xtmux4bi588(.xtout(xtout[588])，.a(a[588])，.b(b[588])，.c(c[588])，.d(d[588])，.sel(sel))； xtmux4bi589(.xtout(xtout[589])，.a(a[589])，.b(b[589])，.c(c[589])，.d(d[589])，.sel(sel))； xtmtx4bi590(.xtout(xtout[590])，.a(a[590])，.b(b[590])，.c(c[590])，.d(d[590])，.sel(sel))； xtmux4bi591(.xtout(xtout[591])，.a(a[591])，.b(b[591])，.c(c[591])，.d(d[591])，.sel(sel))； xtmux4bi592(.xtout(xtout[592])，.a(a[592])，.b(b[592])，.c(c[592])，.d(d[592])，.sel(sel))； xtmux4bi593(.xtout(xtout[593])，.a(a[593])，.b(b[593])，.c(c[593])，.d(d[593])，.sel(sel))； xtmux4bi594(.xtout(xtout[594])，.a(a[594])，.b(b[594])，.c(c[594])，.d(d[594])，.sel(sel))； xtmux4bi595(.xtout(xtout[595])，.a(a[595])，.b(b[595])，.c(c[595])，.d(d[595])，.sel(sel))； xtmux4bi596(.xtout(xtout[596])，.a(a[596])，.b(b[596])，.c(c[596])，.d(d[596])，.sel(sel))；<dpn="d244"/> xtmux4bi597(.xtout(xtout[597])，.a(a[597])，.b(b[597])，.c(c[597])，.d(d[597])，.sel(sel))； xtmux4bi598(.xtout(xtout[598])，.a(a[598])，.b(b[598])，.c(c[598])，.d(d[598])，.sel(sel))； xtmux4bi599(.xtout(xtout[599])，.a(a[599])，.b(b[599])，.c(c[599])，.d(d[599])，.sel(sel))； xtmux4bi600(.xtout(xtout[600])，.a(a[600])，.b(b[600])，.c(c[600])，.d(d[600])，.sel(sel))； xtmux4bi601(.xtout(xtout[601])，.a(a[601])，.b(b[601])，.c(c[601])，.d(d[601])，.sel(sel))； xtmux4bi602(.xtout(xtout[602])，.a(a[602])，.b(b[602])，.c(c[602])，.d(d[602])，.sel(sel))； xtmux4bi603(.xtout(xtout[603])，.a(a[603])，.b(b[603])，.c(c[603])，.d(d[603])，.sel(sel))； xtmux4bi604(.xtout(xtout[604])，.a(a[604])，.b(b[604])，.c(c[604])，.d(d[604])，.sel(sel))； xtmux4bi605(.xtout(xtout[605])，.a(a[605])，.b(b[605])，.c(c[605])，.d(d[605])，.sel(sel))； xtmux4bi606(.xtout(xtout[606])，.a(a[606])，.b(b[606])，.c(c[606])，.d(d[606])，.sel(sel))； xtmux4bi607(.xtout(xtout[607])，.a(a[607])，.b(b[607])，.c(c[607])，.d(d[607])，.sel(sel))； xtmux4bi608(.xtout(xtout[608])，.a(a[608])，.b(b[608])，.c(c[608])，.d(d[608])，.sel(sel))； xtmux4bi609(.xtout(xtout[609])，.a(a[609])，.b(b[609])，.c(c[609])，.d(d[609])，.sel(sel))； xtmux4bi610(.xtout(xtout[610])，.a(a[610])，.b(b[610])，.c(c[610])，.d(d[610])，.sel(sel))； xtmux4bi611(.xtout(xtout[611])，.a(a[611])，.b(b[611])，.c(c[611])，.d(d[611])，.sel(sel))； xtmux4bi612(.xtout(xtout[612])，.a(a[612])，.b(b[612])，.c(c[612])，.d(d[612])，.sel(sel))； xtmux4bi613(.xtout(xtout[613])，.a(a[613])，.b(b[613])，.c(c[613])，.d(d[613])，.sel(sel))； xtmux4bi614(.xtout(xtout[614])，.a(a[614])，.b(b[614])，.c(c[614])，.d(d[614])，.sel(sel))； xtmux4bi615(.xtout(xtout[615])，.a(a[615])，.b(b[615])，.c(c[615])，.d(d[615])，.sel(sel))； xtmux4bi616(.xtout(xtout[616])，.a(a[616])，.b(b[616])，.c(c[616])，.d(d[616])，.sel(sel))； xtmux4bi617(.xtout(xtout[617])，.a(a[617])，.b(b[617])，.c(c[617])，.d(d[617])，.sel(sel))； xtmux4bi618(.xtout(xtout[618])，.a(a[618])，.b(b[618])，.c(c[618])，.d(d[618])，.sel(sel))； xtmux4bi619(.xtout(xtout[619])，.a(a[619])，.b(b[619])，.c(c[619])，.d(d[619])，.sel(sel))； xtmux4bi620(.xtout(xtout[620])，.a(a[620])，.b(b[620])，.c(c[620])，.d(d[620])，.sel(sel))； xtmux4bi621(.xtout(xtout[621])，.a(a[621])，.b(b[621])，.c(c[621])，.d(d[621])，.sel(sel))； xtmux4bi622(.xtout(xtout[622])，.a(a[622])，.b(b[622])，.c(c[622])，.d(d[622])，.sel(sel))； xtmux4bi623(.xtout(xtout[623])，.a(a[623])，.b(b[623])，.c(c[623])，.d(d[623])，.sel(sel))； xtmux4bi624(.xtout(xtout[624])，.a(a[624])，.b(b[624])，.c(c[624])，.d(d[624])，.sel(sel))； xtmux4bi625(.xtout(xtout[625])，.a(a[625])，.b(b[625])，.c(c[625])，.d(d[625])，.sel(sel))； xtmux4bi626(.xtout(xtout[626])，.a(a[626])，.b(b[626])，.c(c[626])，.d(d[626])，.sel(sel))；<dpn="d245"/> xtmux4bi627(.xtout(xtout[627])，.a(a[627])，.b(b[627])，.c(c[627])，.d(d[627])，.sel(sel))； xtmux4bi628(.xtout(xtout[628])，.a(a[628])，.b(b[628])，.c(c[628])，.d(d[628])，.sel(sel))； xtmux4bi629(.xtout(xtout[629])，.a(a[629])，.b(b[629])，.c(c[629])，.d(d[629])，.sel(sel))； xtmux4bi630(.xtout(xtout[630])，.a(a[630])，.b(b[630])，.c(c[630])，.d(d[630])，.sel(sel))； xtmux4bi631(.xtout(xtout[631])，.a(a[631])，.b(b[631])，.c(c[631])，.d(d[631])，.sel(sel))； xtmux4bi632(.xtout(xtout[632])，.a(a[632])，.b(b[632])，.c(c[632])，.d(d[632])，.sel(sel))； xtmux4bi633(.xtot(xtout[633])，.a(a[633])，.b(b[633])，.c(c[633])，.d(d[633])，.sel(sel))； xtmux4bi634(.xtout(xtout[634])，.a(a[634])，.b(b[634])，.c(c[634])，.d(d[634])，.sel(sel))； xtmux4bi635(.xtout(xtout[635])，.a(a[635])，.b(b[635])，.c(c[635])，.d(d[635])，.sel(sel))； xtmux4bi636(.xtout(xtout[636])，.a(a[636])，.b(b[636])，.c(c[636])，.d(d[636])，.sel(sel))； xtmux4bi637(.xtout(xtout[637])，.a(a[637])，.b(b[637])，.c(c[637])，.d(d[637])，.sel(sel))； xtmux4bi638(.xtout(xtout[638])，.a(a[638])，.b(b[638])，.c(c[638])，.d(d[638])，.sel(sel))； xtmux4bi639(.xtout(xtout[639])，.a(a[639])，.b(b[639])，.c(c[639])，.d(d[639])，.sel(sel))； xtmux4bi640(.xtout(xtout[640])，.a(a[640])，.b(b[640])，.c(c[640])，.d(d[640])，.sel(sel))； xtmux4bi641(.xtout(xtout[641])，.a(a[641])，.b(b[641])，.c(c[641])，.d(d[641])，.sel(sel))； xtmux4bi642(.xtout(xtout[642])，.a(a[642])，.b(b[642])，.c(c[642])，.d(d[642])，.sel(sel))； xtmux4bi643(.xtout(xtout[643])，.a(a[643])，.b(b[643])，.c(c[643])，.d(d[643])，.sel(sel))； xtmux4bi644(.xtout(xtout[644])，.a(a[644])，.b(b[644])，.c(c[644])，.d(d[644])，.sel(sel))； xtmux4bi645(.xtout(xtout[645])，.a(a[645])，.b(b[645])，.c(c[645])，.d(d[645])，.sel(sel))； xtmux4bi646(.xtout(xtout[646])，.a(a[646])，.b(b[646])，.c(c[646])，.d(d[646])，.sel(sel))； xtmux4bi647(.xtout(xtout[647])，.a(a[647])，.b(b[647])，.c(c[647])，.d(d[647])，.sel(sel))； xtmux4bi648(.xtout(xtout[648])，.a(a[648])，.b(b[648])，.c(c[648])，.d(d[648])，.sel(sel))； xtmux4bi649(.xtout(xtout[649])，.a(a[649])，.b(b[649])，.c(c[649])，.d(d[649])，.sel(sel))； xtmux4bi650(.xtout(xtout[650])，.a(a[650])，.b(b[650])，.c(c[650])，.d(d[650])，.sel(sel))； xtmux4bi651(.xtout(xtout[651])，.a(a[651])，.b(b[651])，.c(c[651])，.d(d[651])，.sel(sel))； xtmux4bi652(.xtout(xtout[652])，.a(a[652])，.b(b[652])，.c[c[652])，.d(d[652])，.sel(sel))； xtmux4bi653(.xtout(xtout[653])，.a(a[653])，.b(b[653])，.c(c[653])，.d(d[653])，.sel(sel))； xtmux4bi654(.xtout(xtout[654])，.a(a[654])，.b(b[654])，.c(c[654])，.d(d[654])，.sel(sel))； xtmux4bi655(.xtout(xtout[655])，.a(a[655])，.b(b[655])，.c(c[655])，.d(d[655])，.sel(sel))； xtmux4bi656(.xtout(xtout[656])，.a(a[656])，.b(b[656])，.c(c[656])，.d(d[656])，.sel(sel))；<dpn="d246"/> xtmux4bi657(.xtout(xtout[657])，.a(a[657])，.b(b[657])，.c(c[657])，.d(d[657])，.sel(sel))； xtmux4bi658(.xtout(xtout[658])，.a(a[658])，.b(b[658])，.c(c[658])，.d(d[658])，.sel(sel))； xtmnx4bi659(.xtout(xtout[659])，.a(a[659])，.b(b[659])，.c(c[659])，.d(d[659])，.sel(sel))； xtmux4bi660(.xtout(xtout[660])，.a(a[660])，.b(b[660])，.c(c[660])，.d(d[660])，.sel(sel))； xtmux4bi661(.xtout(xtout[661])，.a(a[66l])，.b(b[661])，.c(c[661])，.d(d[661])，.sel(sel))； xtmux4bi662(.xtout(xtout[662])，.a(a[662])，.b(b[662])，.c(c[662])，.d(d[662])，.sel(sel))； xtmux4bi663(.xtout(xtout[663])，.a(a[663])，.b(b[663])，.c(c[663])，.d(d[663])，.sel(sel))； xtmux4bi664(.xtout(xtout[664])，.a(a[664])，.b(b[664])，.c(c[664])，.d(d[664])，.sel(sel))； xtmux4bi665(.xtout(xtout[665])，.a(a[665])，.b(b[665])，.c(c[665])，.d(d[665])，.sel(sel))； xtmux4bi666(.xtout(xtot[666])，.a(a[666])，.b(b[666])，.c(c[666])，.d(d[666])，.sel(sel))； xtmux4bi667(.xtout(xtout[667])，.a(a[667])，.b(b[667])，.c(c[667])，.d(d[667])，.sel(sel))； xtmux4bi668(.xtout(xtout[668])，.a(a[668])，.b(b[668])，.c(c[668])，.d(d[668])，.sel(sel))； xtmux4bi669(.xtout(xtout[669])，.a(a[669])，.b(b[669])，.c(c[669])，.d(d[669])，.sel(sel))； xtmux4bi670(.xtout(xtout[670])，.a(a[670])，.b(b[670])，.c(c[670])，.d(d[670])，.sel(sel))； xtmux4bi671(.xtout(xtout[671])，.a(a[671])，.b(b[671])，.c(c[671])，.d(d[671])，.sel(sel))； xtmux4bi672(.xtout(xtout[672])，.a(a[672])，.b(b[672])，.c(c[672])，.d(d[672])，.sel(sel))； xtmux4bi673(.xtout(xtout[673])，.a(a[673])，.b(b[673])，.c(c[673])，.d(d[673])，.sel(sel))； xtmux4bi674(.xtout(xtout[674])，.a(a[674])，.b(b[674])，.c(c[674])，.d(d[674])，.sel(sel))； xtmux4bi675(.xtout(xtout[675])，.a(a[675])，.b(b[675])，.c(c[675])，.d(d[675])，.sel(sel))； xtmux4bi676(.xtout(xtout[676])，.a(a[676])，.b(b[676])，.c(c[676])，.d(d[676])，.sel(sel))； xtmux4bi677(.xtout(xtout[677])，.a(a[677])，.b(b[677])，.c(c[677])，.d(d[677])，.sel(sel))； xtmux4bi678(.xtout(xtout[678])，.a(a[678])，.b(b[678])，.c(c[678])，.d(d[678])，.sel(sel))； xtmux4bi679(.xtout(xtout[679])，.a(a[679])，.b(b[679])，.c(c[679])，.d(d[679])，.sel(sel))； xtmux4bi680(.xtout(xtout[680])，.a(a[680])，.b(b[680])，.c(c[680])，.d(d[680])，.sel(sel))； xtmux4bi681(.xtout(xtout[681])，.a(a[681])，.b(b[681])，.c(c[681])，.d(d[681])，.sel(sel))； xtmux4bi682(.xtout(xtout[682])，.a(a[682])，.b(b[682])，.c(c[682])，.d(d[682])，.sel(sel))； xtmux4bi683(.xtout(xtout[683])，.a(a[683])，.b(b[683])，.c(c[683])，.d(d[683])，.sel(sel))； xtmux4bi684(.xtout(xtout[684])，.a(a[684])，.b(b[684])，.c(c[684])，.d(d[684])，.sel(sel))； xtmux4bi685(.xtout(xtout[685])，.a(a[685])，.b(b[685])，.c(c[685])，.d(d[685])，.sel(sel))； xtmux4bi686(.xtout(xtout[686])，.a(a[686])，.b(b[686])，.c(c[686])，.d(d[686])，.sel(sel))；<dpn="d247"/> xtmux4bi687(.xtout(xtout[687])，.a(a[687])，.b(b[687])，.c(c[687])，.d(d[687])，.sel(sel))； xtmux4bi688(.xtout(xtout[688])，.a(a[688])，.b(b[688])，.c(c[688])，.d(d[688])，.sel(sel))； xtmux4bi689(.xtout(xtout[689])，.a(a[689])，.b(b[689])，.c(c[689])，.d(d[689])，.sel(sel))； xtmux4bi690(.xtout(xtout[690])，.a(a[690])，.b(b[690])，.c(c[690])，.d(d[690])，.sel(sel))； xtmux4bi691(.xtout(xtout[691])，.a(a[691])，.b(b[691])，.c(c[691])，.d(d[691])，.sel(sel))； xtmux4bi692(.xtout(xtout[692])，.a(a[692])，.b(b[692])，.c(c[692])，.d(d[692])，.sel(sel))； xtmux4bi693(.xtout(xtout[693])，.a(a[693])，.b(b[693])，.c(c[693])，.d(d[693])，.sel(sel))； xtmux4bi694(.xtout(xtout[694])，.a(a[694])，.b(b[694])，.c(c[694])，.d(d[694])，.sel(sel))； xtmux4bi695(.xtout(xtout[695])，.a(a[695])，.b(b[695])，.c(c[695])，.d(d[695])，.sel(sel))； xtmux4bi696(.xtout(xtout[696])，.a(a[696])，.b(b[696])，.c(c[696])，.d(d[696])，.sel(sel))； xtmux4bi697(.xtout(xtout[697])，.a(a[697])，.b(b[697])，.c(c[697])，.d(d[697])，.sel(sel))； xtmux4bi698(.xtout(xtout[698])，.a(a[698])，.b(b[698])，.c(c[698])，.d(d[698])，.sel(sel))； xtmux4bi699(.xtout(xtout[699])，.a(a[699])，.b(b[699])，.c(c[699])，.d(d[699])，.sel(sel))； xtmux4bi700(.xtout(xtout[700])，.a(a[700])，.b(b[700])，.c(c[700])，.d(d[700])，.sel(sel))； xtmux4bi701(.xtout(xtout[701])，.a(a[701])，.b(b[701])，.c(c[701])，.d(d[701])，.sel(sel))； xtmux4bi702(.xtout(xtout[702])，.a(a[702])，.b(b[702])，.c(c[702])，.d(d[702])，.sel(sel))； xtmux4bi703(.xtout(xtout[703])，.a(a[703])，.b(b[703])，.c(c[703])，.d(d[703])，.sel(sel))； xtmux4bi704(.xtout(xtout[704])，.a(a[704])，.b(b[704])，.c(c[704])，.d(d[704])，.sel(sel))； xtmux4bi705(.xtout(xtout[705])，.a(a[705])，.b(b[705])，.c(c[705])，.d(d[705])，.sel(sel))； xtmux4bi706(.xtout(xtout[706])，.a(a[706])，.b(b[706])，.c(c[706])，.d(d[706])，.sel(sel))； xtmux4bi707(.xtout(xtout[707])，.a(a[707])，.b(b[707])，.c(c[707])，.d(d[707])，.sel(sel))； xtmux4bi708(.xtout(xtout[708])，.a(a[708])，.b(b[708])，.c(c[708])，.d(d[708])，.sel(sel))； xtmux4bi709(.xtout(xtout[709])，.a(a[709])，.b(b[709])，.c(c[709])，.d(d[709])，.sel(sel))； xtmux4bi710(.xtout(xtout[710])，.a(a[710])，.b(b[710])，.c(c[710])，.d(d[710])，.sel(sel))； xtmux4bi711(.xtout(xtout[711])，.a(a[711])，.b(b[711])，.c(c[711])，.d(d[711])，.sel(sel))； xtmux4bi712(.xtout(xtout[712])，.a(a[712])，.b(b[712])，.c(c[712])，.d(d[712])，.sel(sel))； xtmux4bi713(.xtout(xtout[713])，.a(a[713])，.b(b[713])，.c(c[713])，.d(d[713])，.sel(sel))； xtmux4bi714(.xtout(xtout[714])，.a(a[714])，.b(b[714])，.c(c[714])，.d(d[714])，.sel(sel))； xtmux4bi715(.xtout(xtout[715])，.a(a[715])，.b(b[715])，.c(c[715])，.d(d[715])，.sel(sel))； xtmux4bi716(.xtout(xtout[716])，.a(a[716])，.b(b[716])，.c(c[716])，.d(d[716])，.sel(sel))；<dpn="d248"/> xtmux4bi717(.xtout(xtout[717])，.a(a[717])，.b(b[717])，.c(c[717])，.d(d[717])，.sel(sel))； xtmux4bi718(.xtout(xtout[718])，.a(a[718])，.b(b[718])，.c(c[718])，.d(d[718])，.sel(sel))； xtmux4bi719(.xtout(xtout[719])，.a(a[719])，.b(b[719])，.c(c[719])，.d(d[719])，.sel(sel))； xtmux4bi720(.xtout(xtout[720])，.a(a[720])，.b(b[720])，.c(c[720])，.d(d[720])，.sel(sel))； xtmux4bi721(.xtout(xtout[721])，.a(a[721])，.b(b[721])，.c(c[721])，.d(d[721])，.sel(sel))； xtmux4bi722(.xtout(xtout[722])，.a(a[722])，.b(b[722])，.c(c[722])，.d(d[722])，.sel(sel))； xtmux4bi723(.xtout(xtout[723])，.a(a[723])，.b(b[723])，.c(c[723])，.d(d[723])，.sel(sel))； xtmux4bi724(.xtout(xtout[724])，.a(a[724])，.b(b[724])，.c(c[724]).d(d[724])，.sel(sel))； xtmux4bi725(.xtout(xtout[725])，.a(a[725])，.b(b[725])，.c(c[725])，.d(d[725])，.sel(sel))； xtmux4bi726(.xtout(xtout[726])，.a(a[726])，.b(b[726])，.c(c[726])，.d(d[726])，.sel(sel))； xtmux4bi727(.xtout(xtout[727])，.a(a[727])，.b(b[727])，.c(c[727])，.d(d[727])，.sel(sel))； xtmux4bi728(.xtout(xtout[728])，.a(a[728])，.b(b[728])，.c(c[728])，.d(d[728])，.sel(sel))； xtmux4bi729(.xtout(xtout[729])，.a(a[729])，.b(b[729])，.c(c[729])，.d(d[729])，.sel(sel))； xtmux4bi730(.xtout(xtout[730])，.a(a[730])，.b(b[730])，.c(c[730])，.d(d[730])，.sel(sel))； xtmux4bi731(.xtout(xtout[731])，.a(a[731])，.b(b[731])，.c(c[731])，.d(d[731])，.sel(sel))； xtmux4bi732(.xtout(xtout[732])，.a(a[732])，.b(b[732])，.c(c[732])，.d(d[732])，.sel(sel))； xtmux4bi733(.xtout(xtout[733])，.a(a[733])，.b(b[733])，.c(c[733])，.d(d[733])，.sel(sel))； xtmux4bi734(.xtout(xtout[734])，.a(a[734])，.b(b[734])，.c(c[734])，.d(d[734])，.sel(sel))； xtmux4bi735(.xtout(xtout[735])，.a(a[735])，.b(b[735])，.c(c[735])，.d(d[735])，.sel(sel))； xtmux4bi736(.xtout(xtout[736])，.a(a[736])，.b(b[736])，.c(c[736])，.d(d[736])，.sel(sel))； xtmux4bi737(.xtout(xtout[737])，.a(a[737])，.b(b[737])，.c(c[737])，.d(d[737])，.sel(sel))； xtmux4bi738(.xtout(xtout[738])，.a(a[738])，.b(b[738])，.c(c[738])，.d(d[738])，.sel(sel))； xtmux4bi739(.xtout(xtout[739])，.a(a[739])，.b(b[739])，.c(c[739])，.d(d[739])，.sel(sel))； xtmux4bi740(.xtout(xtout[740])，.a(a[740])，.b(b[740])，.c(c[740])，.d(d[740])，.sel(sel))； xtmux4bi741(.xtout(xtout[741])，.a(a[741])，.b(b[741])，.c(c[741])，.d(d[741])，.sel(sel))； xtmux4bi742(.xtout(xtout[742])，.a(a[742])，.b(b[742])，.c(c[742])，.d(d[742])，.sel(sel))； xtmux4bi743(.xtout(xtout[743])，.a(a[743])，.b(b[743])，.c(c[743])，.d(d[743])，.sel(sel))； xtmux4bi744(.xtout(xtout[744])，.a(a[744])，.b(b[744])，.c(c[744])，.d(d[744])，.sel(sel))； xtmux4bi745(.xtout(xtout[745])，.a(a[745])，.b(b[745])，.c(c[745])，.d(d[745])，.sel(sel))； xtmux4bi746(.xtout(xtout[746])，.a(a[746])，.b(b[746])，.c(c[746])，.d(d[746])，.sel(sel))；<dpn="d249"/> xtmux4bi747(.xtout(xtout[747])，.a(a[747])，.b(b[747])，.c(c[747])，.d(d[747])，.sel(sel))； xtmux4bi748(.xtout(xtout[748])，.a(a[748])，.b(b[748])，.c(c[748])，.d(d[748])，.sel(sel))； xtmux4bi749(.xtout(xtout[749])，.a(a[749])，.b(b[749])，.c(c[749])，.d(d[749])，.sel(sel))； xtmux4bi750(.xtout(xtout[750])，.a(a[750])，.b(b[750])，.c(c[750])，.d(d[750])，.sel(sel))； xtmux4bi751(.xtout(xtout[751])，.a(a[751])，.b(b[751])，.c(c[751])，.d(d[751])，.sel(sel))； xtmux4bi752(.xtout(xtout[752])，.a(a[752])，.b(b[752])，.c(c[752])，.d(d[752])，.sel(sel))； xtmux4bi753(.xtout(xtout[753])，.a(a[753])，.b(b[753])，.c(c[753])，.d(d[753])，.sel(sel))； xtmux4bi754(.xtout(xtout[754])，.a(a[754])，.b(b[754])，.c(c[754])，.d(d[754])，.sel(sel))； xtmux4bi755(.xtout(xtout[755])，.a(a[755])，.b(b[755])，.c(c[755])，.d(d[755])，.sel(sel))； xtmux4bi756(.xtout(xtout[756])，.a(a[756])，.b(b[756])，.c(c[756])，.d(d[756])，.sel(sel))； xtmux4bi757(.xtout(xtout[757])，.a(a[757])，.b(b[757])，.c(c[757])，.d(d[757])，.sel(sel))； xtmux4bi758(.xtout(xtout[758])，.a(a[758])，.b(b[758])，.c(c[758])，.d(d[758])，.sel(sel))； xtmux4bi759(.xtout(xtout[759])，.a(a[759])，.b(b[759])，.c(c[759])，.d(d[759])，.sel(sel))； xtmux4bi760(.xtout(xtout[760])，.a(a[760])，.b(b[760])，.c(c[760])，.d(d[760])，.sel(sel))； xtmux4bi761(.xtout(xtout[761])，.a(a[761])，.b(b[761])，.c(c[761])，.d(d[761])，.sel(sel))； xtmux4bi762(.xtout(xtout[762])，.a(a[762])，.b(b[762])，.c(c[762])，.d(d[762])，.sel(sel))； xtmux4bi763(.xtout(xtout[763])，.a(a[763])，.b(b[763])，.c(c[763])，.d(d[763])，.sel(sel))； xtmux4bi764(.xtout(xtout[764])，.a(a[764])，.b(b[764])，.c(c[764])，.d(d[764])，.sel(sel))； xtmux4bi765(.xtout(xtout[765])，.a(a[765])，.b(b[765])，.c(c[765])，.d(d[765])，.sel(sel))； xtmux4bi766(.xtout(xtout[766])，.a(a[766])，.b(b[766])，.c(c[766])，.d(d[766])，.sel(sel))； xtmux4bi767(.xtout(xtout[767])，.a(a[767])，.b(b[767])，.c(c[767])，.d(d[767])，.sel(sel))； xtmux4bi768(.xtout(xtout[768])，.a(a[768])，.b(b[768])，.c(c[768])，.d(d[768])，.sel(sel))； xtmux4bi769(.xtout(xtout[769])，.a(a[769])，.b(b[769])，.c(c[769])，.d(d[769])，.sel(sel))； xtmux4bi770(.xtout(xtout[770])，.a(a[770])，.b(b[770])，.c(c[770])，.d(d[770])，.sel(sel))； xtmux4bi771(.xtout(xtout[771])，.a(a[771])，.b(b[771])，.c(c[771])，.d(d[771])，.sel(sel))； xtmux4bi772(.xtout(xtout[772])，.a(a[772])，.b(b[772])，.c(c[772])，.d(d[772])，.sel(sel))； xtmux4bi773(.xtout(xtout[773])，.a(a[773])，.b(b[773])，.c(c[773])，.d(d[773])，.sel(sel))； xtmux4bi774(.xtout(xtout[774])，.a(a[774])，.b(b[774])，.c(c[774])，.d(d[774])，.sel(sel))； xtmux4bi775(.xtout(xtout[775])，.a(a[775])，.b(b[775])，.c(c[775])，.d(d[775])，.sel(sel))； xtmux4bi776(.xtout(xtout[776])，.a(a[776])，.b(b[776])，.c(c[776])，.d(d[776])，.sel(sel))；<dpn="d250"/> xtmux4bi777(.xtout(xtout[777])，.a(a[777])，.b(b[777])，.c(c[777])，.d(d[777])，.sel(sel))； xtmux4bi778(.xtout(xtout[778])，.a(a[778])，.b(b[778])，.c(c[778])，.d(d[778])，.sel(sel))； xtmux4bi779(.xtout(xtout[779])，.a(a[779])，.b(b[779])，.c(c[779])，.d(d[779])，.sel(sel))； xtmux4bi780(.xtout(xtout[780])，.a(a[780])，.b(b[780])，.c(c[780])，.d(d[780])，.sel(sel))； xtmux4bi781(.xtout(xtout[781])，.a(a[781])，.b(b[781])，.c(c[781])，.d(d[781])，.sel(sel))； xtmux4bi782(.xtout(xtout[782])，.a(a[782])，.b(b[782])，.c(c[782])，.d(d[782])，.sel(sel))； xtmux4bi783(.xtout(xtout[783])，.a(a[783])，.b(b[783])，.c(c[783])，.d(d[783])，.sel(sel))； xtmux4bi784(.xtout(xtout[784])，.a(a[784])，.b(b[784])，.c(c[784])，.d(d[784])，.sel(sel))； xtmux4bi785(.xtout(xtout[785])，.a(a[785])，.b(b[785])，.c(c[785])，.d(d[785])，.sel(sel))； xtmux4bi786(.xtout(xtout[786])，.a(a[786])，.b(b[786])，.c(c[786])，.d(d[786])，.sel(sel))； xtmux4bi787(.xtout(xtout[787])，.a(a[787])，.b(b[787])，.c(c[787])，.d(d[787])，.sel(sel))； xtmux4bi788(.xtout(xtout[788])，.a(a[788])，.b(b[788])，.c(c[788])，.d(d[788])，.sel(sel))； xtmux4bi789(.xtout(xtout[789])，.a(a[789])，.b(b[789])，.c(c[789])，.d(d[789])，.sel(sel))； xtmux4bi790(.xtout(xtout[790])，.a(a[790])，.b(b[790])，.c(c[790])，.d(d[790])，.sel(sel))； xtmux4bi791(.xtout(xtout[791])，.a(a[791])，.b(b[791])，.c(c[791])，.d(d[791])，.sel(sel))； xtmux4bi792(.xtout(xtout[792])，.a(a[792])，.b(b[792])，.c(c[792])，.d(d[792])，.sel(sel))； xtmux4bi793(.xtout(xtout[793])，.a(a[793])，.b(b[793])，.c(c[793])，.d(d[793])，.sel(sel))； xtmux4bi794(.xtout(xtout[794])，.a(a[794])，.b(b[794])，.c(c[794])，.d(d[794])，.sel(sel))； xtmux4bi795(.xtout(xtout[795])，.a(a[795])，.b(b[795])，.c(c[795])，.d(d[795])，.sel(sel))； xtmux4bi796(.xtout(xtout[796])，.a(a[796])，.b(b[796])，.c(c[796])，.d(d[796])，.sel(sel))； xtmux4bi797(.xtout(xtout[797])，.a(a[797])，.b(b[797])，.c(c[797])，.d(d[797])，.sel(sel))； xtmux4bi798(.xtout(xtout[798])，.a(a[798])，.b(b[798])，.c(c[798])，.d(d[798])，.sel(sel))； xtmux4bi799(.xtout(xtout[799])，.a(a[799])，.b(b[799])，.c(c[799])，.d(d[799])，.sel(sel))； xtmux4bi800(.xtout(xtout[800])，.a(a[800])，.b(b[800])，.c(c[800])，.d(d[800])，.sel(sel))； xtmux4bi801(.xtout(xtout[801])，.a(a[801])，.b(b[801])，.c(c[801])，.d(d[801])，.sel(sel))； xtmux4bi802(.xtout(xtout[802])，.a(a[802])，.b(b[802])，.c(c[802])，.d(d[802])，.sel(sel))； xtmux4bi803(.xtout(xtout[803])，.a(a[803])，.b(b[803])，.c(c[803])，.d(d[803])，.sel(sel))； xtmux4bi804(.xtout(xtout[804])，.a(a[804])，.b(b[804])，.c(c[804])，.d(d[804])，.sel(sel))； xtmux4bi805(.xtout(xtout[805])，.a(a[805])，.b(b[805])，.c(c[805])，.d(d[805])，.sel(sel))； xtmux4bi806(.xtout(xtout[806])，.a(a[806])，.b(b[806])，.c(c[806])，.d(d[806])，.sel(sel))；<dpn="d251"/> xtmux4bi807(.xtout(xtout[807])，.a(a[807])，.b(b[807])，.c(c[807])，.d(d[807])，.sel(sel))； xtmux4bi808(.xtout(xtout[808])，.a(a[808])，.b(b[808])，.c(c[808])，.d(d[808])，.sel(sel))； xtmux4bi809(.xtout(xtout[809])，.a(a[809])，.b(b[809])，.c(c[809])，.d(d[809])，.sel(sel))； xtmux4bi810(.xtout(xtout[810])，.a(a[810])，.b(b[810])，.c(c[810])，.d(d[810])，.sel(sel))； xtmux4bi811(.xtout(xtout[811])，.a(a[811])，.b(b[811])，.c(c[811])，.d(d[811])，.sel(sel))； xtmux4bi812(.xtout(xtout[812])，.a(a[812])，.b(b[812])，.c(c[812])，.d(d[812])，.sel(sel))； xtmux4bi813(.xtout(xtout[813])，.a(a[813])，.b(b[813])，.c(c[813])，.d(d[813])，.sel(sel))； xtmux4bi814(.xtout(xtout[814])，.a(a[814])，.b(b[814])，.c(c[814])，.d(d[814])，.sel(sel))； xtmux4bi815(.xtout(xtout[815])，.a(a[815])，.b(b[815])，.c(c[815])，.d(d[815])，.sel(sel))； xtmux4bi816(.xtout(xtout[816])，.a(a[816])，.b(b[816])，.c(c[816])，.d(d[816])，.sel(sel))； xtmux4bi817(.xtout(xtout[817])，.a(a[817])，.b(b[817])，.c(c[817])，.d(d[817])，.sel(sel))； xtmux4bi818(.xtout(xtout[818])，.a(a[818])，.b(b[818])，.c(c[818])，.d(d[818])，.sel(sel))； xtmux4bi819(.xtout(xtout[819])，.a(a[819])，.b(b[819])，.c(c[819])，.d(d[819])，.sel(sel))； xtmux4bi820(.xtout(xtout[820])，.a(a[820])，.b(b[820])，.c(c[820])，.d(d[820])，.sel(sel))； xtmux4bi821(.xtout(xtout[821])，.a(a[821])，.b(b[821])，.c(c[821])，.d(d[821])，.sel(sel))； xtmux4bi822(.xtout(xtout[822])，.a(a[822])，.b(b[822])，.c(c[822])，.d(d[822])，.sel(sel))； xtmux4bi823(.xtout(xtout[823])，.a(a[823])，.b(b[823])，.c(c[823])，.d(d[823])，.sel(sel))； xtmux4bi824(.xtout(xtout[824])，.a(a[824])，.b(b[824])，.c(c[824])，.d(d[824])，.sel(sel))； xtmux4bi825(.xtout(xtout[825])，.a(a[825])，.b(b[825])，.c(c[825])，.d(d[825])，.sel(sel))； xtmux4bi826(.xtout(xtout[826])，.a(a[826])，.b(b[826])，.c(c[826])，.d(d[826])，.sel(sel))； xtmux4bi827(.xtout(xtout[827])，.a(a[827])，.b(b[827])，.c(c[827])，.d(d[827])，.sel(sel))； xtmux4bi828(.xtout(xtout[828])，.a(a[828])，.b(b[828])，.c(c[828])，.d(d[828])，.sel(sel))； xtmux4bi829(.xtout(xtout[829])，.a(a[829])，.b(b[829])，.c(c[829])，.d(d[829])，.sel(sel))； xtmux4bi830(.xtout(xtout[830])，.a(a[830])，.b(b[830])，.c(c[830])，.d(d[830])，.sel(sel))； xtmux4bi831(.xtout(xtout[831])，.a(a[831])，.b(b[831])，.c(c[831])，.d(d[831])，.sel(sel))； xtmux4bi832(.xtout(xtout[832])，.a(a[832])，.b(b[832])，.c(c[832])，.d(d[832])，.sel(sel))； xtmux4bi833(.xtout(xtout[833])，.a(a[833])，.b(b[833])，.c(c[833])，.d(d[833])，.sel(sel))； xtmux4bi834(.xtout(xtout[834])，.a(a[834])，.b(b[834])，.c(c[834])，.d(d[834])，.sel(sel))； xtmux4bi835(.xtout(xtout[835])，.a(a[835])，.b(b[835])，.c(c[835])，.d(d[835])，.sel(sel))； xtmux4bi836(.xtout(xtout[836])，.a(a[836])，.b(b[836])，.c(c[836])，.d(d[836])，.sel(sel))；<dpn="d252"/> xtmux4bi867(.xtout(xtout[867])，.a(a[867])，.b(b[867])，.c(c[867])，.d(d[867])，.sel(sel))； xtmux4bi868(.xtout(xtout[868])，.a(a[868])，.b(b[868])，.c(c[868])，.d(d[868])，.sel(sel))； xtmux4bi869(.xtout(xtout[869])，.a(a[869])，.b(b[869])，.c(c[869])，.d(d[869])，.sel(sel))； xtmudx4bi870(.xtout(xtout[870])，.a(a[870])，.b(b[870])，.c(c[870])，.d(d[870])，.sel(sel))； xtmux4bi871(.xtout(xtout[871])，.a(a[871])，.b(b[871])，.c(c[871])，.d(d[871])，.sel(sel))； xtmux4bi872(.xtout(xtout[872])，.a(a[872])，.b(b[872])，.c(c[872])，.d(d[872])，.sel(sel))； xtmux4bi873(.xtout(xtout[873])，.a(a[873])，.b(b[873])，.c(c[873])，.d(d[873])，.sel(sel))； xtmux4bi874(.xtout(xtout[874])，.a(a[874])，.b(b[874])，.c(c[874])，.d(d[874])，.sel(sel))； xtmux4bi875(.xtout(xtout[875])，.a(a[875])，.b(b[875])，.c(c[875])，.d(d[875])，.sel(sel))； xtmux4bi876(.xtout(xtout[876])，.a(a[876])，.b(b[876])，.c(c[876])，.d(d[876])，.sel(sel))； xtmux4bi877(.xtout(xtout[877])，.a(a[877])，.b(b[877])，.c(c[877])，.d(d[877])，.sel(sel))； xtmux4bi878(.xtout(xtout[878])，.a(a[878])，.b(b[878])，.c(c[878])，.d(d[878])，.sel(sel))； xtmux4bi879(.xtout(xtout[879])，.a(a[879])，.b(b[879])，.c(c[879])，.d(d[879])，.sel(sel))； xtmux4bi880(.xtout(xtout[880])，.a(a[880])，.b(b[880])，.c(c[880])，.d(d[880])，.sel(sel))； xtmux4bi881(.xtout(xtout[881])，.a(a[881])，.b(b[881])，.c(c[881])，.d(d[881])，.sel(sel))； xtmux4bi882(.xtout(xtout[882])，.a(a[882])，.b(b[882])，.c(c[882])，.d(d[882])，.sel(sel))； xtmux4bi883(.xtout(xtout[883])，.a(a[883])，.b(b[883])，.c(c[883])，.d(d[883])，.sel(sel))； xtmux4bi884(.xtout(xtout[884])，.a(a[884])，.b(b[884])，.c(c[884])，.d(d[884])，.sel(sel))； xtmux4bi885(.xtout(xtout[885])，.a(a[885])，.b(b[885])，.c(c[885])，.d(d[885])，.sel(sel))； xtmux4bi886(.xtout(xtout[886])，.a(a[886])，.b(b[886])，.c(c[886])，.d(d[886])，.sel(sel))； xtmux4bi887(.xtout(xtout[887])，.a(a[887])，.b(b[887])，.c(c[887])，.d(d[887])，.sel(sel))； xtmux4bi888(.xtout(xtout[888])，.a(a[888])，.b(b[888])，.c(c[888])，.d(d[888])，.sel(sel))； xtmux4bi889(.xtout(xtout[889])，.a(a[889])，.b(b[889])，.c(c[889])，.d(d[889])，.sel(sel))； xtmux4bi890(.xtout(xtout[890])，.a(a[890])，.b(b[890])，.c(c[890])，.d(d[890])，.sel(sel))； xtmux4bi891(.xtout(xtout[891])，.a(a[891])，.b(b[891])，.c(c[891])，.d(d[891])，.sel(sel))； xtmux4bi892(.xtout(xtout[892])，.a(a[892])，.b(b[892])，.c(c[892])，.d(d[892])，.sel(sel))； xtmux4bi893(.xtout(xtout[893])，.a(a[893])，.b(b[893])，.c(c[893])，.d(d[893])，.sel(sel))； xtmux4bi894(.xtout(xtout[894])，.a(a[894])，.b(b[894])，.c(c[894])，.d(d[894])，.sel(sel))； xtmux4bi895(.xtout(xtout[895])，.a(a[895])，.b(b[895])，.c(c[895])，.d(d[895])，.sel(sel))； xtmux4bi896(.xtout(xtout[896])，.a(a[896])，.b(b[896])，.c(c[896])，.d(d[896])，.sel(sel))；<dpn="d253"/> xtmux4bi837(.xtout(xtout[837])，.a(a[837])，.b(b[837])，.c(c[837])，.d(d[837])，.sel(sel))； xtmux4bi838(.xtout(xtout[838])，.a(a[838])，.b(b[838])，.c(c[838])，.d(d[838])，.sel(sel))； xtmux4bi839(.xtout(xtout[839])，.a(a[839])，.b(b[839])，.c(c[839])，.d(d[839])，.sel(sel))； xtmux4bi840(.xtout(xtout[840])，.a(a[840])，.b(b[840])，.c(c[840])，.d(d[840])，.sel(sel))； xtmux4bi841(.xtout(xtout[841])，.a(a[841])，.b(b[841])，.c(c[841])，.d(d[841])，.sel(sel))； xtmux4bi842(.xtout(xtout[842])，.a(a[842])，.b(b[842])，.c(c[842])，.d(d[842])，.sel(sel))； xtmux4bi843(.xtout(xtout[843])，.a(a[843])，.b(b[843])，.c(c[843])，.d(d[843])，.sel(sel))； xtmux4bi844(.xtout(xtout[844])，.a(a[844])，.b(b[844])，.c(c[844])，.d(d[844])，.sel(sel))； xtmux4bi845(.xtout(xtout[845])，.a(a[845])，.b(b[845])，.c(c[845])，.d(d[845])，.sel(sel))； xtmux4bi846(.xtout(xtout[846])，.a(a[846])，.b(b[846])，.c(c[846])，.d(d[846])，.sel(sel))； xtmux4bi847(.xtout(xtout[847])，.a(a[847])，.b(b[847])，.c(c[847])，.d(d[847])，.sel(sel))； xtmux4bi848(.xtout(xtout[848])，.a(a[848])，.b(b[848])，.c(c[848])，.d(d[848])，.sel(sel))； xtmux4bi849(.xtout(xtout[849])，.a(a[849])，.b(b[849])，.c(c[849])，.d(d[849])，.sel(sel))； xtmux4bi850(.xtout(xtout[850])，.a(a[850])，.b(b[850])，.c(c[850])，.d(d[850])，.sel(sel))； xtmux4bi851(.xtout(xtout[851])，.a(a[851])，.b(b[851])，.c(c[851])，.d(d[851])，.sel(sel))； xtmux4bi852(.xtout(xtout[852])，.a(a[852])，.b(b[852])，.c(c[852])，.d(d[852])，.sel(sel))； xtmux4bi853(.xtout(xtout[853])，.a(a[853])，.b(b[853])，.c(c[853])，.d(d[853])，.sel(sel))； xtmux4bi854(.xtout(xtout[854])，.a(a[854])，.b(b[854])，.c(c[854])，.d(d[854])，.sel(sel))； xtmux4bi855(.xtout(xtout[855])，.a(a[855])，.b(b[855])，.c(c[855])，.d(d[855])，.sel(sel))； xtmux4bi856(.xtout(xtout[856])，.a(a[856])，.b(b[856])，.c(c[856])，.d(d[856])，.sel(sel))； xtmux4bi857(.xtout(xtout[857])，.a(a[857])，.b(b[857])，.c(c[857])，.d(d[857])，.sel(sel))； xtmux4bi858(.xtout(xtout[858])，.a(a[858])，.b(b[858])，.c(c[858])，.d(d[858])，.sel(sel))； xtmux4bi859(.xtout(xtout[859])，.a(a[859])，.b(b[859])，.c(c[859])，.d(d[859])，.sel(sel))； xtmux4bi860(.xtout(xtout[860])，.a(a[860])，.b(b[860])，.c(c[860])，.d(d[860])，.sel(sel))； xtmux4bi861(.xtout(xtout[861])，.a(a[861])，.b(b[861])，.c(c[861])，.d(d[861])，.sel(sel))； xtmux4bi862(.xtout(xtout[862])，.a(a[862])，.b(b[862])，.c(c[862])，.d(d[862])，.sel(sel))； xtmux4bi863(.xtout(xtout[863])，.a(a[863])，.b(b[863])，.c(c[863])，.d(d[863])，.sel(sel))； xtmux4bi864(.xtout(xtout[864])，.a(a[864])，.b(b[864])，.c(c[864])，.d(d[864])，.sel(sel))； xtmux4bi865(.xtout(xtout[865])，.a(a[865])，.b(b[865])，.c(c[865])，.d(d[865])，.sel(sel))； xtmux4bi866(.xtout(xtout[866])，.a(a[866])，.b(b[866])，.c(c[866])，.d(d[866])，.sel(sel))；<dpn="d254"/> xtmux4bi897(.xtot(xtout[897])，.a(a[897])，.b(b[897])，.c(c[897])，.d(d[897])，.sel(sel))； xtmux4bi898(.xtout(xtout[898])，.a(a[898])，.b(b[898])，.c(c[898])，.d(d[898])，.sel(sel))； xtmux4bi899(.xtout(xtout[899])，.a(a[899])，.b(b[899])，.c(c[899])，.d(d[899])，.sel(sel))； xtmux4bi900(.xtout(xtout[900])，.a(a[900])，.b(b[900])，.c(c[900])，.d(d[900])，.sel(sel))； xtmux4bi901(.xtout(xtout[901])，.a(a[901])，.b(b[901])，.c(c[901])，.d(d[901])，.sel(sel))； xtmux4bi902(.xtout(xtout[902])，.a(a[902])，.b(b[902])，.c(c[902])，.d(d[902])，.sel(sel))； xtmux4bi903(.xtout(xtout[903])，.a(a[903])，.b(b[903])，.c(c[903])，.d(d[903])，.sel(sel))； xtmux4bi904(.xtout(xtout[904])，.a(a[904])，.b(b[904])，.c(c[904])，.d(d[904])，.sel(sel))； xtmux4bi905(.xtout(xtout[905])，.a(a[905])，.b(b[905])，.c(c[905])，.d(d[905])，.sel(sel))； xtmux4bi906(.xtout(xtout[906])，.a(a[906])，.b(b[906])，.c(c[906])，.d(d[906])，.sel(sel))； xtmux4bi907(.xtout(xtout[907])，.a(a[907])，.b(b[907])，.c(c[907])，.d(d[907])，.sel(sel))； xtmux4bi908(.xtout(xtout[908])，.a(a[908])，.b(b[908])，.c(c[908])，.d(d[908])，.sel(sel))； xtmux4bi909(.xtout(xtout[909])，.a(a[909])，.b(b[909])，.c(c[909])，.d(d[909])，.sel(sel))； xtmux4bi910(.xtout(xtout[910])，.a(a[910])，.b(b[910])，.c(c[910])，.d(d[910])，.sel(sel))； xtmux4bi911(.xtout(xtout[911])，.a(a[911])，.b(b[911])，.c(c[911])，.d(d[911])，.sel(sel))； xtmux4bi912(.xtout(xtout[912])，.a(a[912])，.b(b[912])，.c(c[912])，.d(d[912])，.sel(sel))； xtmux4bi913(.xtout(xtout[913])，.a(a[913])，.b(b[913])，.c(c[913])，.d(d[913])，.sel(sel))； xtmux4bi914(.xtout(xtout[914])，.a(a[914])，.b(b[914])，.c(c[914])，.d(d[914])，.sel(sel))； xtmux4bi915(.xtout(xtout[915])，.a(a[915])，.b(b[915])，.c(c[915])，.d(d[915])，.sel(sel))； xtmux4bi916(.xtout(xtout[916])，.a(a[916])，.b(b[916])，.c(c[916])，.d(d[916])，.sel(sel))； xtmux4bi917(.xtout(xtout[917])，.a(a[917])，.b(b[917])，.c(c[917])，.d(d[917])，.sel(sel))； xtmux4bi918(.xtout(xtout[918])，.a(a[918])，.b(b[918])，.c(c[918])，.d(d[918])，.sel(sel))； xtmux4bi919(.xtout(xtout[919])，.a(a[919])，.b(b[919])，.c(c[919])，.d(d[919])，.sel(sel))； xtmux4bi920(.xtout(xtout[920])，.a(a[920])，.b(b[920])，.c(c[920])，.d(d[920])，.sel(sel))； xtmux4bi92l(.xtout(xtout[921])，.a(a[921])，.b(b[921])，.c(c[921])，.d(d[921])，.sel(sel))； xtmux4bi922(.xtout(xtout[922])，.a(a[922])，.b(b[922])，.c(c[922])，.d(d[922])，.sel(sel))； xtmux4bi923(.xtout(xtout[923])，.a(a[923])，.b(b[923])，.c(c[923])，.d(d[923])，.sel(sel))； xtmux4bi924(.xtout(xtout[924])，.a(a[924])，.b(b[924])，.c(c[924])，.d(d[924])，.sel(sel))； xtmux4bi925(.xtout(xtout[925])，.a(a[925])，.b(b[925])，.c(c[925])，.d(d[925])，.sel(sel))； xtmux4bi926(.xtout(xtout[926])，.a(a[926])，.b(b[926])，.c(c[926])，.d(d[926])，.sel(sel))；<dpn="d255"/> xtmux4bi927(.xtout(xtout[927])，.a(a[927])，.b(b[927])，.c(c[927])，.d(d[927])，.sel(sel))； xtmux4bi928(.xtout(xtout[928])，.a(a[928])，.b(b[928])，.c(c[928])，.d(d[928])，.sel(sel))； xtmux4bi929(.xtout(xtout[929])，.a(a[929])，.b(b[929])，.c(c[929])，.d(d[929])，.sel(sel))； xtmux4bi930(.xtout(xtout[930])，.a(a[930])，.b(b[930])，.c(c[930])，.d(d[930])，.sel(sel))； xtmux4bi931(.xtot(xtout[931])，.a(a[931])，.b(b[931])，.c(c[931])，.d(d[931])，.sel(sel))； xtmux4bi932(.xtout(xtout[932])，.a(a[932])，.b(b[932])，.c(c[932])，.d(d[932])，.sel(sel))； xtmux4bi933(.xtout(xtout[933])，.a(a[933])，.b(b[933])，.c(c[933])，.d(d[933])，.sel(sel))； xtmux4bi934(.xtout(xtout[934])，.a(a[934])，.b(b[934])，.c(c[934])，.d(d[934])，.sel(sel))； xtmux4bi935(.xtout(xtout[935])，.a(a[935])，.b(b[935])，.c(c[935])，.d(d[935])，.sel(sel))； xtmux4bi936(.xtout(xtout[936])，.a(a[936])，.b(b[936])，.c(c[936])，.d(d[936])，.sel(sel))； xtmux4bi937(.xtout(xtout[937])，.a(a[937])，.b(b[937])，.c(c[937])，.d(d[937])，.sel(sel))； xtmux4bi938(.xtout(xtout[938])，.a(a[938])，.b(b[938])，.c(c[938])，.d(d[938])，.sel(sel))； xtmux4bi939(.xtout(xtout[939])，.a(a[939])，.b(b[939])，.c(c[939])，.d(d[939])，.sel(sel))； xtmux4bi940(.xtout(xtout[940])，.a(a[940])，.b(b[940])，.c(c[940])，.d(d[940])，.sel(sel))； xtmux4bi941(.xtot(xtout[941])，.a(a[941])，.b(b[941])，.c(c[941])，.d(d[941])，.sel(sel))； xtmux4bi942(.xtout(xtout[942])，.a(a[942])，.b(b[942])，.c(c[942])，.d(d[942])，.sel(sel))； xtmux4bi943(.xtout(xtout[943])，.a(a[943])，.b(b[943])，.c(c[943])，.d(d[943])，.sel(sel))； xtmux4bi944(.xtout(xtout[944])，.a(a[944])，.b(b[944])，.c(c[944])，.d(d[944])，.sel(sel))； xtmux4bi945(.xtout(xtout[945])，.a(a[945])，.b(b[945])，.c(c[945])，.d(d[945])，.sel(sel])； xtmux4bi946(.xtout(xtout[946])，.a(a[946])，.b(b[946])，.c(c[946])，.d(d[946])，.sel(sel))； xtmux4bi947(.xtout(xtout[947])，.a(a[947])，.b(b[947])，.c(c[947])，.d(d[947])，.sel(sel))； xtmux4bi948(.xtout(xtout[948])，.a(a[948])，.b(b[948])，.c(c[948])，.d(d[948])，.sel(sel))； xtmux4bi949(.xtout(xtout[949])，.a(a[949])，.b(b[949])，.c(c[949])，.d(d[949])，.sel(sel))； xtmux4bi950(.xtout(xtout[950])，.a(a[950])，.b(b[950])，.c(c[950])，.d(d[950])，.sel(sel))； xtmux4bi951(.xtout(xtout[951])，.a(a[951])，.b(b[951])，.c(c[951])，.d(d[951])，.sel(sel))； xtmux4bi952(.xtout(xtout[952])，.a(a[952])，.b(b[952])，.c(c[952])，.d(d[952])，.sel(sel))； xtmux4bi953(.xtout(xtout[953])，.a(a[953])，.b(b[953])，.c(c[953])，.d(d[953])，.sel(sel))； xtmux4bi954(.xtout(xtout[954])，.a(a[954])，.b(b[954])，.c(c[954])，.d(d[954])，.sel(sel))； xtmux4bi955(.xtout(xtout[955])，.a(a[955])，.b(b[955])，.c(c[955])，.d(d[955])，.sel(sel))； xtmux4bi956(.xtout(xtout[956])，.a(a[956])，.b(b[956])，.c(c[956])，.d(d[956])，.sel(sel))；<dpn="d256"/> xtmux4bi957(.xtout(xtout[957])，.a(a[957])，.b(b[957])，.c(c[957])，.d(d[957])，.sel(sel))； xtmux4bi958(.xtout(xtout[958])，.a(a[958])，.b(b[958])，.c(c[958])，.d(d[958])，.sel(sel))； xtmux4bi959(.xtout(xtout[959])，.a(a[959])，.b(b[959])，.c(c[959])，.d(d[959])，.sel(sel))； xtmux4bi960(.xtout(xtout[960])，.a(a[960])，.b(b[960])，.c(c[960])，.d(d[960])，.sel(sel))； xtmux4bi961(.xtout(xtout[961])，.a(a[961])，.b(b[961])，.c(c[961])，.d(d[961])，.sel(sel))； xtmux4bi962(.xtout(xtout[962])，.a(a[962])，.b(b[962])，.c(c[962])，.d(d[962])，.se1(sel))； xtmux4bi963(.xtout(xtout[963])，.a(a[963])，.b(b[963])，.c(c[963])，.d(d[963])，.sel(sel))； xtmux4bi964(.xtout(xtout[964])，.a(a[964])，.b(b[964])，.c(c[964])，.d(d[964])，.sel(sel))； xtmux4bi965(.xtout(xtout[965])，.a(a[965])，.b(b[965])，.c(c[965])，.d(d[965])，.sel(sel))； xtmux4bi966(.xtout(xtout[966])，.a(a[966])，.b(b[966])，.c(c[966])，.d(d[966])，.sel(sel))； xtmux4bi967(.xtout(xtout[967])，.a(a[967])，.b(b[967])，.c(c[967])，.d(d[967])，.sel(se1))； xtmux4bi968(.xtout(xtout[968])，.a(a[968])，.b(b[968])，.c(c[968])，.d(d[968])，.sel(sel))； xtmux4bi969(.xtout(xtout[969])，.a(a[969])，.b(b[969])，.c(c[969])，.d(d[969])，.sel(sel))； xtmux4bi970(.xtout(xtout[970])，.a(a[970])，.b(b[970])，.c(c[970])，.d(d[970])，.sel(sel))； xtmux4bi971(.xtout(xtout[971])，.a(a[971])，.b(b[971])，.c(c[971])，.d(d[971])，.sel(sel))； xtmux4bi972(.xtout(xtout[972])，.a(a[972])，.b(b[972])，.c(c[972])，.d(d[972])，.sel(sel))； xtmux4bi973(.xtout(xtout[973])，.a(a[973])，.b(b[973])，.c(c[973])，.d(d[973])，.sel(sel))； xtmux4bi974(.xtout(xtout[974])，.a(a[974])，.b(b[974])，.c(c[974])，.d(d[974])，.sel(sel))； xtmux4bi975(.xtout(xtout[975])，.a(a[975])，.b(b[975])，.c(c[975])，.d(d[975])，.sel(sel))； xtmux4bi976(.xtout(xtout[976])，.a(a[976])，.b(b[976])，.c(c[976])，.d(d[976])，.sel(sel))； xtmux4bi977(.xtout(xtout[977])，.a(a[977])，.b(b[977])，.c(c[977])，.d(d[977])，.sel(sel))； xtmux4bi978(.xtout(xtout[978])，.a(a[978])，.b(b[978])，.c(c[978])，.d(d[978])，.sel(sel))； xtmux4bi979(.xtout(xtout[979])，.a(a[979])，.b(b[979])，.c(c[979])，.d(d[979])，.sel(sel))； xtmux4bi980(.xtout(xtout[980])，.a(a[980])，.b(b[980])，.c(c[980])，.d(d[980])，.sel(sel))； xtmux4bi981(.xtout(xtout[981])，.a(a[981])，.b(b[981])，.c(c[981])，.d(d[981])，.sel(sel))； xtmux4bi982(.xtout(xtout[982])，.a(a[982])，.b(b[982])，.c(c[982])，.d(d[982])，.sel(sel))； xtmux4bi983(.xtout(xtout[983])，.a(a[983])，.b(b[983])，.c(c[983])，.d(d[983])，.sel(sel))； xtmux4bi984(.xtout(xtout[984])，.a(a[984])，.b(b[984])，.c(c[984])，.d(d[984])，.sel(sel))； xtmux4bi985(.xtout(xtout[985])，.a(a[985])，.b(b[985])，.c(c[985])，.d(d[985])，.sel(sel))； xtmux4bi986(.xtout(xtout[986])，.a(a[986])，.b(b[986])，.c(c[986])，.d(d[986])，.sel(sel))；<dpn="d257"/> xtmux4bi987(.xtout(xtout[987])，.a(a[987])，.b(b[987])，.c(c[987])，.d(d[987])，.sel(sel))； xtmux4bi988(.xtout(xtout[988])，.a(a[988])，.b(b[988])，.c(c[988])，.d(d[988])，.sel(sel))； xtmux4bi989(.xtout(xtout[989])，.a(a[989])，.b(b[989])，.c(c[989])，.d(d[989])，.sel(sel))； xtmux4bi990(.xtout(xtout[990])，.a(a[990])，.b(b[990])，.c(c[990])，.d(d[990])，.sel(sel))； xtmux4bi991(.xtout(xtout[991])，.a(a[991])，.b(b[991])，.c(c[991])，.d(d[991])，.sel(sel))； xtmux4bi992(.xtout(xtout[992])，.a(a[992])，.b(b[992])，.c(c[992])，.d(d[992])，.sel(sel))； xtmux4bi993(.xtout(xtout[993])，.a(a[993])，.b(b[993])，.c(c[993])，.d(d[993])，.sel(sel))； xtmux4bi994(.xtout(xtout[994])，.a(a[994])，.b(b[994])，.c(c[994])，.d(d[994])，.sel(sel))； xtmux4bi995(.xtout(xtout[995])，.a(a[995])，.b(b[995])，.c(c[995])，.d(d[995])，.sel(sel))； xtmux4bi996(.xtout(xtout[996])，.a(a[996])，.b(b[996])，.c(c[996])，.d(d[996])，.sel(sel))； xtmux4bi997(.xtout(xtout[997])，.a(a[997])，.b(b[997])，.c(c[997])，.d(d[997])，.sel(sel))； xtmux4bi998(.xtout(xtout[998])，.a(a[998])，.b(b[998])，.c(c[998])，.d(d[998])，.sel(sel))； xtmux4bi999(.xtout(xtout[999])，.a(a[999])，.b(b[999])，.c(c[999])，.d(d[999])，.sel(sel))； xtmux4bi1000(.xtout(xtout[1000])，.a(a[1000])，.b(b[1000])，.c(c[1000])，.d(d[1000])，.sel(sel))； xtmux4bi1001(.xtout(xtout[1001])，.a(a[1001])，.b(b[1001])，.c(c[1001])，.d(d[1001])，.sel(sel))； xtmux4bi1002(.xtout(xtout[1002])，.a(a[1002])，.b(b[1002])，.c(c[1002])，.d(d[1002])，.sel(sel))； xtmux4bi1003(.xtout(xtout[1003])，.a(a[1003])，.b(b[1003])，.c(c[1003])，.d(d[1003])，.sel(sel))； xtmux4bi1004(.xtout(xtout[1004])，.a(a[1004])，.b(b[1004])，.c(c[1004])，.d(d[1004])，.sel(sel))； xtmux4bi1005(.xtout(xtout[1005])，.a(a[1005])，.b(b[1005])，.c(c[1005])，.d(d[1005])，.sel(sel))； xtmux4bi1006(.xtout(xtout[1006])，.a(a[1006])，.b(b[1006])，.c(c[1006])，.d(d[1006])，.sel(sel))； xtmux4bi1007(.xtout(xtout[1007])，.a(a[1007])，.b(b[1007])，.c(c[1007])，.d(d[1007])，.sel(sel))； xtmux4bi1008(.xtout(xtout[1008])，.a(a[1008])，.b(b[1008])，.c(c[1008])，.d(d[1008])，.sel(sel))； xtmux4bi1009(.xtout(xtout[1009])，.a(a[1009])，.b(b[1009])，.c(c[1009])，.d(d[1009])，.sel(sel))； xtmux4bi1010(.xtout(xtout[1010])，.a(a[1010])，.b(b[1010])，.c(c[1010])，.d(d[1010])，.sel(sel))； xtmux4bi1011(.xtout(xtout[1011])，.a(a[1011])，.b(b[1011])，.c(c[1011])，.d(d[1011])，.sel(sel))； xtmux4bi1012(.xtout(xtout[1012])，.a(a[1012])，.b(b[1012])，.c(c[1012])，.d(d[1012])，.sel(sel))； xtmux4bi1013(.xtout(xtout[1013])，.a(a[1013])，.b(b[1013])，.c(c[1013])，.d(d[1013])，.sel(sel))； xtmux4bi1014(.xtout(xtout[1014])，.a(a[1014])，.b(b[1014])，.c(c[1014])，.d(d[1014])，.sel(sel))； xtmux4bi1015(.xtout(xtout[1015])，.a(a[1015])，.b(b[1015])，.c(c[1015])，.d(d[1015])，.sel(sel))； xtmux4bi1016(.xtout(xtout[1016])，.a(a[1016])，.b(b[1016])，.c(c[1016])，.d(d[1016])，.sel(sel))；<dpn="d258"/> xtmux4bi1017(.xtout(xtout[1017])，.a(a[1017])，.b(b[1017])，.c(c[1017])，.d(d[1017])，.sel(sel))； xtmux4bi1018(.xtout(xtout[1018])，.a(a[1018])，.b(b[1018])，.c(c[1018])，.d(d[1018])，.sel(sel))； xtmux4bi1019(.xtout(xtout[1019])，.a(a[1019])，.b(b[1019])，.c(c[1019])，.d(d[1019])，.sel(sel))； xtmux4bi1020(.xtout(xtout[1020])，.a(a[1020])，.b(b[1020])，.c(c[1020])，.d(d[1020])，.sel(sel))； xtmux4bi1021(.xtout(xtout[1021])，.a(a[1021])，.b(b[1021])，.c(c[1021])，.d(d[1021])，.sel(8el))； xtmux4bi1022(.xtout(xtout[1022])，.a(a[1022])，.b(b[1022])，.c(c[1022])，.d(d[1022])，.sel(sel))； xtmux4bi1023(.xtout(xtout[1023])，.a(a[1023])，.b(b[1023])，.c(c[1023])，.d(d[1023])，.sel(sel))；endmodulemodulextcsa_1024(sum，carry，a，b，c)；output[10230]sum，carry；input[10230]a，b，c； xtfai0(.sum(sum)，.carry(carry)，.a(a)，.b(b)，.c(c))； xtfai1(.sum(sum[1])，.carry(carry[1])，.a(a[1])，.b(b[1])，.c(c[1]))； xtfai2(.sum(sum[2])，.carry(carry[2])，.a(a[2])，.b(b[2])，.c(c[2]))； xtfai3(.sum(sum[3])，.carry(carry[3])，.a(a[3])，.b(b[3])，.c(c[3]))； xtfai4(.sum(sum[4])，.carry(carry[4])，.a(a[4])，.b(b[4])，.c(c[4]))； xtfai5(.sum(sum[5])，.carry(carry[5])，.a(a[5])，.b(b[5])，.c(c[5]))； xtfai6(.sum(sum[6])，.carry(carry[6])，.a(a[6])，.b(b[6])，.c(c[6]))； xtfai7(.sum(sum[7])，.carry(carry[7])，.a(a[7])，.b(b[7])，.c(c[7]))； xtfai8(.sum(sum[8])，.carry(carry[8])，.a(a[8])，.b(b[8])，.c(c[8]))； xtfai9(.sum(sum[9])，.carry(carry[9])，.a(a[9])，.b(b[9])，.c(c[9]))； xtfai10(.sum(sum[10])，.carry(carry[10])，.a(a[10])，.b(b[10])，.c(c[10]))； xtfai11(.sum(sum[11])，.carry(carry[11])，.a(a[11])，.b(b[11])，.c(c[11]))； xtfai12(.sum(sum[12])，.carry(carry[12])，.a(a[12])，.b(b[12])，.c(c[12]))； xtfai13(.sum(sum[13])，.carry(carry[13])，.a(a[13])，.b(b[13])，.c(c[13]))； xtfai14(.sum(sum[14])，.carry(carry[14])，.a(a[14])，.b(b[14])，.c(c[14]))； xtfai15(.sum(sum[15])，.carry(carry[15])，.a(a[15])，.b(b[15])，.c(c[15]))； xtfai16(.sum(sum[16])，.carry(carry[16])，.a(a[16])，.b(b[16])，.c(c[16]))； xtfai17(.sum(sum[17])，.carry(carry[17])，.a(a[17])，.b(b[17])，.c(c[17]))； xtfai18(.sum(sum[18])，.carry(carry[18])，.a(a[18])，.b(b[18])，.c(c[18]))； xtfai19(.sum(sum[19])，.carry(carry[19])，.a(a[19])，.b(b[19])，.c(c[19]))； xtfai20(.sum(sum[20])，.carry(carry[20])，.a(a[20])，.b(b[20])，.c(c[20]))； xtfai21(.sum(sum[21])，.carry(carry[21])，.a(a[21])，.b(b[21])，.c(c[21]))； xtfai22(.sum(sum[22])，.carry(carry[22])，.a(a[22])，.b(b[22])，.c(c[22]))； xtfai23(.sum(sum[23])，.carry(carry[23])，.a(a[23])，.b(b[23])，.c(c[23]))； xtfai24(.sum(sum[24])，.carry(carry[24])，.a(a[24])，.b(b[24])，.c(c[24]))； xtfai25(.sum(sum[25])，.carry(carry[25])，.a(a[25])，.b(b[25])，.c(c[25]))；<dpn="d259"/> xtfai26(.sum(sum[26])，.carry(carry[26])，.a(a[26])，.b(b[26])，.c(c[26]))； xtfai27(.sum(sum[27])，.carry(carry[27])，.a(a[27])，.b(b[27])，.c(c[27]))； xtfai28(.sum(sum[28])，.carry(carry[28])，.a(a[28])，.b(b[28])，.c(c[28]))； xtfai29(.sum(sum[29])，.carry(carry[29])，，a(a[29])，.b(b[29])，.c(c[29]))； xtfai30(.sum(sum[30])，.carry(carry[30])，.a(a[30])，b(b[30])，.c(c[30]))； xtfai31(.sum(sum[31])，.carry(carry[31])，.a(a[31])，.b(b[31])，.c(c[31]))； xtfai32(.sum(sum[32])，.carry(carry[32])，.a(a[32])，.b(b[32])，.c(c[32]))； xtfai33(.sum(sum[33])，.carry(carry[33])，.a(a[33])，.b(b[33])，.c(c[33]))； xtfai34(.sum(sum[34])，.carry(carry[34])，.a(a[34])，.b(b[34])，.c(c[34]))； xtfai35(.sum(sum[35])，.carry(carry[35])，.a(a[35])，.b(b[35])，.c(c[35]))； xtfai36(.sum(sum[36])，.carry(carry[36])，.a(a[36])，.b(b[36])，.c(c[36]))； xtfai37(.sum(sum[37])，.carry(carry[37])，.a(a[37])，.b(b[37])，.c(c[37]))； xtfai38(.sum(sum[38])，.carry(carry[38])，.a(a[38])，.b(b[38])，.c(c[38]))； xtfai39(.sum(sum[39])，.carry(carry[39])，.a(a[39])，.b(b[39])，.c(c[39]))； xtfai40(.sum(sum[40])，.carry(carry[40])，.a(a[40])，.b(b[40])，.c(c[40]))； xtfai41(.sum(sum[41])，.carry(carry[41])，.a(a[41])，.b(b[41])，.c(c[41]))； xtfai42(.sum(sum[42])，.carry(carry[42])，.a(a[42])，.b(b[42])，.c(c[42]))； xtfai43(.sum(sum[43])，.carry(carry[43])，.a(a[43])，.b(b[43])，.c(c[43]))； xtfai44(.sum(sum[44])，.carry(carry[44])，.a(a[44])，.b(b[44])，.c(c[44]))； xtfai45(.sum(sum[45])，.carry(carry[45])，.a(a[45])，.b(b[45])，.c(c[45]))； xtfai46(.sum(sum[46])，.carry(carry[46])，.a(a[46])，.b(b[46])，.c(c[46]))； xtfai47(.sum(sum[47])，.carry(carry[47])，.a(a[47])，.b(b[47])，.c(c[47]))； xtfai48(.sum(sum[48])，.carry(carry[48])，.a(a[48])，.b(b[48])，.c(c[48]))； xtfai49(.sum(sum[49])，.carry(carry[49])，.a(a[49])，.b(b[49])，.c(c[49]))； xtfai50(.sum(sum[50])，.carry(carry[50])，.a(a[50])，.b(b[50])，.c(c[50]))； xtfai51(.sum(sum[51])，.carry(carry[51])，.a(a[51])，.b(b[51])，.c(c[51]))； xtfai52(.sum(sum[52])，.carry(carry[52])，.a(a[52])，.b(b[52])，.c(c[52]))； xtfai53(.sum(sum[53])，.carry(carry[53])，.a(a[53])，.b(b[53])，.c(c[53]))； xtfai54(.sum(sum[54])，.carry(carry[54])，.a(a[54])，.b(b[54])，.c(c[54]))； xtfai55(.sum(sum[55])，.carry(carry[55])，.a(a[55])，.b(b[55])，.c(c[55]))；<dpn="d260"/> xtfai56(.sum(sum[56])，.carry(carry[56])，.a(a[56])，.b(b[56])，.c(c[56]))； xtfai57(.sum(sum[57])，.carry(carry[57])，.a(a[57])，.b(b[57])，.c(c[57]))； xtfai58(.sum(sum[58])，.carry(carry[58])，.a(a[58])，.b(b[58])，.c(c[58]))； xtfai59(.sum(sum[59])，.carry(carry[59])，.a(a[59])，.b(b[59])，.c(c[59]))； xtfai60(.sum(sum[60])，.carry(carry[60])，.a(a[60])，.b(b[60])，.c(c[60]))； xtfai61(.sum(sum[61])，.carry(carry[61])，.a(a[61])，.b(b[61])，.c(c[61]))； xtfai62(.sum(sum[62])，.carry(carry[62])，.a(a[62])，.b(b[62])，.c(c[62]))； xtfai63(.sum(sum[63])，.carry(carry[63])，.a(a[63])，.b(b[63])，.c(c[63]))； xtfai64(.sum(sum[64])，.carry(carry[64])，.a(a[64])，.b(b[64])，.c(c[64]))； xtfai65(.sum(sum[65])，.carry(carry[65])，.a(a[65])，.b(b[65])，.c(c[65]))； xtfai66(.sum(sum[66])，.carry(carry[66])，.a(a[66])，.b(b[66])，.c(c[66]))； xtfai67(.sum(sum[67])，.carry(carry[67])，.a(a[67])，.b(b[67])，.c(c[67]))； xtfai68(.sum(sum[68])，.carry(carry[68])，.a(a[68])，.b(b[68])，.c(c[68]))； xtfai69(.sum(sum[69])，.carry(carry[69])，.a(a[69])，.b[b[69])，.c(c[69]))； xtfai70(.sum(sum[70])，.carry(carry[70])，.a(a[70])，.b(b[70])，.c(c[70]))； xtfai71(.sum(sum[71])，.carry(carry[71])，.a(a[71])，.b(b[71])，.c(c[71]))； xtfai72(.sum(sum[72])，.carry(carry[72])，.a(a[72])，.b(b[72])，.c(c[72]))； xtfai73(.sum(sum[73])，.carry(carry[73])，.a(a[73])，.b(b[73])，.c(c[73]))； xtfai74(.sum(sum[74])，.carry(carry[74])，.a(a[74])，.b(b[74])，.c(c[74]))； xtfai75(.sum(sum[75])，.carry(carry[75])，.a(a[75])，.b(b[75])，.c(c[75]))； xtfai76(.sum(sum[76])，.carry(carry[76])，a(a[76])，.b(b[76])，.c(c[76]))； xtfai77(.sum(sum[77])，.carry(carry[77])，.a(a[77])，.b(b[77])，.c(c[77]))； xtfai78(.sum(sum[78])，.carry(carry[78])，.a(a[78])，.b(b[78])，.c(c[78]))； xtfai79(.sum(sum[79])，.carry(carry[79])，.a(a[79])，.b(b[79])，.c(c[79]))； xtfai80(.sum(sum[80])，.carry(carry[80])，.a(a[80])，.b(b[80])，.c(c[80]))； xtfai81(.sum(sum[81])，.carry(carry[81])，.a(a[81])，.b(b[81])，.c(c[81]))； xtfai82(.sum(sum[82])，.carry(carry[82])，.a(a[82])，.b(b[82])，.c(c[82]))； xtfai83(.sum(sum[83])，.carry(carry[83])，.a(a[83])，.b(b[83])，.c(c[83]))； xtfai84(.sum(sum[84])，.carry(carry[84])，.a(a[84])，.b(b[84])，.c(c[84]))； xtfai85(.sum(sum[85])，.carry(carry[85])，.a(a[85])，.b(b[85])，.c(c[85]))；<dpn="d261"/> xtfai86(.sum(sum[86])，.carry(carry[86])，.a(a[86])，.b(b[86])，.c(c[86]))； xtfai87(.sum(sum[87])，.carry(carry[87])，.a(a[87])，.b(b[87])，.c(c[87]))； xtfai88(.sum(sum[88])，.carry(carry[88])，.a(a[88])，.b(b[88])，.c(c[88]))； xtfai89(.sum(sum[89])，.carry(carry[89])，.a(a[89])，.b(b[89])，.c(c[89]))； xtfai90(.sum(sum[90])，.carry(carry[90])，.a(a[90])，.b(b[90])，.c(c[90]))； xtfai91(.sum(sum[91])，.carry(carry[91])，.a(a[91])，.b(b[91])，.c(c[91]))； xtfai92(.sum(sum[92])，.carry(carry[92])，.a(a[92])，.b(b[92])，.c(c[92]))； xtfai93(.sum(sum[93])，.carty(carry[93])，.a(a[93])，.b(b[93])，.c(c[93]))； xtfai94(.sum(sum[94])，.carry(carry[94])，.a(a[94])，.b(b[94])，.c(c[94]))； xtfai95(.sum(sum[95])，.carry(carry[95])，.a(a[95])，.b(b[95])，.c(c[95]))； xtfai96(.sum(sum[96])，.carry(carry[96])，.a(a[96])，.b(b[96])，.c(c[96]))； xtfai97(.sum(sum[97])，.carry(carry[97])，.a(a[97])，.b(b[97])，.c(c[97]))； xtfai98(.sum(sum[98])，.carry(carry[98])，.a(a[98])，.b(b[98])，.c(c[98]))； xtfai99(.sum(sum[99])，.carry(carry[99])，.a(a[99])，.b(b[99])，.c(c[99]))； xtfai100(.sum(sum[100])，.carry(carry[100])，.a(a[100])，.b(b[100])，.c(c[100]))； xtfai101(.sum(sum[101])，.carry(carry[101])，.a(a[101])，.b(b[101])，.c(c[101]))； xtfai102(.sum(sum[102])，.carry(carry[102])，.a(a[102])，.b(b[102])，.c(c[102]))； xtfai103(.sum(sum[103])，.carry(carry[103])，.a(a[103])，.b(b[103])，.c(c[103]))； xtfai104(.sum(sum[104])，.carry(carry[104])，.a(a[104])，.b(b[104])，.c(c[104]))； xtfai105(.sum(sum[105])，.carry(carry[105])，.a(a[105])，.b(b[105])，.c(c[105]))； xtfai106(.sum(sum[106])，.carry(carry[106])，.a(a[106])，.b(b[106])，.c(c[106]))； xtfai107(.sum(sum[107])，.carry(carry[107])，.a(a[107])，.b(b[107])，.c(c[107]))； xtfai108(.sum(sum[108])，.carry(carry[108])，.a(a[108])，.b(b[108])，.c(c[108]))； xtfai109(.sum(sum[109])，.carry(carry[109])，.a(a[109])，.b(b[109])，.c(c[109]))； xtfai110(.sum(sum[110])，.carry(carry[110])，.a(a[110])，.b(b[110])，.c(c[110]))； xtfai111(.sum(sum[111])，.carry(carry[111])，.a(a[111])，.b(b[111])，.c(c[111]))； xtfai112(.sum(sum[112])，.carry(carry[112])，.a(a[112])，.b(b[112])，.c(c[112]))； xtfai113(.sum(sum[113])，.carry(carry[113])，.a(a[113])，.b(b[113])，.c(c[113]))； xtfai114(.sum(sum[114])，.carry(carry[114])，.a(a[114])，.b(b[114])，.c(c[114]))； xtfai115(.sum(sum[115])，.carry(carry[115])，.a(a[115])，.b(b[115])，.c(c[115]))；<dpn="d262"/> xtfai116(.sum(sum[116])，.carry(carry[116])，.a(a[116])，.b(b[116])，.c(c[116]))； xtfai117(.sum(sum[117])，.carry(carry[117])，.a(a[117])，.b(b[117])，.c(c[117]))； xtfai118(.sum(sum[118])，.carry(carry[118])，.a(a[118])，.b(b[118])，.c(c[118]))； xtfai119(.sum(sum[119])，.carry(carry[119])，.a(a[119])，.b(b[119])，.c(c[119]))； xtfai120(.sum(sum[120])，.carry(carry[120])，.a(a[120])，.b(b[120])，.c(c[120]))； xtfai121(.sum(sum[121])，.carry(carry[121])，.a(a[121])，.b(b[121])，.c(c[121]))； xtfai122(.sum(sum[122])，.carry(carry[122])，.a(a[122])，.b(b[122])，.c(c[122]))； xtfai123(.sum(sum[123])，.carry(carry[123])，.a(a[123])，.b(b[123])，.c(c[123]))； xtfai124(.sum(sum[124])，.carry(carry[124])，.a(a[124])，.b(b[124])，.c(c[124]))； xtfai125(.sum(sum[125])，.carry(carry[125])，.a(a[125])，.b(b[125])，.c(c[125]))； xtfai126(.sum(sum[126])，.carry(carry[126])，.a(a[126])，.b(b[126])，.c(c[126]))； xtfai127(.sum(sum[127])，.carry(carry[127])，.a(a[127])，.b(b[127])，.c(c[127]))； xtfai128(.sum(sum[128])，.carry(carry[128])，.a(a[128])，.b(b[128])，.c(c[128]))； xtfai129(.sum(sum[129])，.carry(carry[129])，.a(a[129])，.b(b[129])，.c(c[129]))； xtfai130(.sum(sum[130])，.carry(carry[130])，.a(a[130])，.b(b[130])，.c(c[130]))； xtfai131(.sum(sum[131])，.carry(carry[131])，.a(a[131])，.b(b[131])，.c(c[131]))； xtfai132(.sum(sum[132])，.carry(carry[132])，.a(a[132])，.b(b[132])，.c(c[132]))； xtfai133(.sum(sum[133])，.carry(carry[133])，.a(a[133])，.b(b[133])，.c(c[133]))； xtfai134(.sum(sum[134])，.carry(carry[134])，.a(a[134])，.b(b[134])，.c(c[134]))； xtfai135(.sum(sum[135])，.carry(carry[135])，.a(a[135])，.b(b[135])，.c(c[135]))； xtfai136(.sum(sum[136])，.carry(carry[136])，.a(a[136])，.b(b[136])，.c(c[136]))； xtfai137(.sum(sum[137])，.carry(carry[137])，.a(a[137])，.b(b[137])，.c(c[137]))； xtfai138(.sum(sum[138])，.carry(carry[138])，.a(a[138])，.b(b[138])，.c(c[138]))； xtfai139(.sum(sum[139])，.carry(carry[139])，.a(a[139])，.b(b[139])，.c(c[139]))； xtfai140(.sum(sum[140])，.carry(carry[140])，.a(a[140])，.b(b[140])，.c(c[140]))； xtfai141(.sum(sum[141])，.carry(carry[141])，.a(a[141])，.b(b[141])，.c(c[141]))； xtfai142(.sum(sum[142])，.carry(carry[142])，.a(a[142])，.b(b[142])，.c(c[142]))； xtfai143(.sum(sum[143])，.carry(carry[143])，.a(a[143])，.b(b[143])，.c(c[143]))； xtfai144(.sum(sum[144])，.carry(carry[144])，.a(a[144])，.b(b[144])，.c(c[144]))； xtfai145(.sum(sum[145])，.carry(carry[145])，.a(a[145])，.b(b[145])，.c(c[145]))；<dpn="d263"/> xtfai146(.sum(sum[146])，.carry(carry[146])，.a(a[146])，.b(b[146])，.c(c[146]))； xtfai147(.sum(sum[147])，.carry(carry[147])，.a(a[147])，.b(b[147])，.c(c[147]))； xtfai148(.sum(sum[148])，.carry(carry[148])，.a(a[148])，.b(b[148])，.c(c[148]))； xtfai149(.sum(sum[149])，.carry(carry[149])，.a(a[149])，.b(b[149])，.c(c[149]))； xtfai150(.sum(sum[150])，.carry(carry[150])，.a(a[150])，.b(b[150])，.c(c[150]))； xtfai151(.sum(sum[151])，.carry(carry[151])，.a(a[151])，.b(b[151])，.c(c[151]))； xtfai152(.sum(sum[152])，.carry(carry[152])，.a(a[152])，.b(b[152])，.c(c[152]))； xtfai153(.sum(sum[153])，.carry(carry[153])，.a(a[153])，.b(b[153])，.c(c[153]))； xtfai154(.sum(sum[154])，.carry(carry[154])，.a(a[154])，.b(b[154])，.c(c[154]))； xtfai155(.sum(sum[155])，.carry(carry[155])，.a(a[155])，.b(b[155])，.c(c[155]))； xtfai156(.sum(sum[156])，.carry(carry[156])，.a(a[156])，.b(b[156])，.c(c[156]))； xtfai157(.sum(sum[157])，.carry(carry[157])，.a(a[157])，.b(b[157])，.c(c[157]))； xtfai158(.sum(sum[158])，.carry(carry[158])，.a(a[158])，.b(b[158])，.c(c[158]))； xtfai159(.sum(sum[159])，.carry(carry[159])，.a(a[159])，.b(b[159])，.c(c[159]))； xtfai160(.sum(sum[160])，.carry(carry[160])，.a(a[160])，.b(b[160])，.c(c[160]))； xtfai161(.sum(sum[161])，.carry(carry[161])，.a(a[161])，.b(b[161])，.c(c[161]))； xtfai162(.sum(sum[162])，.carry(carry[162])，.a(a[162])，.b(b[162])，.c(c[162]))； xtfai163(.sum(sum[163])，.carry(carry[163])，.a(a[163])，.b(b[163])，.c(c[163]))； xtfai164(.sum(sum[164])，.carry(carry[164])，.a(a[164])，.b(b[164])，.c(c[164]))； xtfai165(.sum(sum[165])，.carry(carry[165])，.a(a[165])，.b(b[165])，.c(c[165]))； xtfai166(.sum(sum[166])，.carry(carry[166])，.a(a[166])，.b(b[166])，.c(c[166]))； xtfai167(.sum(sum[167])，.carry(carry[167])，.a(a[167])，.b(b[167])，.c(c[167]))； xtfai168(.sum(sum[168])，.carry(carry[168])，.a(a[168])，.b(b[168])，.c(c[168]))； xtfai169(.sum(sum[169])，.carry(carry[169])，.a(a[169])，.b(b[169])，.c(c[169]))； xtfai170(.sum(sum[170])，.carry(carry[170])，.a(a[170])，.b(b[170])，.c(c[170]))； xtfai171(.sum(sum[171])，.carry(carry[171])，.a(a[171])，.b(b[171])，.c(c[171]))； xtfai172(.sum(sum[172])，.carry(carry[172])，.a(a[172])，.b(b[172])，.c(c[172]))； xtfai173(.sum(sum[173])，.carry(carry[173])，.a(a[173])，.b(b[173])，.c(c[173]))； xtfai174(.sum(sum[174])，.carry(carry[174])，.a(a[174])，.b(b[174])，.c(c[174]))； xtfai175(.sum(sum[175])，.carry(carry[175])，.a(a[175])，.b(b[175])，.c(c[175]))；<dpn="d264"/> xtfai176(.sum(sum[176])，.carry(carry[176])，.a(a[176])，.b(b[176])，.c(c[176]))； xtfai177(.sum(sum[177])，.carry(carry[177])，.a(a[177])，.b(b[177])，.c(c[177]))； xtfai178(.sum(sum[178])，.carry(carry[178])，.a(a[178])，.b(b[178])，.c(c[178]))； xtfai179(.sum(sum[179])，.carry(carry[179])，.a(a[179])，.b(b[179])，.c(c[179]))； xtfai180(.sum(sum[180])，.carry(carry[180])，.a(a[180])，.b(b[180])，.c(c[180]))； xtfai181(.sum(sum[181])，.carry(carry[181])，.a(a[181])，.b(b[181])，.c(c[181]))； xtfai182(.sum(sum[182])，.carry(carry[182])，.a(a[182])，.b(b[182])，.c(c[182]))； xtfai183(.sum(sum[183])，.carry(carry[183])，.a(a[183])，b(b[183])，.c(c[183]))； xtfai184(.sum(sum[184])，.carry(carry[184])，.a(a[184])，.b(b[184])，.c(c[184]))； xtfai185(.sum(sum[185])，.carry(carry[185])，.a(a[185])，.b(b[185])，.c(c[185]))； xtfai186(.sum(sum[186])，.carry(carry[186])，.a(a[186])，.b(b[186])，.c(c[186]))； xtfai187(.sum(sum[187])，.carry(carry[187])，.a(a[187])，.b(b[187])，.c(c[187]))； xtfai188(.sum(sum[188])，.carry(carry[188])，.a(a[188])，.b(b[188])，.c(c[188]))； xtfai189(.sum(sum[189])，.carry(carry[189])，.a(a[189])，.b(b[189])，.c(c[189]))； xtfai190(.sum(sum[190])，.carry(carry[190])，.a(a[190])，.b(b[190])，.c(c[190]))； xtfai191(.sum(sum[191])，.carry(carry[191])，.a(a[191])，.b(b[191])，.c(c[191]))； xtfai192(.sum(sum[192])，.carry(carry[192])，.a(a[192])，.b(b[192])，.c(c[192]))； xtfai193(.sum(sum[193])，.carry(carry[193])，.a(a[193])，.b(b[193])，.c(c[193]))； xtfai194(.sum(sum[194])，.carry(carry[194])，.a(a[194])，.b(b[194])，.c(c[194]))； xtfai195(.sum(sum[195])，.carry(carry[195])，.a(a[195])，.b(b[195])，.c(c[195]))； xtfai196(.sum(sum[196])，.carry(carry[196])，.a(a[196])，.b(b[196])，.c(c[196]))； xtfai197(.sum(sum[197])，.carry(carry[197])，.a(a[197])，.b(b[197])，.c(c[197]))； xtfai198(.sum(sum[198])，.carry(carry[198])，.a(a[198])，.b(b[198])，.c(c[198]))； xtfai199(.sum(sum[199])，.carry(carry[199])，.a(a[199])，.b(b[199])，.c(c[199]))； xtfai200(.sum(sum[200])，.carry(carry[200])，.a(a[200])，.b(b[200])，.c(c[200]))； xtfai201(.sum(sum[201])，.carry(carry[201])，.a(a[201])，.b(b[201])，.c(c[201]))； xtfai202(.sum(sum[202])，.carry(carry[202])，.a(a[202])，.b(b[202])，.c(c[202]))； xtfai203(.sum(sum[203])，.carry(carry[203])，.a(a[203])，.b(b[203])，.c(c[203]))； xtfai204(.sum(sum[204])，.carry(carry[204])，.a(a[204])，.b(b[204]，.c(c[204]))； xtfai205(.sum(sum[205])，.carry(carry[205])，.a(a[205])，.b(b[205])，.c(c[205]))；<dpn="d265"/> xtfai206(.sum(sum[206])，.carry(carry[206])，.a(a[206])，.b(b[206])，.c(c[206]))； xtfai207(.sum(sum[207])，.carry(carry[207])，.a(a[207])，.b(b[207])，.c(c[207]))； xtfai208(.sum(sum[208])，.carry(carry[208])，.a(a[208])，.b(b[208])，.c(c[208]))； xtfai209(.sum(sum[209])，.carry(carry[209])，.a(a[209])，.b(b[209])，.c(c[209]))； xtfai210(.sum(sum[210])，.carry(carry[210])，.a(a[210])，.b(b[210])，.c(c[210]))； xtfai211(.sum(sum[211])，.carry(carry[211])，.a(a[211])，.b(b[211])，.c(c[211]))； xtfai212(.sum(sum[212])，.carry(carry[212])，.a(a[212])，.b(b[212])，.c(c[212]))； xtfai213(.sum(sum[213])，.carry(carry[213])，.a(a[213])，.b(b[213])，.c(c[213]))； xtfai214(.sum(sum[214])，.carry(carry[214])，.a(a[214])，.b(b[214])，.c(c[214]))； xtfai215(.sum(sum[215])，.carry(carry[215])，.a(a[215])，.b(b[215])，.c(c[215]))； xtfai216(.sum(sum[216])，.carry(carry[216])，.a(a[216])，.b(b[216])，.c(c[216]))； xtfai217(.sum(sum[217])，.carry(carry[217])，.a(a[217])，.b(b[217])，.c(c[217]))； xtfai218(.sum(sum[218])，.carry(carry[218])，.a(a[218])，.b(b[218])，.c(c[218]))； xtfai219(.sum(sum[219])，.carry(carry[219])，.a(a[219])，.b(b[219])，.c(c[219]))； xtfai220(.sum(sum[220])，.carry(carry[220])，.a(a[220])，.b(b[220])，.c(c[220]))； xtfai221(.sum(sum[221])，.carry(carry[221])，.a(a[221])，.b(b[221])，.c(c[221]))； xtfai222(.sum(sum[222])，.carry(carry[222])，.a(a[222])，.b(b[222])，.c(c[222]))； xtfai223(.sum(sum[223])，.carry(carry[223])，.a(a[223])，.b(b[223])，.c(c[223]))； xtfai224(.sum(sum[224])，.carry(carry[224])，.a(a[224])，.b(b[224])，.c(c[224]))； xtfai225(.sum(sum[225])，.carry(carry[225])，.a(a[225])，.b(b[225])，.c(c[225]))； xtfai226(.sum(sum[226])，.carry(carry[226])，.a(a[226])，.b(b[226])，.c(c[226]))； xtfai227(.sum(sum[227])，.carry(carry[227])，.a(a[227])，.b(b[227])，.c(c[227]))； xtfai228(.sum(sum[228])，.carry(carry[228])，.a(a[228])，.b(b[228])，.c(c[228]))； xtfai229(.sum(sum[229])，.carry(carry[229])，.a(a[229])，.b(b[229])，.c(c[229]))； xtfai230(.sum(sum[230])，.carry(carry[230])，.a(a[230])，.b(b[230])，.c(c[230]))； xtfai231(.sum(sum[231])，.carry(carry[231])，.a(a[231])，.b(b[231])，.c(c[231]))； xtfai232(.sum(sum[232])，.carry(carry[232])，.a(a[232])，.b(b[232])，.c(c[232]))； xtfai233(.sum(sum[233])，.carry(carry[233])，.a(a[233])，.b(b[233])，.c(c[233]))； xtfai234(.sum(sum[234])，.carry(carry[234])，.a(a[234])，.b(b[234])，.c(c[234]))； xtfai235(.sum(sum[235])，.carry(carry[235])，.a(a[235])，.b(b[235])，.c(c[235]))；<dpn="d266"/> xtfai236(.sum(sum[236])，.carry(carry[236])，.a(a[236])，.b(b[236])，.c(c[236]))； xtfai237(.sum(sum[237])，.carry(carry[237])，.a(a[237])，.b(b[237])，.c(c[237]))； xtfai238(.sum(sum[238])，.carry(carry[238])，.a(a[238])，.b(b[238])，.c(c[238]))； xtfai239(.sum(sum[239])，.carry(carry[239])，.a(a[239])，.b(b[239])，.c(c[239]))； xtfai240(.sum(sum[240])，.carry(carry[240])，.a(a[240])，.b(b[240])，.c(c[240]))； xtfai241(.sum(sum[241])，.carry(carry[241])，.a(a[241])，.b(b[241])，.c(c[241]))； xtfai242(.sum(sum[242])，.carry(carry[242])，.a(a[242])，.b(b[242])，.c(c[242]))； xtfai243(.sum(sum[243])，.carry(carry[243])，.a(a[243])，.b(b[243])，.c(c[243]))； xtfai244(.sum(sum[244])，.carry(carry[244])，.a(a[244])，.b(b[244])，.c(c[244]))； xtfai245(.sum(sum[245])，.carry(carry[245])，.a(a[245])，.b(b[245])，.c(c[245]))； xtfai246(.sum(sum[246])，.carry(carry[246])，.a(a[246])，.b(b[246])，.c(c[246]))； xtfai247(.sum(sum[247])，.carry(carry[247])，.a(a[247])，.b(b[247])，.c(c[247]))； xtfai248(.sum(sum[248])，.carry(carry[248])，.a(a[248])，.b(b[248])，.c(c[248]))； xtfai249(.sum(sum[249])，.carry(carry[249])，.a(a[249])，.b(b[249])，.c(c[249]))； xtfai250(.sum(sum[250])，.carry(carry[250])，.a(a[250])，.b(b[250])，.c(c[250]))； xtfai251(.sum(sum[251])，.carry(carry[251])，.a(a[251])，.b(b[251])，.c(c[251]))； xtfai252(.sum(sum[252])，.carry(carry[252])，.a(a[252])，.b(b[252])，.c(c[252]))； xtfai253(.sum(sum[253])，.carry(carry[253])，.a(a[253])，.b(b[253])，.c(c[253]))； xtfai254(.sum(sum[254])，.carry(carry[254])，.a(a[254])，.b(b[254])，.c(c[254]))； xtfai255(.sum(sum[255])，.carry(carry[255])，.a(a[255])，.b(b[255])，.c(c[255]))； xtfai256(.sum(sum[256])，.carry(carry[256])，.a(a[256])，.b(b[256])，.c(c[256]))； xtfai257(.sum(sum[257])，.carry(carry[257])，.a(a[257])，.b(b[257])，.c(c[257]))； xtfai258(.sum(sum[258])，.carry(carry[258])，.a(a[258])，.b(b[258])，.c(c[258]))； xtfai259(.sum(sum[259])，.carry(carry[259])，.a(a[259])，.b(b[259])，.c(c[259]))； xtfai260(.sum(sum[260])，.carry(carry[260])，.a(a[260])，.b(b[260])，.c(c[260]))； xtfai261(.sum(sum[261])，.carry(carry[261])，.a(a[261])，.b(b[261])，.c(c[261]))； xtfai262(.sum(sum[262])，.carry(carry[262])，.a(a[262])，.b(b[262])，.c(c[262]))； xtfai263(.sum(sum[263])，.carry(carry[263])，.a(a[263])，.b(b[263])，.c(c[263]))； xtfai264(.sum(sum[264])，.carry(carry[264])，.a(a[264])，.b(b[264])，.c(c[264]))； xtfai265(.sum(sum[265])，.carry(carry[265])，.a(a[265])，.b(b[265])，.c(c[265]))；<dpn="d267"/> xtfai266(.sum(sum[266])，.carry(carry[266])，.a(a[266])，.b(b[266])，.c(c[266]))； xtfai267(.sum(sum[267])，.carry(carry[267])，.a(a[267])，.b(b[267])，.c(c[267]))； xtfai268(.sum(sum[268])，.carry(carry[268])，.a(a[268])，.b(b[268])，.c(c[268]))； xtfai269(.sum(sum[269])，.carry(carry[269])，.a(a[269])，.b(b[269])，.c(c[269]))； xtfai270(.sum(sum[270])，.carry(carry[270])，.a(a[270])，.b(b[270])，.c(c[270]))； xtfai271(.sum(sum[271])，.carry(carry[271])，.a(a(271])，.b(b[271])，.c(c[271]))； xtfai272(.sum(sum[272])，.carry(carry[272])，.a(a[272])，.b(b[272])，.c(c[272]))； xtfai273(.sum(sum[273])，.carry(carry[273])，.a(a[273])，.b(b[273])，.c(c[273]))； xtfai274(.sum(sum[274])，.carry(carry[274])，.a(a[274])，.b(b[274])，.c(c[274]))； xtfai275(.sum(sum[275])，.carry(carry[275])，.a(a[275])，.b(b[275])，.c(c[275]))； xtfai276(.sum(sum[276])，.carry(carry[276])，.a(a[276])，.b(b[276])，.c(c[276]))； xtfai277(.sum(sum[277])，.carry(carry[277])，.a(a[277])，.b(b[277])，.c(c[277]))； xtfai278(.sum(sum[278])，.carry(carry[278])，.a(a[278])，.b(b[278])，.c(c[278]))； xtfai279(.sum(sum[279])，.carry(carry[279])，.a(a[279])，.b(b[279])，.c(c[279]))； xtfai280(.sum(sum[280])，.carry(carry[280])，.a(a[280])，.b(b[280])，.c(c[280]))； xtfai281(.sum(sum[281])，.carry(carry[281])，.a(a[281])，.b(b[281])，.c(c[281]))； xtfai282(.sum(sum[282])，.carry(carry[282])，.a(a[282])，.b(b[282])，.c(c[282]))； xtfai283(.sum(sum[283])，.carry(carry[283])，.a(a[283])，.b(b[283])，.c(c[283]))； xtfai284(.sum(sum[284])，.carry(carry[284])，.a(a[284])，.b(b[284])，.c(c[284]))； xtfai285(.sum(sum[285])，.carry(carry[285])，.a(a[285])，.b(b[285])，.c(c[285]))； xtfai286(.sum(sum[286])，.carry(carry[286])，.a(a[286])，.b(b[286])，.c(c[286]))； xtfai287(.sum(sum[287])，.carry(carry[287])，.a(a[287])，.b(b[287])，.c(c[287]))； xtfai288(.sum(sum[288])，.carry(carry[288])，.a(a[288])，.b(b[288])，.c(c[288]))； xtfai289(.sum(sum[289])，.carry(carry[289])，.a(a[289])，.b(b[289])，.c(c[289]))； xtfai290(.sum(sum[290])，.carry(carry[290])，.a(a[290])，.b(b[290])，.c(c[290]))； xtfai291(.sum(sum[291])，.carry(carry[291])，.a(a[291])，.b(b[291])，.c(c[291]))； xtfai292(.sum(sum[292])，.carry(carry[292])，.a(a[292])，.b(b[292])，.c(c[292]))； xtfai293(.sum(sum[293])，.carry(carry[293])，.a(a[293])，.b(b[293])，.c(c[293]))； xtfai294(.sum(sum[294])，.carry(carry[294])，.a(a[294])，.b(b[294])，.c(c[294]))； xtfai295(.sum(sum[295])，.carry(carry[295])，.a(a[295])，.b(b[295])，.c(c[295]))；<dpn="d268"/> xtfai296(.sum(sum[296])，.carry(carry[296])，.a(a[296])，.b(b[296])，.c(c[296]))； xtfai297(.sum(sum[297])，.carry(carry[297])，.a(a[297])，.b(b[297])，.c(c[297]))； xtfai298(.sum(sum[298])，.carry(carry[298])，.a(a[298])，.b(b[298])，.c(c[298]))； xtfai299(.sum(sum[299])，.carry(carry[299])，.a(a[299])，.b(b[299])，.c(c[299]))； xtfai300(.sum(sum[300])，.carry(carry[300])，.a(a[300])，.b(b[300])，.c(c[300]))； xtfai301(.sum(sum[301])，.carry(carry[301])，.a(a[301])，.b(b[301])，.c(c[301]))； xtfai302(.sum(sum[302])，.carry(carry[302])，.a(a[302])，.b(b[302])，.c(c[302]))； xtfai303(.sum(sum[303])，.carry(carry[303])，.a(a[303])，.b(b[303])，.c(c[303]))； xtfai304(.sum(sum[304])，.carry(carry[304])，.a(a[304])，.b(b[304])，.c(c[304]))； xtfai305(.sum(sum[305])，.carry(carry[305])，.a(a[305])，.b(b[305])，.c(c[305]))； xtfai306(.sum(sum[306])，.carry(carry[306])，.a(a[306])，.b(b[306])，.c(c[306]))； xtfai307(.sum(sum[307])，.carry(carry[307])，.a(a[307])，.b(b[307])，.c(c[307]))； xtfai308(.sum(sum[308])，.carry(carry[308])，.a(a[308])，.b(b[308])，.c(c[308]))； xtfai309(.sum(sum[309])，.carry(carry[309])，.a(a[309])，.b(b[309])，.c(c[309]))； xtfai310(.sum(sum[310])，.carry(carry[310])，.a(a[310])，.b(b[310])，.c(c[310]))； xtfai311(.sum(sum[311])，.carry(carry[311])，.a(a[311])，.b(b[311])，.c(c[311]))； xtfai312(.sum(sum[312])，.carry(carry[312])，.a(a[312])，.b(b[312])，.c(c[312]))； xtfai313(.sum(sum[313])，.carry(carry[313])，.a(a[313])，.b(b[313])，.c(c[313]))； xtfai314(.sum(sum[314])，.carry(carry[314])，.a(a[314])，.b(b[314])，.c(c[314]))； xtfai315(.sum(sum[315])，.carry(carry[315])，.a(a[315])，.b(b[315])，.c(c[315]))； xtfai316(.sum(sum[316])，.carry(carry[316])，.a(a[316])，.b(b[316])，.c(c[316]))； xtfai317(.sum(sum[317])，.carry(carry[317])，.a(a[317])，.b(b[317])，.c(c[317]))； xtfai318(.sum(sum[318])，.carry(carry[318])，.a(a[318])，.b(b[318])，.c(c[318]))； xtfai319(.sum(sum[319])，.carry(carry[319])，.a(a[319])，.b(b[319])，.c(c[319]))； xtfai320(.sum(sum[320])，.carry(carry[320])，.a(a[320])，.b(b[320])，.c(c[320]))； xtfai321(.sum(sum[321])，.carry(carry[321])，.a(a[321])，.b(b[321])，.c(c[321]))； xtfai322(.sum(sum[322])，.carry(carry[322])，.a(a[322])，.b(b[322])，.c(c[322]))； xtfai323(.sum(sum[323])，.carry(carry[323])，.a(a[323])，.b(b[323])，.c(c[323]))； xtfai324(.sum(sum[324])，.carry(carry[324])，.a(a[324])，.b(b[324])，.c(c[324]))； xtfai325(.sum(sum[325])，.carry(carry[325])，.a(a[325])，.b(b[325])，.c(c[325]))；<dpn="d269"/> xtfai326(.sum(sum[326])，.carry(carry[326])，.a(a[326])，.b(b[326])，.c(c[326]))； xtfai327(.sum(sum[327])，.carry(carry[327])，.a(a[327])，.b(b[327])，.c(c[327]))； xtfai328(.sum(sum[328])，.carry(carry[328])，.a(a[328])，.b(b[328])，.c(c[328]))； xtfai329(.sum(sum[329])，.carry(carry[329])，.a(a[329])，.b(b[329])，.c(c[329]))； xtfai330(.sum(sum[330])，.carry(carry[330])，.a(a[330])，.b(b[330])，.c(c[330]))； xtfai331(.sum(sum[331])，.carry(carry[331])，.a(a[331])，.b(b[331])，.c(c[331]))； xtfai332(.sum(sum[332])，.carry(carry[332])，.a(a[332])，.b(b[332])，.c(c[332]))； xtfai333(.sum(sum[333])，.carry(carry[333])，.a(a[333])，.b(b[333])，.c(c[333]))； xtfai334(.sum(sum[334])，.carry(carry[334])，.a(a[334])，.b(b[334])，.c(c[334]))； xtfai335(.sum(sum[335])，.carry(carry[335])，.a(a[335])，.b(b[335])，.c(c[335]))； xtfai336(.sum(sum[336])，.carry(carry[336])，.a(a[336])，.b(b[336])，.c(c[336]))； xtfai337(.sum(sum[337])，.carry(carry[337])，.a(a[337])，.b(b[337])，.c(c[337]))； xtfai338(.sum(sum[338])，.carry(carry[338])，.a(a[338])，.b(b[338])，.c(c[338]))； xtfai339(.sum(sum[339])，.carry(carry[339])，.a(a[339])，.b(b[339])，.c(c[339]))； xtfai340(.sum(sum[340])，.carry(carry[340])，.a(a[340])，.b(b[340])，.c(c[340]))； xtfai341(.sum(sum[341])，.carry(carry[341])，.a(a[341])，.b(b[341])，.c(c[341]))； xtfai342(.sum(sum[342])，.carry(carry[342])，.a(a[342])，.b(b[342])，.c(c[342]))； xtfai343(.sum(sum[343])，.carry(carry[343])，.a(a[343])，.b(b[343])，.c(c[343]))； xtfai344(.sum(sum[344])，.carry(carry[344])，.a(a[344])，.b(b[344])，.c(c[344]))； xtfai345(.sum(sum[345])，.carry(carry[345])，.a(a[345])，.b(b[345])，.c(c[345]))； xtfai346(.sum(sum[346])，.carry(carry[346])，.a(a[346])，.b(b[346])，.c(c[346]))； xtfai347(.sum(sum[347])，.carry(carry[347])，.a(a[347])，.b(b[347])，.c(c[347]))； xtfai348(.sum(sum[348])，.carry(carry[348])，.a(a[348])，.b(b[348])，.c(c[348]))； xtfai349(.sum(sum[349])，.carry(carry[349])，.a(a[349])，.b(b[349])，.c(c[349]))； xtfai350(.sum(sum[350])，.carry(carry[350])，.a(a[350])，.b(b[350])，.c(c[350]))； xtfai351(.sum(sum[351])，.carry(carry[351])，.a(a[351])，.b(b[351])，.c(c[351]))； xtfai352(.sum(sum[352])，.carry(carry[352])，.a(a[352])，.b(b[352])，.c(c[352]))； xtfai353(.sum(sum[353])，.carry(carry[353])，.a(a[353])，.b(b[353])，.c(c[353]))； xtfai354(.sum(sum[354])，.carry(carry[354])，.a(a[354])，.b(b[354])，.c(c[354]))； xtfai355(.sum(sum[355])，.carry(carry[355])，.a(a[355])，.b(b[355])，.c(c[355]))；<dpn="d270"/> xtfai356(.sum(sum[356])，.carry(carry[356])，.a(a[356])，.b(b[356])，.c(c[356]))； xtfai357(.sum(sum[357])，.carry(carry[357])，.a(a[357])，.b(b[357])，.c(c[357]))； xtfai358(.sum(sum[358])，.carry(carry[358])，.a(a[358])，.b(b[358])，.c(c[358]))； xtfai359(.sum(sum[359])，.carry(carry[359])，.a(a[359])，.b(b[359])，.c(c[359]))； xtfai360(.sum(sum[360])，.carry(carry[360])，.a(a[360])，.b(b[360])，.c(c[360]))； xtfai361(.sum(sum[361])，.carry(carry[361])，.a(a[361])，.b(b[361])，.c(c[361]))； xtfai362(.sum(sum[362])，.carry(carry[362])，.a(a[362])，.b(b[362])，.c(c[362]))； xtfai363(.sum(sum[363])，.carry(carry[363])，.a(a[363])，.b(b[363])，.c(c[363]))； xtfai364(.sum(sum[364])，.carry(carry[364])，.a(a[364])，.b(b[364])，.c(c[364]))； xtfai365(.sum(sum[365])，.carry(carry[365])，.a(a[365])，.b(b[365])，.c(c[365]))； xtfai366(.sum(sum[366])，.carry(carry[366])，.a(a[366])，.b(b[366])，.c(c[366]))； xtfai367(.sum(sum[367])，.carry(carry[367])，.a(a[367])，.b(b[367])，.c(c[367]))； xtfai368(.sum(sum[368])，.carry(carry[368])，.a(a[368])，.b(b[368])，.c(c[368]))； xtfai369(.sum(sum[369])，.carry(carry[369])，.a(a[369])，.b(b[369])，.c(c[369]))； xtfai370(.sum(sum[370])，.carry(carry[370])，.a(a[370])，.b(b[370])，.c(c[370]))； xtfai371(.sum(sum[371])，.carry(carry[371])，.a(a[371])，.b(b[371])，.c(c[371]))； xtfai372(.sum(sum[372])，.carry(carry[372])，.a(a[372])，.b(b[372])，.c(c[372]))； xtfai373(.sum(sum[373])，.carry(carry[373])，.a(a[373])，.b(b[373])，.c(c[373]))； xtfai374(.sum(sum[374])，.carry(carry[374])，.a(a[374])，.b(b[374])，.c(c[374]))； xtfai375(.sum(sum[375])，.carry(carry[375])，.a(a[375])，.b(b[375])，.c(c[375]))； xtfai376(.sum(sum[376])，.carry(carry[376])，.a(a[376])，.b(b[376])，.c(c[376]))； xtfai377(.sum(sum[377])，.carry(carry[377])，.a(a[377])，.b(b[377])，.c(c[377]))； xtfai378(.sum(sum[378])，.carry(carry[378])，.a(a[378])，.b(b[378])，.c(c[378]))； xtfai379(.sum(sum[379])，.carry(carry[379])，.a(a[379])，.b(b[379])，.c(c[379]))； xtfai380(.sum(sum[380])，.carry(carry[380])，.a(a[380])，.b(b[380])，.c(c[380]))； xtfai381(.sum(sum[381])，.carry(carry[381])，.a(a[381])，.b(b[381])，.c(c[381]))； xtfai382(.sum(sum[382])，.carry(carry[382])，.a(a[382])，.b(b[382])，.c(c[382]))； xtfai383(.sum(sum[383])，.carry(carry[383])，.a(a[383])，.b(b[383])，.c(c[383]))； xtfai384(.sum(sum[384])，.carry(carry[384])，.a(a[384])，.b(b[384])，.c(c[384]))； xtfai385(.sum(sum[385])，.carry(carry[385])，.a(a[385])，.b(b[385])，.c(c[385]))；<dpn="d271"/> xtfai386(.sum(sum[386])，.carry(carry[386])，.a(a[386])，.b(b[386])，.c(c[386]))； xtfai387(.sum(sum[387])，.carry(carry[387])，.a(a[387])，.b(b[387])，.c(c[387]))； xtfai388(.sum(sum[388])，.carry(carry[388])，.a(a[388])，.b(b[388])，.c(c[388]))； xtfai389(.sum(sum[389])，.carry(carry[389])，.a(a[389])，.b(b[389])，.c(c[389]))； xtfai390(.sum(sum[390])，.carry(carry[390])，.a(a[390])，.b(b[390])，.c(c[390]))； xtfai391(.sum(sum[391])，.carry(carry[391])，.a(a[391])，.b(b[391])，.c(c[391]))； xtfai392(.sum(sum[392])，.carry(carry[392])，.a(a[392])，.b(b[392])，.c(c[392]))； xtfai393(.sum(sum[393])，.carry(carry[393])，.a(a[393])，.b(b[393])，.c(c[393]))； xtfai394(.sum(sum[394])，.carry(carry[394])，.a(a[394])，.b(b[394])，.c(c[394]))； xtfai395(.sum(sum[395])，.carry(carry[395])，.a(a[395])，.b(b[395])，.c(c[395]))； xtfai396(.sum(sum[396])，.carry(carry[396])，.a(a[396])，.b(b[396])，.c(c[396]))； xtfai397(.sum(sum[397])，.carry(carry[397])，.a(a[397])，.b(b[397])，.c(c[397]))； xtfai398(.sum(sum[398])，.carry(carry[398])，.a(a[398])，.b(b[398])，.c(c[398]))； xtfai399(.sum(sum[399])，.carry(carry[399])，.a(a[399])，.b(b[399])，.c(c[399]))； xtfai400(.sum(sum[400])，.carry(carry[400])，.a(a[400])，.b(b[400])，.c(c[400]))； xtfai401(.sum(sum[401])，.carry(carry[401])，.a(a[401])，.b(b[401])，.c(c[401]))； xtfai402(.sum(sum[402])，.carry(carry[402])，.a(a[402])，.b(b[402])，.c(c[402]))； xtfai403(.sum(sum[403])，.carry(carry[403])，.a(a[403])，.b(b[403])，.c(c[403]))； xtfai404(.sum(sum[404])，.carry(carry[404])，.a(a[404])，.b(b[404])，.c(c[404]))； xtfai405(.sum(sum[405])，.carry(carry[405])，.a(a[405])，.b(b[405])，.c(c[405]))； xtfai406(.sum(sum[406])，.carry(carry[406])，.a(a[406])，.b(b[406])，.c(c[406])))； xtfai407(.sum(sum[407])，.carry(carry[407])，.a(a[407])，.b(b[407])，.c(c[407]))； xtfai408(.sum(sum[408])，.carry(carry[408])，.a(a[408])，.b(b[408])，.c(c[408]))； xtfai409(.sum(sum[409])，.carry(carry[409])，.a(a[409])，.b(b[409])，.c(c[409]))； xtfai410(.sum(sum[410])，.carry(carry[410])，.a(a[410])，.b(b[410])，.c(c[410]))； xtfai411(.sum(sum[411])，.carry(carry[411])，.a(a[411])，.b(b[411])，.c(c[411]))； xtfai412(.sum(sum[412])，.carry(carry[412])，.a(a[412])，.b(b[412])，.c(c[412]))； xtfai413(.sum(sum[413])，.carry(carry[413])，.a(a[413])，.b(b[413])，.c(c[413]))； xtfai414(.sum(sum[414])，.carry(carry[414])，.a(a[414])，.b(b[414])，.c(c[414]))； xtfai415(.sum(sum[415])，.carry(carry[415])，.a(a[415])，.b(b[415])，.c(c[415]))；<dpn="d272"/> xtfai416(.sum(sum[416])，.carry(carry[416])，.a(a[416])，.b(b[416])，.c(c[416]))； xtfai417(.sum(sum[417])，.carry(carry[417])，.a(a[417])，.b(b[417])，.c(c[417]))； xtfai418(.sum(sum[418])，.carry(carry[418])，.a(a[418])，.b(b[418])，.c(c[418]))； xtfai419(.sum(sum[419])，.carry(carry[419])，.a(a[419])，.b(b[419])，.c(c[419]))； xtfai420(.sum(sum[420])，.carry(carry[420])，.a(a[420])，.b(b[420])，.c(c[420]))； xtfai421(.sum(sum[421])，.carry(carry[421])，.a(a[421])，.b(b[421])，.c(c[421]))； xtfai422(.sum(sum[422])，.carry(carry[422])，.a(a[422])，.b(b[422])，.c(c[422]))； xtfai423(.sum(sum[423])，.carry(carry[423])，.a(a[423])，.b(b[423])，.c(c[423]))； xtfai424(.sum(sum[424])，.carry(carry[424])，.a(a[424])，.b(b[424])，.c(c[424]))； xtfai425(.sum(sum[425])，.carry(carry[425])，.a(a[425])，.b(b[425])，.c(c[425]))； xtfai426(.sum(sum[426])，.carry(carry[426])，.a(a[426])，.b(b[426])，.c(c[426]))； xtfai427(.sum(sum[427])，.carry(carry[427])，.a(a[427])，.b(b[427])，.c(c[427]))； xtfai428(.sum(sum[428])，.carry(carry[428])，.a(a[428])，.b(b[428])，.c(c[428])) xtfai429(.sum(sum[429])，.carry(carry[429])，.a(a[429])，.b(b[429])，.c(c[429]))； xtfai430(.sum(sum[430])，.carry(carry[430])，.a(a[430])，.b(b[430])，.c(c[430]))； xtfai431(.sum(sum[431])，.carry(carry[431])，.a(a[431])，.b(b[431])，.c(c[431]))； xtfai432(.sum(sum[432])，.carry(carry[432])，.a(a[432])，.b(b[432])，.c(c[432]))； xtfai433(.sum(sum[433])，.carry(carry[433])，.a(a[433])，.b(b[433])，.c(c[433]))； xtfai434(.sum(sum[434])，.carry(carry[434])，.a(a[434])，.b(b[434])，.c(c[434]))； xtfai435(.sum(sum[435])，.carry(carry[435])，.a(a[435])，.b(b[435])，.c(c[435]))； xtfai436(.sum(sum[436])，.carry(carry[436])，.a(a[436])，.b(b[436])，.c(c[436]))； xtfai437(.sum(sum[437])，.carry(carry[437])，.a(a[437])，.b(b[437])，.c(c[437]))； xtfai438(.sum(sum[438])，.carry(carry[438])，.a(a[438])，.b(b[438])，.c(c[438]))； xtfai439(.sum(sum[439])，.carry(carry[439])，.a(a[439])，.b(b[439])，.c(c[439]))； xtfai440(.sum(sum[440])，.carry(carry[440])，.a(a[440])，.b(b[440])，.c(c[440]))； xtfai441(.sum(sum[441])，.carry(carry[441])，.a(a[441])，.b(b[441])，.c(c[441]))； xtfai442(.sum(sum[442])，.carry(carry[442])，.a(a[442])，.b(b[442])，.c(c[442]))； xtfai443(.sum(sum[443])，.carry(carry[443])，.a(a[443])，.b(b[443])，.c(c[443]))； xtfai444(.sum(sum[444])，.carry(carry[444])，.a(a[444])，.b(b[444])，.c(c[444]))； xtfai445(.sum(sum[445])，.carry(carry[445])，.a(a[445])，.b(b[445])，.c(c[445]))；<dpn="d273"/> xtfai446(.sum(sum[446])，.carry(carry[446])，.a(a[446])，.b(b[446])，.c(c[446]))； xtfai447(.sum(sum[447])，.carry(carry[447])，.a(a[447])，.b(b[447])，.c(c[447]))； xtfai448(.sum(sum[448])，.carry(carry[448])，.a(a[448])，.b(b[448])，.c(c[448]))； xtfai449(.sum(sum[449])，.carry(carry[449])，.a(a[449])，.b(b[449])，.c(c[449]))； xtfai450(.sum(sum[450])，.carry(carry[450])，.a(a[450])，.b(b[450])，.c(c[450]))； xtfai451(.sum(sum[451])，.carry(carry[451])，.a(a[451])，.b(b[451])，.c(c[451]))； xtfai452(.sum(sum[452])，.carry(carry[452])，.a(a[452])，.b(b[452])，.c(c[452]))； xtfai453(.sum(sum[453])，.carry(carry[453])，.a(a[453])，.b(b[453])，.c(c[453]))； xtfai454(.sum(sum[454])，.carry(carry[454])，.a(a[454])，.b(b[454])，.c(c[454]))； xtfai455(.sum(sum[455])，.carry(carry[455])，.a(a[455])，.b(b[455])，.c(c[455]))； xtfai456(.sum(sum[456])，.carry(carry[456])，.a(a[456])，.b(b[456])，.c(c[456]))； xtfai457(.sum(sum[457])，.carry(carry[457])，.a(a[457])，.b(b[457])，.c(c[457]))； xtfai458(.sum(sum[458])，.carry(carry[458])，.a(a[458])，.b(b[458])，.c(c[458]))； xtfai459(.sum(sum[459])，.carry(carry[459])，.a(a[459])，.b(b[459])，.c(c[459]))； xtfai460(.sum(sum[460])，.carry(carry[460])，.a(a[460])，.b(b[460])，.c(c[460]))； xtfai461(.sum(sum[461])，.carry(carry[461])，.a(a[461])，.b(b[461])，.c(c[461]))； xtfai462(.sum(sum[462])，.carry(carry[462])，.a(a[462])，.b(b[462])，.c(c[462]))； xtfai463(.sum(sum[463])，.carry(carry[463])，.a(a[463])，.b(b[463])，.c(c[463]))； xtfai464(.sum(sum[464])，.carry(carry[464])，.a(a[464])，.b(b[464])，.c(c[464]))； xtfai465(.sum(sum[465])，.carry(carry[465])，.a(a[465])，.b(b[465])，.c(c[465]))； xtfai466(.sum(sum[466])，.carry(carry[466])，.a(a[466])，.b(b[466])，.c(c[466]))； xtfai467(.sum(sum[467])，.carry(carry[467])，.a(a[467])，.b(b[467])，.c(c[467]))； xtfai468(.sum(sum[468])，.carry(carry[468])，.a(a[468])，.b(b[468])，.c(c[468]))； xtfai469(.sum(sum[469])，.carry(carry[469])，.a(a[469])，.b(b[469])，.c(c[469]))； xtfai470(.sum(sum[470])，.carry(carry[470])，.a(a[470])，.b(b[470])，.c(c[470]))； xtfai471(.sum(sum[471])，.carry(carry[471])，.a(a[471])，.b(b[471])，.c(c[471]))； xtfai472(.sum(sum[472])，.carry(carry[472])，.a(a[472])，.b(b[472])，.c(c[472]))； xtfai473(.sum(sum[473])，.carry(carry[473])，.a(a[473])，.b(b[473])，.c(c[473]))； xtfai474(.sum(sum[474])，.carry(carry[474])，.a(a[474])，.b(b[474])，.c(c[474]))； xtfai475(.sum(sum[475])，.carry(carry[475])，.a(a[475])，.b(b[475])，.c(c[475]))；<dpn="d274"/> xtfai476(.sum(sum[476])，.carry(carry[476])，.a(a[476])，.b(b[476])，.c(c[476]))； xtfai477(.sum(sum[477])，.carry(carry[477])，.a(a[477])，.b(b[477]，.c(c[477]))； xtfai478(.sum(sum[478])，.carry(carry[478])，.a(a[478])，.b(b[478])，.c(c[478]))； xtfai479(.sum(sum[479])，.carry(carry[479])，.a(a[479])，.b(b[479])，.c(c[479]))； xtfai480(.sum(sum[480])，.carry(carry[480])，.a(a[480])，.b(b[480])，.c(c[480]))； xtfai481(.sum(sum[481])，.carry(carry[481])，.a(a[481])，.b(b[481])，.c(c[481]))； xtfai482(.sum(sum[482])，.carry(carry[482])，.a(a[482])，.b(b[482])，.c(c[482]))； xtfai483(.sum(sum[483])，.carry(carry[483])，.a(a[483])，.b(b[483])，.c(c[483]))； xtfai484(.sum(sum[484])，.carry(carry[484])，.a(a[484])，.b(b[484])，.c(c[484]))； xtfai485(.sum(sum[485])，.carry(carry[485])，.a(a[485])，.b(b[485])，.c(c[485]))； xtfai486(.sum(sum[486])，.carry(carry[486])，.a(a[486])，.b(b[486])，.c(c[486]))； xtfai487(.sum(sum[487])，.carry(carry[487])，.a(a[487])，.b(b[487])，.c(c[487]))； xtfai488(.sum(sum[488])，.carry(carry[488])，.a(a[488])，.b(b[488])，.c(c[488]))； xtfai489(.sum(sum[489])，.carry(carry[489])，.a(a[489])，.b(b[489])，.c(c[489]))； xtfai490(.sum(sum[490])，.carry(carry[490])，.a(a[490])，.b(b[490])，.c(c[490]))； xtfai491(.sum(sum[491])，.carry(carry[491])，.a(a[491])，.b(b[491])，.c(c[491]))； xtfai492(.sum(sum[492])，.carry(carry[492])，.a(a[492])，.b(b[492])，.c(c[492]))； xtfai493(.sum(sum[493])，.carry(carry[493])，.a(a[493])，.b(b[493])，.c(c[493]))； xtfai494(.sum(sum[494])，.carry(carry[494])，.a(a[494])，.b(b[494])，.c(c[494]))； xtfai495(.sum(sum[495])，.carry(carry[495])，.a(a[495])，.b(b[495])，.c(c[495]))； xtfai496(.sum(sum[496])，.carry(carry[496])，.a(a[496])，.b(b[496])，.c(c[496]))； xtfai497(.sum(sum[497])，.carry(carry[497])，.a(a[497])，.b(b[497])，.c(c[497]))； xtfai498(.sum(sum[498])，.carry(carry[498])，.a(a[498])，.b(b[498])，.c(c[498]))； xtfai499(.sum(sum[499])，.carry(carry[499])，.a(a[499])，.b(b[499])，.c(c[499]))； xtfai500(.sum(sum[500])，.carry(carry[500])，.a(a[500])，.b(b[500])，.c(c[500]))； xtfai501(.sum(sum[501])，.carry(carry[501])，.a(a[501])，.b(b[501])，.c(c[501]))； xtfai502(.sum(sum[502])，.carry(carry[502])，.a(a[502])，.b(b[502])，.c(c[502]))； xtfai503(.sum(sum[503])，.carry(carry[503])，.a(a[503])，.b(b[503])，.c(c[503]))； xtfai504(.sum(sum[504])，.carry(carry[504])，.a(a[504])，.b(b[504])，.c(c[504]))； xtfai505(.sum(sum[505])，.carry(carry[505])，.a(a[505])，.b(b[505])，.c(c[505]))；<dpn="d275"/> xtfai506(.sum(sum[506])，.carry(carry[506])，.a(a[506])，.b(b[506])，.c(c[506]))； xtfai507(.sum(sum[507])，.carry(carry[507])，.a(a[507])，.b(b[507])，.c(c[507]))； xtfai508(.sum(sum[508])，.carry(carry[508])，.a(a[508])，.b(b[508])，.c(c[508]))； xtfai509(.sum(sum[509])，.carry(carry[509])，.a(a[509])，.b(b[509])，.c(c[509]))； xtfai510(.sum(sum[510])，.carry(carry[510])，.a(a[510])，.b(b[510])，.c(c[510]))； xtfai511(.sum(sum[511])，.carry(carry[511])，.a(a[511])，.b(b[511])，.c(c[511]))； xtfai512(.sum(sum[512])，.carry(carry[512])，.a(a[512])，.b(b[512])，.c(c[512]))； xtfai513(.sum(sum[513])，.carry(carry[513])，.a(a[513])，.b(b[513])，.c(c[513]))； xtfai514(.sum(sum[514])，.carry(carry[514])，.a(a[514])，.b(b[514])，.c(c[514]))； xtfai515(.sum(sum[515])，.carry(carry[515])，.a(a[515])，.b(b[515])，.c(c[515]))； xtfai516(.sum(sum[516])，.carry(carry[516])，.a(a[5i6])，.b(b[516])，.c(c[516]))； xtfai517(.sum(sum[517])，.carry(carry[517])，.a(a[517])，.b(b[517])，.c(c[517]))； xtfai518(.sum(sum[518])，.carry(carry[518])，.a(a[518])，.b(b[518])，.c(c[518]))； xtfai519(.sum(sum[519])，.carry(carry[519])，.a(a[519])，.b(b[519])，.c(c[519]))； xtfai520(.sum(sum[520])，.carry(carry[520])，.a(a[520])，.b(b[520])，.c(c[520]))； xtfai521(.sum(sum[521])，.carry(carry[521])，.a(a[521])，.b(b[521])，.c(c[521]))； xtfai522(.sum(sum[522])，.carry(carry[522])，.a(a[522])，.b(b[522])，.c(c[522]))； xtfai523(.sum(sum[523])，.carry(carry[523])，.a(a[523])，.b(b[523])，.c(c[523]))； xtfai524(.sum(sum[524])，.carry(carry[524])，.a(a[524])，.b(b[524])，.c(c[524]))； xtfai525(.sum(sum[525])，.carry(carry[525])，.a(a[525])，.b(b[525])，.c(c[525]))； xtfai526(.sum(sum[526])，.carry(carry[526])，.a(a[526])，.b(b[526])，.c(c[526]))； xtfai527(.sum(sum[527])，.carry(carry[527])，.a(a[527])，.b(b[527])，.c(c[527]))； xtfai528(.sum(sum[528])，.carry(carry[528])，.a(a[528])，.b(b[528])，.c(c[528]))； xtfai529(.sum(sum[529])，.carry(carry[529])，.a(a[529])，.b(b[529])，.c(c[529]))； xtfai530(.sum(sum[530])，.carry(carry[530])，.a(a[530])，.b(b[530])，.c(c[530]))； xtfai531(.sum(sum[531])，.carry(carry[531])，.a(a[531])，.b(b[531])，.c(c[531]))； xtfai532(.sum(sum[532])，.carry(carry[532])，.a(a[532])，.b(b[532])，.c(c[532]))； xtfai533(.sum(sum[533])，.carry(carry[533])，.a(a[533])，.b(b[533])，.c(c[533]))； xtfai534(.sum(sum[534])，.carry(carry[534])，.a(a[534])，.b(b[534])，.c(c[534]))； xtfai535(.sum(sum[535])，.carry(carry[535])，.a(a[535])，.b(b[535])，.c(c[535]))；<dpn="d276"/> xtfai536(.sum(sum[536])，.carry(carry[536])，.a(a[536])，.b(b[536])，.c(c[536]))； xtfai537(.sum(sum[537])，.carry(carry[537])，.a(a(537])，.b(b[537])，.c(c[537]))； xtfai538(.sum(sum[538])，.carry(carry[538])，.a(a[538])，.b(b[538])，.c(c[538]))； xtfai539(.sum(sum[539])，.carry(carry[539])，.a(a[539])，.b(b[539])，.c(c[539]))； xtfai540(.sum(sum[540])，.carry(carry[540])，.a(a[540])，.b(b[540])，.c(c[540]))； xtfai541(.sum(sum[541])，.carry(carry[541])，.a(a[541])，.b(b[541])，.c(c[541]))； xtfai542(.sum(sum[542])，.carry(carry[542])，.a(a[542])，.b(b[542])，.c(c[542]))； xtfai543(.sum(sum[543])，.carry(carry[543])，.a(a[543])，.b(b[543])，.c(c[543]))； xtfai544(.sum(sum[544])，.carry(carry[544])，.a(a[544])，.b(b[544])，.c(c[544]))； xtfai545(.sum(sum[545])，.carry(carry[545])，.a(a[545])，.b(b[545])，.c(c[545]))； xtfai546(.sum(sum[546])，.carry(carry[546])，.a(a[546])，.b(b[546])，.c(c[546]))； xtfai547(.sum(sum[547])，.carry(carry[547])，.a(a[547])，.b(b[547])，.c(c[547]))； xtfai548(.sum(sum[548])，.carry(carry[548])，.a(a[548])，.b(b[548])，.c(c[548]))； xtfai549(.sum(sum[549])，.carry(carry[549])，.a(a[549])，.b(b[549])，.c(c[549]))； xtfai550(.sum(sum[550])，.carry(carry[550])，.a(a[550])，.b(b[550])，.c(c[550]))； xtfai551(.sum(sum[551])，.carry(carry[551])，.a(a[551])，.b(b[551])，.c(c[551]))； xtfai552(.sum(sum[552])，.carry(carry[552])，.a(a[552])，.b(b[552])，.c(c[552]))； xtfai553(.sum(sum[553])，.carry(carry[553])，.a(a[553])，.b(b[553])，.c(c[553]))； xtfai554(.sum(sum[554])，.carry(carry[554])，.a(a[554])，.b(b[554])，.c(c[554]))； xtfai555(.sum(sum[555])，.carry(carry[555])，.a(a[555])，.b(b[555])，.c(c[555]))； xtfai556(.sum(sum[556])，.carry(carry[556])，.a(a[556])，.b(b[556])，.c(c[556]))； xtfai557(.sum(sum[557])，.carry(carry[557])，.a(a[557])，.b(b[557])，.c(c[557]))； xtfai558(.sum(sum[558])，.carry(carry[558])，.a(a[558])，.b(b[558])，.c(c[558]))； xtfai559(.sum(sum[559])，.carry(carry[559])，.a(a[559])，.b(b[559])，.c(c[559]))； xtfai560(.sum(sum[560])，.carry(carry[560])，.a(a[560])，.b(b[560])，.c(c[560]))； xtfai561(.sum(sum[561])，.carry(carry[561])，.a(a[561])，.b(b[561])，.c(c[561]))； xtfai562(.sum(sum[562])，.carry(carry[562])，.a(a[562])，.b(b[562])，.c(c[562]))； xtfai563(.sum(sum[563])，.carry(carry[563])，.a(a[563])，.b(b[563])，.c(c[563]))； xtfai564(.sum(sum[564])，.carry(carry[564])，.a(a[564])，.b(b[564])，.c(c[564]))； xtfai565(.sum(sum[565])，.carry(carry[565])，.a(a[565])，.b(b[565])，.c(c[565]))；<dpn="d277"/> xtfai566(.sum(sum[566])，.carry(carry[566])，.a(a[566])，.b(b[566])，.c(c[566]))； xtfai567(.sum(sum[567])，.carry(carry[567])，.a(a[567])，.b(b[567])，.c(c[567]))； xtfai568(.sum(sum[568])，.carry(carry[568])，.a(a[568])，.b(b[568])，.c(c[568]))； xtfai569(.sum(sum[569])，.carry(carry[569])，.a(a[569])，.b(b[569])，.c(c[569]))； xtfai570(.sum(sum[570])，.carry(carry[570])，.a(a[570])，.b(b[570])，.c(c[570]))； xtfai571(.sum(sum[571])，.carry(carry[571])，.a(a[571])，.b(b[571])，.c(c[571]))； xtfai572(.sum(sum[572])，.carry(carry[572])，.a(a[572])，.b(b[572])，.c(c[572]))； xtfai573(.sum(sum[573])，.carry(carry[573])，.a(a[573])，.b(b[573])，.c(c[573]))； xtfai574(.sum(sum[574])，.carry(carry[574])，.a(a[574])，.b(b[574])，.c(c[574]))； xtfai575(.sum(sum[575])，.carry(carry[575])，.a(a[575])，.b(b[575])，.c(c[575]))； xtfai576(.sum(sum[576])，.carry(carry[576])，.a(a[576])，.b(b[576])，.c(c[576]))； xtfai577(.sum(sum[577])，.carry(carry[577])，.a(a[577])，.b(b[577])，.c(c[577]))； xtfai578(.sum(sum[578])，.carry(carry[578])，.a(a[578])，.b(b[578])，.c(c[578]))； xtfai579(.sum(sum[579])，.carry(carry[579])，.a(a[579])，.b(b[579])，.c(c[579]))； xtfai580(.sum(sum[580])，.carry(carry[580])，.a(a[580])，.b(b[580])，.c(c[580]))； xtfai581(.sum(sum[581])，.carry(carry[581])，.a(a[581])，.b(b[581])，.c(c[581]))； xtfai582(.sum(sum[582])，.carry(carry[582])，.a(a[582])，.b(b[582])，.c(c[582]))； xtfai583(.sum(sum[583])，.carry(carry[583])，.a(a[583])，.b(b[583])，.c(c[583]))； xtfai584(.sum(sum[584])，.carry(carry[584])，.a(a[584])，.b(b[584])，.c(c[584]))； xtfai585(.sum(sum[585])，.carry(carry[585])，.a(a[585])，.b(b[585])，.c(c[585]))； xtfai586(.sum(sum[586])，.carry(carry[586])，.a(a[586])，.b(b[586])，.c(c[586]))； xtfai587(.sum(sum[587])，.carry(carry[587])，.a(a[587])，.b(b[587])，.c(c[587]))； xtfai588(.sum(sum[588])，.carry(carry[588])，.a(a[588])，.b(b[588])，.c(c[588]))； xtfai589(.sum(sum[589])，.carry(carry[589])，.a(a[589])，.b(b[589])，.c(c[589]))； xtfai590(.sum(sum[590])，.carry(carry[590])，.a(a[590])，.b(b[590])，.c(c[590]))； xtfai591(.sum(sum[591])，.carry(carry[591])，.a(a[591])，.b(b[591])，.c(c[591]))； xtfai592(.sum(sum[592])，.carry(carry[592])，.a(a[592])，.b(b[592])，.c(c[592]))； xtfai593(.sum(sum[593])，.carry(carry[593])，.a(a[593])，.b(b[593])，.c(c[593]))； xtfai594(.sum(sum[594])，.carry(carry[594])，.a(a[594])，.b(b[594])，.c(c[594]))； xtfai595(.sum(sum[595])，.carry(carry[595])，.a(a[595])，.b(b[595])，.c(c[595]))；<dpn="d278"/> xtfai596(.sum(sum[596])，.carry(carry[596])，.a(a[596])，.b(b[596])，.c(c[596]))； xtfai597(.sum(sum[597])，.carry(carry[597])，.a(a[597])，.b(b[597])，.c(c[597]))； xtfai598(.sum(sum[598])，.carry(carry[598])，.a(a[598])，.b(b[598])，.c(c[598]))； xtfai599(.sum(sum[599])，.carry(carry[599])，.a(a[599])，.b(b[599])，.c(c[599]))； xtfai600(.sum(sum[600])，.carry(carry[600])，.a(a[600])，.b(b[600])，.c(c[600]))； xtfai601(.sum(sum[601])，.carry(carry[601])，.a(a[601])，.b(b[601])，.c(c[601]))； xtfai602(.sum(sum[602])，.carry(carry[602])，.a(a[602])，.b(b[602])，.c(c[602]))； xtfai603(.sum(sum[603])，.carry(carry[603])，.a(a[603])，.b(b[603])，.c(c[603]))； xtfai604(.sum(sum[604])，.carry(carry[604])，.a(a[604])，.b(b[604])，.c(c[604]))； xtfai605(.sum(sum[605])，.carry(carry[605])，.a(a[605])，.b(b[605])，.c(c[605]))； xtfai606(.sum(sum[606])，.carry(carry[606])，.a(a[606])，.b(b[606])，.c(c[606]))； xtfai607(.sum(sum[607])，.carry(carry[607])，.a(a[607])，.b(b[607])，.c(c[607]))； xtfai608(.sum(sum[608])，.carry(carry[608])，.a(a[608])，.b(b[608])，.c(c[608]))； xtfai609(.sum(sum[609])，.carry(carry[609])，.a(a[609])，.b(b[609])，.c(c[609]))； xtfai610(.sum(sum[610])，.carry(carry[610])，.a(a[610])，.b(b[610])，.c(c[610]))； xtfai611(.sum(sum[611])，.carry(carry[611])，.a(a[611])，.b(b[611])，.c(c[611]))； xtfai612(.sum(sum[612])，.carry(carry[612])，.a(a[612])，.b(b[612])，.c(c[612]))； xtfai613(.sum(sum[613])，.carry(carry[613])，.a(a[613])，.b(b[613])，.c(c[613]))； xtfai614(.sum(sum[614])，.carry(carry[614])，.a(a[614])，.b(b[614])，.c(c[614]))； xtfai615(.sum(sum[615])，.carry(carry[615])，.a(a[615])，.b(b[615])，.c(c[615]))； xtfai616(.sum(sum[616])，.carry(carry[616])，.a(a[616])，.b(b[616])，.c(c[616]))； xtfai617(.sum(sum[617])，.carry(carry[617])，.a(a[617])，.b(b[617])，.c(c[617]))； xtfai618(.sum(sum[618])，.carry(carry[618])，.a(a[618])，.b(b[618])，.c(c[618]))； xtfai619(.sum(sum[619])，.carry(carry[619])，.a(a[619])，.b(b[619])，.c(c[619]))； xtfai620(.sum(sum[620])，.carry(carry[620])，.a(a[620])，.b(b[620])，.c(c[620]))； xtfai621(.sum(sum[621])，.carry(carry[621])，.a(a[621])，.b(b[621])，.c(c[621]))； xtfai622(.8um(sum[622])，.carry(carry[622])，.a(a[622])，.b(b[622])，.c(c[622]))； xtfai623(.sum(sum[623])，.carry(carry[623])，.a(a[623])，.b(b[623])，.c(c[623]))； xtfai624(.sum(sum[624])，.carry(carry[624])，.a(a[624])，.b(b[624])，.c(c[624]))； xtfai625(.sum(sum[625])，.carry(carry[625])，.a(a[625])，.b(b[625])，.c(c[625]))；<dpn="d279"/> xtfai626(.sum(sum[626])，.carry(carry[626])，.a(a[626])，.b(b[626])，.c(c[626]))； xtfai627(.sum(sum[627])，.carry(carry[627])，.a(a[627])，.b(b[627])，.c(c[627]))； xtfai628(.sum(sum[628])，.carry(carry[628])，.a(a[628])，.b(b[628])，.c(c[628]))； xtfai629(.sum(sum[629])，.carry(carry[629])，.a(a[629])，.b(b[629]，.c(c[629]))； xtfai630(.sum(sum[630])，.carry(carry[630])，.a(a[630])，.b(b[630])，.c(c[630]))； xtfai631(.sum(sum[631])，.carry(carry[631])，.a(a[631])，.b(b[631])，.c(c[631]))； xtfai632(.sum(sum[632])，.carry(carry[632])，.a(a[632])，.b(b[632])，.c(c[632]))； xtfai633(.sum(sum[633])，.carry(carry[633])，.a(a[633])，.b(b[633])，.c(c[633]))； xtfai634(.sum(sum[634])，.carry(carry[634])，.a(a[634])，.b(b[634])，.c(c[634]))； xtfai635(.sum(sum[635])，.carry(carry[635])，.a(a[635])，.b(b[635])，.c(c[635]))； xtfai636(.sum(sum[636])，.carry(carry[636])，.a(a[636])，.b(b[636])，.c(c[636]))； xtfai637(.sum(sum[637])，.carry(carry[637])，.a(a[637])，.b(b[637])，.c(c[637]))； xtfai638(.sum(sum[638])，.carry(carry[638])，.a(a[638])，.b(b[638])，.c(c[638]))； xtfai639(.sum(sum[639])，.carry(carry[639])，.a(a[639])，.b(b[639])，.c(c[639]))； xtfai640(.sum(sum[640])，.carry(carry[640])，.a(a[640])，.b(b[640])，.c(c[640]))； xtfai641(.sum(sum[641])，.carry(carry[641])，.a(a[641])，.b(b[641])，.c(c[641]))； xtfai642(.sum(sum[642])，.carry(carry[642])，.a(a[642])，.b(b[642])，.c(c[642]))； xtfai643(.sum(sum[643])，.carry(carry[643])，.a(a[643])，.b(b[643])，.c(c[643]))； xtfai644(.sum(sum[644])，.carry(carry[644])，.a(a[644])，.b(b[644])，.c(c[644]))； xtfai645(.sum(sum[645])，.carry(carry[645])，.a(a[645])，.b(b[645])，.c(c[645]))； xtfai646(.sum(sum[646])，.carry(carry[646])，.a(a[646])，.b(b[646])，.c(c[646]))； xtfai647(.sum(sum[647])，.carry(carry[647])，.a(a[647])，.b(b[647])，.c(c[647]))； xtfai648(.sum(sum[648])，.carry(carry[648])，.a(a[648])，.b(b[648])，.c(c[648]))； xtfai649(.sum(sum[649])，.carry(carry[649])，.a(a[649])，.b(b[649])，.c(c[649]))； xtfai650(.sum(sum[650])，.carry(carry[650])，.a(a[650])，.b(b[650])，.c(c[650]))； xtfai651(.sum(sum[651])，.carry(carry[651])，.a(a[651])，.b(b[651])，.c(c[651]))； xtfai652(.sum(sum[652])，.carry(carry[652])，.a(a[652])，.b(b[652])，.c(c[652]))； xtfai653(.sum(sum[653])，.carry(carry[653])，.a(a[653])，.b(b[653])，.c(c[653]))； xtfai654(.sum(sum[654])，.carry(carry[654])，.a(a[654])，.b(b[654])，.c(c[654]))； xtfai655(.sum(sum[655])，.carry(carry[655])，.a(a[655])，.b(b[655])，.c(c[655]))；<dpn="d280"/> xtfai656(.sum(sum[656])，.carry(carry[656])，.a(a[656])，.b(b[656])，.c(c[656]))； xtfai657(.sum(sum[657])，.carry(carry[657])，.a(a[657])，.b(b[657])，.c(c[657]))； xtfai658(.sum(sum[658])，.carry(carry[658])，.a(a[658])，.b(b[658])，.c(c[658]))； xtfai659(.sum(sum[659])，.carry(carry[659])，.a(a[659])，.b(b[659])，.c(c[659]))； xtfai660(.sum(sum[660])，.carry(carry[660])，.a(a[660])，.b(b[660])，.c(c[660]))； xtfai661(.sum(sum[661])，.carry(carry[661])，.a(a[661])，.b(b[661])，.c(c[661]))； xtfai662(.sum(sum[662])，.carry(carry[662])，.a(a[662])，.b(b[662])，.c(c[662]))； xtfai663(.sum(sum[663])，.carry(carry[663])，.a(a[663])，.b(b[663])，.c(c[663]))； xtfai664(.sum(sum[664])，.carry(carry[664])，.a(a[664])，.b(b[664])，.c(c[664]))； xtfai665(.sum(sum[665])，.carry(carry[665])，.a(a[665])，.b(b[665])，.c(c[665]))； xtfai666(.sum(sum[666])，.carry(carry[666])，.a(a[666])，.b(b[666])，.c(c[666]))； xtfai667(.sum(sum[667])，.carry(carry[667])，.a(a[667])，.b(b[667])，.c(c[667]))； xtfai668(.sum(sum[668])，.carry(carry[668])，.a(a[668])，.b(b[668])，.c(c[668]))； xtfai669(.sum(sum[669])，.carry(carry[669])，.a(a[669])，.b(b[669])，.c(c[669]))； xtfai670(.sum(sum[670])，.carry(carry[670])，.a(a[670])，.b(b[670])，.c(c[670]))； xtfai671(.sum(sum[671])，.carry(carry[671])，.a(a[671])，.b(b[671])，.c(c[671]))； xtfai672(.sum(sum[672])，.carry(carry[672])，.a(a[672])，.b(b[672])，.c(c[672]))； xtfai673(.sum(sum[673])，.carry(carry[673])，.a(a[673])，.b(b[673])，.c(c[673]))； xtfai674(.sum(sum[674])，.carry(carry[674])，.a(a[674])，.b(b[674])，.c(c[674]))； xtfai675(.sum(sum[675])，.carry(carry[675])，.a(a[675])，.b(b[675])，.c(c[675]))； xtfai676(.sum(sum[676])，.carry(carry[676])，.a(a[676])，.b(b[676])，.c(c[676]))； xtfai677(.sum(sum[677])，.carry(carry[677])，.a(a[677])，.b(b[677])，.c(c[677]))； xtfai678(.sum(sum[678])，.carry(carry[678])，.a(a[678])，.b(b[678])，.c(c[678]))； xtfai679(.sum(sum[679])，.carry(carry[679])，.a(a[679])，.b(b[679])，.c(c[679]))； xtfai680(.sum(sum[680])，.carry(carry[680])，.a(a[680])，.b(b[680])，.c(c[680]))； xtfai681(.sum(sum[681])，.carry(carry[681])，.a(a[681])，.b(b[681])，.c(c[681]))； xtfai682(.sum(sum[682])，.carry(carry[682])，.a(a[682])，.b(b[682])，.c(c[682]))； xtfai683(.sum(sum[683])，.carry(carry[683])，.a(a[683])，.b(b[683])，.c(c[683]))； xtfai684(.sum(sum[684])，.carry(carry[684])，.a(a[684])，.b(b[684])，.c(c[684]))； xtfai685(.sum(sum[685])，.carry(carry[685])，.a(a[685])，.b(b[685])，.c(c[685]))；<dpn="d281"/> xtfai686(.sum(sum[686])，.carry(carry[686])，.a(a[686])，.b(b[686])，.c(c[686]))； xtfai687(.sum(sum[687])，.carry(carry[687])，.a(a[687])，.b(b[687])，.c(c[687]))； xtfai688(.sum(sum[688])，.carry(carry[688])，.a(a[688])，.b(b[688])，.c(c[688]))； xtfai689(.sum(sum[689])，.carry(carry[689])，.a(a[689])，.b(b[689])，.c(c[689]))； xtfai690(.sum(sum[690])，.carry(carry[690])，.a(a[690])，.b(b[690])，.c(c[690]))； xtfai691(.sum(sum[691])，.carry(carry[691])，.a(a[691])，.b(b[691])，.c(c[691]))； xtfai692(.sum(sum[692])，.carry(carry[692])，.a(a[692])，.b(b[692])，.c(c[692]))； xtfai693(.sum(sum[693])，.carry(carry[693])，.a(a[693])，.b(b[693])，.c(c[693]))； xtfai694(.sum(sum[694])，.carry(carry[694])，.a(a[694])，.b(b[694])，.c(c[694]))； xtfai695(.sum(sum[695])，.carry(carry[695])，.a(a[695])，.b(b[695])，.c(c[695]))； xtfai696(.sum(sum[696])，.carry(carry[696])，.a(a[696])，.b(b[696])，.c(c[696]))； xtfai697(.sum(sum[697])，.carry(carry[697])，.a(a[697])，.b(b[697])，.c(c[697]))； xtfai698(.sum(sum[698])，.carry(carry[698])，.a(a[698])，.b(b[698])，.c(c[698]))； xtfai699(.sum(sum[699])，.carry(carry[699])，.a(a[699])，.b(b[699])，.c(c[699]))； xtfai700(.sum(sum[700])，.carry(carry[700])，.a(a[700])，.b(b[700])，.c(c[700]))； xtfai701(.sum(sum[701])，.carry(carry[701])，.a(a[701])，.b(b[701])，.c(c[701]))； xtfai702(.sum(sum(702])，.carry(carry[702])，.a(a[702])，.b(b[702])，.c(c[702]))； xtfai703(.sum(sum[703])，.carry(carry[703])，.a(a[703])，.b(b[703])，.c(c[703]))； xtfai704(.sum(sum[704])，.carry(carry[704])，.a(a[704])，.b(b[704])，.c(c[704]))； xtfai705(.sum(sum[705])，.carry(carry[705])，.a(a[705])，.b(b[705])，.c(c[705]))； xtfai706(.sum(sum[706])，.carry(carry[706])，.a(a[706])，.b(b[706])，.c(c[706]))； xtfai707(.sum(sum[707])，.carry(carry[707])，.a(a[707])，.b(b[707])，.c(c[707]))； xtfai708(.sum(sum[708])，.carry(carry[708])，.a(a[708])，.b(b[708])，.c(c[708]))； xtfai709(.sum(sum[709])，.carry(carry[709])，.a(a[709])，.b(b[709])，.c(c[709]))； xtfai710(.sum(sum[710])，.carry(carry[710])，.a(a[710])，.b(b[710])，.c(c[710]))； xtfai711(.sum(sum[711])，.carry(carry[711])，.a(a[711])，.b(b[711])，.c(c[711]))； xtfai712(.sum(sum[712])，.carry(carry[712])，.a(a[712])，.b(b[712])，.c(c[712]))； xtfai713(.sum(sum[713])，.carry(carry[713])，.a(a[713])，.b(b[713])，.c(c[713]))； xtfai714(.sum(sum[714])，.carry(carry[714])，.a(a[714])，.b(b[714])，.c(c[714]))； xtfai715(.sum(sum[715])，.carry(carry[715])，.a(a[715])，.b(b[715])，.c(c[715]))；<dpn="d282"/> xtfai716(.sum(sum[716])，.carry(carry[716])，.a(a[716])，.b(b[716])，.c(c[716]))； xtfai717(.sum(sum[717])，.carry(carry[717])，.a(a[717])，.b(b[717])，.c(c[717]))； xtfai718(.sum(sum[718])，.carry(carry[718])，.a(a[718])，.b(b[718])，.c(c[718]))； xtfai719(.sum(sum[719])，.carry(carry[719])，.a(a[719])，.b(b[719])，.c(c[719]))； xtfai720(.sum(sum[720])，.carry(carry[720])，.a(a[720])，.b(b[720])，.c(c[720]))； xtfai721(.sum(sum[721])，.carry(carry[721])，.a(a[721])，.b(b[721])，.c(c[721]))； xtfai722(.sum(sum[722])，.carry(carry[722])，.a(a[722])，.b(b[722])，.c(c[722]))； xtfai723(.sum(sum[723])，.carry(carry[723])，.a(a[723])，.b(b[723])，.c(c[723]))； xtfai724(.sum(sum[724])，.carry(carry[724])，.a(a[724])，.b(b[724])，.c(c[724]))； xtfai725(.sum(sum[725])，.carry(carry[725])，.a(a[725])，.b(b[725])，.c(c[725]))； xtfai726(.sum(sum[726])，.carry(carry[726])，.a(a[726])，.b(b[726])，.c(c[726]))； xtfai727(.sum(sum[727])，.carry(carry[727])，.a(a[727])，.b(b[727])，.c(c[727]))； xtfai728(.sum(sum[728])，.carry(carry[728])，.a(a[728])，.b(b[728])，.c(c[728]))； xtfai729(.sum(sum[729])，.carry(carry[729])，.a(a[729])，.b(b[729])，.c(c[729]))； xtfai730(.sum(sum[730])，.carry(carry[730])，.a(a[730])，.b(b[730])，.c(c[730]))； xtfai731(.sum(sum[731])，.carry(carry[731])，.a(a[731])，.b(b[731])，.c(c[731]))； xtfai732(.sum(sum[732])，.carry(carry[732])，.a(a[732])，.b(b[732])，.c(c[732]))； xtfai733(.sum(sum[733])，.carry(carry[733])，.a(a[733])，.b(b[733])，.c(c[733]))； xtfai734(.sum(sum[734])，.carry(carry[734])，.a(a[734])，.b(b[734])，.c(c[734]))； xtfai735(.sum(sum[735])，.carry(carry[735])，.a(a[735])，.b(b[735])，.c(c[735]))； xtfai736(.sum(sum[736])，.carry(carry[736])，.a(a[736])，.b(b[736])，.c(c[736]))； xtfai737(.sum(sum[737])，.carry(carry[737])，.a(a[737])，.b(b[737])，.c(c[737]))； xtfai738(.sum(sum[738])，.carry(carry[738])，.a(a[738])，.b(b[738])，.c(c[738]))； xtfai739(.sum(sum[739])，.carry(carry[739])，.a(a[739])，.b(b[739])，.c(c[739]))； xtfai740(.sum(sum[740])，.carry(carry[740])，.a(a[740])，.b(b[740])，.c(c[740]))； xtfai741(.sum(sum[741])，.carry(carry[741])，.a(a[741])，.b(b[741])，.c(c[741]))； xtfai742(.sum(sum[742])，.carry(carry[742])，.a(a[742])，.b(b[742])，.c(c[742]))； xtfai743(.sum(sum[743])，.carry(carry[743])，.a(a[743])，.b(b[743])，.c(c[743]))； xtfai744(.sum(sum[744])，.carry(carry[744])，.a(a[744])，.b(b[744])，.c(c[744]))； xtfai745(.sum(sum[745])，.carry(carry[745])，.a(a[745])，.b(b[745])，.c(c[745]))；<dpn="d283"/> xtfai746(.sum(sum[746])，.carry(carry[746])，.a(a[746])，.b(b[746])，.c(c[746]))； xtfai747(.sum(sum[747])，.carry(carry[747])，.a(a[747])，.b(b[747])，.c(c[747]))； xtfai748(.sum(sum[748])，.carry(carry[748])，.a(a[748])，.b(b[748])，.c(c[748]))； xtfai749(.sum(sum[749])，.carry(carry[749])，.a(a[749])，.b(b[749])，.c(c[749]))； xtfai750(.sum(sum[750])，.carry(carry[750])，.a(a[750])，.b(b[750])，.c(c[750]))； xtfai751(.sum(sum[751])，.carry(carry[751])，.a(a[751])，.b(b[751])，.c(c[751]))； xtfai752(.sum(sum[752])，.carry(carry[752])，.a(a[752])，.b(b[752])，.c(c[752]))； xtfai753(.sum(sum[753])，.carry(carry[753])，.a(a[753])，.b(b[753])，.c(c[753]))； xtfai754(.sum(sum[754])，.carry(carry[754])，.a(a[754])，.b(b[754])，.c(c[754]))； xtfai755(.sum(sum[755])，.carry(carry[755])，.a(a[755])，.b(b[755])，.c(c[755]))； xtfai756(.sum(sum[756])，.carry(carry[756])，.a(a[756])，.b(b[756])，.c(c[756]))； xtfai757(.sum(sum[757])，.carry(carry[757])，.a(a[757])，.b(b[757])，.c(c[757]))； xtfai758(.sum(sum[758])，.carry(carry[758])，.a(a[758])，.b(b[758])，.c(c[758]))； xtfai759(.sum(sum[759])，.carry(carry[759])，.a(a[759])，.b(b[759])，.c(c[759]))； xtfai760(.sum(sum[760])，.carry(carry[760])，.a(a[760])，.b(b[760])，.c(c[760]))； xtfai761(.sum(sum[761])，.carry(carry[761])，.a(a[761])，.b(b[761])，.c(c[761]))； xtfai762(.sum(sum[762])，.carry(carry[762])，.a(a[762])，.b(b[762])，.c(c[762]))； xtfai763(.sum(sum[763])，.carry(carry[763])，.a(a[763])，.b(b[763])，.c(c[763]))； xtfai764(.sum(sum[764])，.carry(carry[764])，.a(a[764])，.b(b[764])，.c(c[764]))； xtfai765(.sum(sum[765])，.carry(carry[765])，.a(a[765])，.b(b[765])，.c(c[765]))； xtfai766(.sum(sum[766])，.carry(carry[766])，.a(a[766])，.b(b[766])，.c(c[766]))； xtfai767(.sum(sum[767])，.carry(carry[767])，.a(a[767])，.b(b[767])，.c(c[767]))； xtfai768(.sum(sum[768])，.carry(carry[768])，.a(a[768])，.b(b[768])，.c(c[768]))； xtfai769(.sum(sum[769])，.carry(carry[769])，.a(a[769])，.b(b[769])，.c(c[769]))； xtfai770(.sum(sum[770])，.carry(carry[770])，.a(a[770])，.b(b[770])，.c(c[770]))； xtfai771(.sum(sum[771])，.carry(carry[771])，.a(a[771])，.b(b[771])，.c(c[771]))； xtfai772(.sum(sum[772])，.carry(carry[772])，.a(a[772])，.b(b[772])，.c(c[772]))； xtfai773(.sum(sum[773])，.carry(carry[773])，.a(a[773])，.b(b[773])，.c(c[773]))； xtfai774(.sum(sum[774])，.carry(carry[774])，.a(a[774])，.b(b[774])，.c(c[774]))； xtfai775(.sum(sum[775])，.carry(carry[775])，.a(a[775])，.b(b[775])，.c(c[775]))；<dpn="d284"/> xtfai776(.sum(sum[776])，.carry(carry[776])，.a(a[776])，.b(b[776])，.c(c[776]))； xtfai777(.sum(sum[777])，.carry(carry[777])，.a(a[777])，.b(b[777])，.c(c[777]))； xtfai778(.sum(sum[778])，.carry(carry[778])，.a(a[778])，.b(b[778])，.c(c[778]))； xtfai779(.sum(sum[779])，.carry(carry[779])，.a(a[779])，.b(b[779])，.c(c[779]))； xtfai780(.sum(sum[780])，.carry(carry[780])，.a(a[780])，.b(b[780])，.c(c[780]))； xtfai781(.sum(sum[781])，.carry(carry[781])，.a(a[781])，.b(b[781])，.c(c[781]))； xtfai782(.sum(sum[782])，.carry(carry[782])，.a(a[782])，.b(b[782])，.c(c[782]))； xtfai783(.sum(sum[783])，.carry(carry[783])，.a(a[783])，.b(b[783])，.c(c[783]))； xtfai784(.sum(sum[784])，.carry(carry[784])，.a(a[784])，.b(b[784])，.c(c[784]))； xtfai785(.sum(sum[785])，.carry(carry[785])，.a(a[785])，.b(b[785])，.c(c[785]))； xtfai786(.sum(sum[786])，.carry(carry[786])，.a(a[786])，.b(b[786])，.c(c[786]))； xtfai787(.sum(sum[787])，.carry(carry[787])，.a(a[787])，.b(b[787])，.c(c[787]))； xtfai788(.sum(sum[788])，.carry(carry[788])，.a(a[788])，.b(b[788])，.c(c[788]))； xtfai789(.sum(sum[789])，.carry(carry[789])，.a(a[789])，.b(b[789])，.c(c[789]))； xtfai790(.sum(sum[790])，.carry(carry[790])，.a(a[790])，.b(b[790])，.c(c[790]))； xtfai791(.sum(sum[791])，.carry(carry[791])，.a(a[791])，.b(b[791])，.c(c[791]))； xtfai792(.sum(sum[792])，.carry(carry[792])，.a(a[792])，.b(b[792])，.c(c[792]))； xtfai793(.sum(sum[793])，.carry(carry[793])，.a(a[793])，.b(b[793])，.c(c[793]))； xtfai794(.sum(sum[794])，.carry(carry[794])，.a(a[794])，.b(b[794])，.c(c[794]))； xtfai795(.sum(sum[795])，.carry(carry[795])，.a(a[795])，.b(b[795])，.c(c[795]))； xtfai796(.sum(sum[796])，.carry(carry[796])，.a(a[796])，.b(b[796])，.c(c[796]))； xtfai797(.sum(sum[797])，.carry(carry[797])，.a(a[797])，.b(b[797])，.c(c[797]))； xtfai798(.sum(sum[798])，.carry(carry[798])，.a(a[798])，.b(b[798])，.c(c[798]))； xtfai799(.sum(sum[799])，.carry(carry[799])，.a(a[799])，.b(b[799])，.c(c[799]))； xtfai800(.sum(sum[800])，.carry(carry[800])，.a(a[800])，.b(b[800])，.c(c[800]))； xtfai801(.sum(sum[801])，.carry(carry[801])，.a(a[801])，.b(b[801])，.c(c[801]))； xtfai802(.sum(sum[802])，.carry(carry[802])，.a(a[802])，.b(b[802])，.c(c[802]))； xtfai803(.sum(sum[803])，.carry(carry[803])，.a(a[803])，.b(b[803])，.c(c[803]))； xtfai804(.sum(sum[804])，.carry(carry[804])，.a(a[804])，.b(b[804])，.c(c[804]))； xtfai805(.sum(sum[805])，.carry(carry[805])，.a(a[805])，.b(b[805])，.c(c[805]))；<dpn="d285"/> xtfai806(.sum(sum[806])，.carry(carry[806])，.a(a[806])，.b(b[806])，.c(c[806]))； xtfai807(.sum(sum[807])，.carry(carry[807])，.a(a[807])，.b(b[807])，.c(c[807]))； xtfai808(.sum(sum[808])，.carry(carry[808])，.a(a[808])，.b(b[808])，.c(c[808]))； xtfai809(.sum(sum[809])，.carry(carry[809])，.a(a[809])，.b(b[809])，.c(c[809]))； xtfai810(.sum(sum[810])，.carry(carry[810])，.a(a[810])，.b(b[810])，.c(c[810]))； xtfai811(.sum(sum[811])，.carry(carry[811])，.a(a[811])，.b(b[811])，.c(c[811]))； xtfai812(.sum(sum[812])，.carry(carry[812])，.a(a[812])，.b(b[812])，.c(c[812]))； xtfai813(.sum(sum[813])，.carry(carry[813])，.a(a[813])，.b(b[813])，.c(c[813]))； xtfai814(.sum(sum[814])，.carry(carry[814])，.a(a[814])，.b(b[814])，.c(c[814]))； xtfai815(.sum(sum[815])，.carry(carry[815])，.a(a[815])，.b(b[815])，.c(c[815]))； xtfai816(.sum(sum[816])，.carry(carry[816])，.a(a[816])，.b(b[816])，.c(c[816]))； xtfai817(.sum(sum[817])，.carry(carry[817])，.a(a[817])，.b(b[817])，.c(c[817]))； xtfai818(.sum(sum[818])，.carry(carry[818])，.a(a[818])，.b(b[818])，.c(c[818]))； xtfai819(.sum(sum[819])，.carry(carry[819])，.a(a[819])，.b(b[819])，.c(c[819]))； xtfai820(.sum(sum[820])，.carry(carry[820])，.a(a[820])，.b(b[820])，.c(c[820]))； xtfai821(.sum(sum[821])，.carry(carry[821])，.a(a[821])，.b(b[821])，.c(c[821]))； xtfai822(.sum(sum[822])，.carry(carry[822])，.a(a[822])，.b(b[822])，.c(c[822]))； xtfai823(.sum(sum[823])，.carry(carry[823])，.a(a[823])，.b(b[823])，.c(c[823]))； xtfai824(.sum(sum[824])，.carry(carry[824])，.a(a[824])，.b(b[824])，.c(c[824]))； xtfai825(.sum(sum[825])，.carry(carry[825])，.a(a[825])，.b(b[825])，.c(c[825]))； xtfai826(.sum(sum[826])，.carry(carry[826])，.a(a[826])，.b(b[826])，.c(c[826]))； xtfai827(.sum(sum[827])，.carry(carry[827])，.a(a[827])，.b(b[827])，.c(c[827]))； xtfai828(.sum(sum[828])，.carry(carry[828])，.a(a[828])，.b(b[828])，.c(c[828]))； xtfai829(.sum(sum[829])，.carry(carry[829])，.a(a[829])，.b(b[829])，.c(c[829]))； xtfai830(.sum(sum[830])，.carry(carry[830])，.a(a[830])，.b(b[830])，.c(c[830]))； xtfai831(.sum(sum[831])，.carry(carry[831])，.a(a[831])，.b(b[831])，.c(c[831]))； xtfai832(.sum(sum[832])，.carry(carry[832])，.a(a[832])，.b(b[832])，.c(c[832]))； xtfai833(.sum(sum[833])，.carry(carry[833])，.a(a[833])，.b(b[833])，.c(c[833])) xtfai834(.sum(sum[834])，.carry(carry[834])，.a(a[834])，.b(b[834])，.c(c[834]))； xtfai835(.sum(sum[835])，.carry(carry[835])，.a(a[835])，.b(b[835])，.c(c[835]))；<dpn="d286"/> xtfai836(.sum(sum[836])，.carry(carry[836])，.a(a[836])，.b(b[836])，.c(c[836]))； xtfai837(.sum(sum[837])，.carry(carry[837])，.a(a[837])，.b(b[837])，.c(c[837]))； xtfai838(.sum(sum[838])，.carry(carry[838])，.a(a[838])，.b(b[838])，.c(c[838]))； xtfai839(.sum(sum[839])，.carry(carry[839])，.a(a[839])，.b(b[839])，.c(c[839]))； xtfai840(.sum(sum[840])，.carry(carry[840])，.a(a[840])，.b(b[840])，.c(c[840]))； xtfai841(.sum(sum[841])，.carry(carry[841])，.a(a[841])，.b(b[841])，.c(c[841]))； xtfai842(.sum(sum[842])，.carry(carry[842])，.a(a[842])，.b(b[842])，.c(c[842]))； xtfai843(.sum(sum[843])，.carry(carry[843])，.a(a[843])，.b(b[843])，.c(c[843]))； xtfai844(.sum(sum[844])，.carry(carry[844])，.a(a[844])，.b(b[844])，.c(c[844]))； xtfai845(.sum(sum[845])，.carry(carry[845])，.a(a[845])，.b(b[845])，.c(c[845]))； xtfai846(.sum(sum[846])，.carry(carry[846])，.a(a[846])，.b(b[846])，.c(c[846]))； xtfai847(.sum(sum[847])，.carry(carry[847])，.a(a[847])，.b(b[847])，.c(c[847]))； xtfai848(.sum(sum[848])，.carry(carry[848])，.a(a[848])，.b(b[848])，.c(c[848]))； xtfai849(.sum(sum[849])，.carry(carry[849])，.a(a[849])，.b(b[849])，.c(c[849]))； xtfai850(.sum(sum[850])，.carry(carry[850])，.a(a[850])，.b(b[850])，.c(c[850]))； xtfai851(.sum(sum[851])，.carry(carry[851])，.a(a[851])，.b(b[851])，.c(c[851]))； xtfai852(.sum(sum[852])，.carry(carry[852])，.a(a[852])，.b(b[852])，.c(c[852]))； xtfai853(.sum(sum[853])，.carry(carry[853])，.a(a[853])，.b(b[853])，.c(c[853]))； xtfai854(.sum(sum[854])，.carry(carry[854])，.a(a[854])，.b(b[854])，.c(c[854]))； xtfai855(.sum(sum[855])，.carry(carry[855])，.a(a[855])，.b(b[855])，.c(c[855]))； xtfai856(.sum(sum[856])，.carry(carry[856])，.a(a[856])，.b(b[856])，.c(c[856]))； xtfai857(.sum(sum[857])，.carry(carry[857])，.a(a[857])，.b(b[857])，.c(c[857]))； xtfai858(.sum(sum[858])，.carry(carry[858])，.a(a[858])，.b(b[858])，.c(c[858]))； xtfai859(.sum(sum[859])，.carry(carry[859])，.a(a[859])，.b(b[859])，.c(c[859]))； xtfai860(.sum(sum[860])，.carry(carry[860])，.a(a[860])，.b(b[860])，.c(c[860]))； xtfai861(.sum(sum[861])，.carry(carry[861])，.a(a[861])，.b(b[861])，.c(c[861]))； xtfai862(.sum(sum[862])，.carry(carry[862])，.a(a[862])，.b(b[862])，.c(c[862]))； xtfai863(.sum(sum[863])，.carry(carry[863])，.a(a[863])，.b(b[863])，.c(c[863]))； xtfai864(.sum(sum[864])，.carry(carry[864])，.a(a[864])，.b(b[864])，.c(c[864]))； xtfai865(.sum(sum[865])，.carry(carry[865])，.a(a[865])，.b(b[865])，.c(c[865]))；<dpn="d287"/> xtfai866(.sum(sum[866])，.carry(carry[866])，.a(a[866])，.b(b[866])，.c(c[866]))； xtfai867(.sum(sum[867])，.carry(carry[867])，.a(a[867])，.b(b[867])，.c(c[867]))； xtfai868(.sum(sum[868])，.carry(carry[868])，.a(a[868])，.b(b[868])，.c(c[868]))； xtfai869(.sum(sum[869])，.carry(carry[869])，.a(a[869])，.b(b[869])，.c(c[869]))； xtfai870(.sum(sum[870])，.carry(carry[870])，.a(a[870])，.b(b[870])，.c(c[870]))； xtfai871(.sum(sum[871])，.carry(carry[871])，.a(a[871])，.b(b[871])，.c(c[871]))； xtfai872(.sum(sum[872])，.carry(carry[872])，.a(a[872])，.b(b[872])，.c(c[872]))； xtfai873(.sum(sum[873])，.carry(carry[873])，.a(a[873])，.b(b[873])，.c(c[873]))； xtfai874(.sum(sum[874])，.carry(carry[874])，.a(a[874])，.b(b[874])，.c(c[874]))； xtfai875(.sum(sum[875])，.carry(carry[875])，.a(a[875])，.b(b[875])，.c(c[875]))； xtfai876(.sum(sum[876])，.carry(carry[876])，.a(a[876])，.b(b[876])，.c(c[876]))； xtfai877(.sum(sum[877])，.carry(carry[877])，.a(a[877])，.b(b[877])，.c(c[877]))； xtfai878(.sum(sum[878])，.carry(carry[878])，.a(a[878])，.b(b[878])，.c(c[878]))； xtfai879(.sum(sum[879])，.carry(carry[879])，.a(a[879])，.b(b[879])，.c(c[879]))； xtfai880(.sum(sum[880])，.carry(carry[880])，.a(a[880])，.b(b[880])，.c(c[880]))； xtfai881(.sum(sum[881])，.carry(carry[881])，.a(a[881])，.b(b[881])，.c(c[881]))； xtfai882(.sum(sum[882])，.carry(carry[882])，.a(a[882])，.b(b[882])，.c(c[882]))； xtfai883(.sum(sum[883])，.carry[carry[883])，.a(a[883])，.b(b[883])，.c(c[883]))； xtfai884(.sum(sum[884])，.carry(carry[884])，.a(a[884])，.b(b[884])，.c(c[884]))； xtfai885(.sum(sum[885])，.carry(carry[885])，.a(a[885])，.b(b[885])，.c(c[885]))； xtfai886(.sum(sum[886])，.carry(carry[886])，.a(a[886])，.b(b[886])，.c(c[886]))； xtfai887(.sum(sum[887])，.carry(carry[887])，.a(a[887])，.b(b[887])，.c(c[887]))； xtfai888(.sum(sum[888])，.carry(carry[8881)，.a(a[888])，.b(b[888])，.c(c[888]))； xtfai889(.sum(sum[889])，.carry(carry[889])，.a(a[889])，.b(b[889])，.c(c[889]))； xtfai890(.sum(sum[890])，.carry(carry[890])，.a(a[890])，.b(b[890])，.c(c[890]))； xtfai891(.sum(sum[891])，.carry(carry[891])，.a(a[891])，.b(b[891])，.c(c[891]))； xtfai892(.sum(sum[892])，.carry(carry[892])，.a(a[892])，.b(b[892])，.c(c[892]))； xtfai893(.sum(sum[893])，.carry(carry[893])，.a(a[893])，.b(b[893])，.c(c[893]))； xtfai894(.sum(sum[894])，.carry(carry[894])，.a(a[894])，.b(b[894])，.c(c[894]))； xtfai895(.sum(sum[895])，.carry(carry[895])，.a(a[895])，.b(b[895])，.c(c[895]))；<dpn="d288"/> xtfai896(.sum(sum[896])，.carry(carry[896])，.a(a[896])，.b(b[896])，.c(c[896]))； xtfai897(.sum(sum[897])，.carry(carry[897])，.a(a[897])，.b(b[897])，.c(c[897]))； xtfai898(.sum(sum[898])，.carry(carry[898])，.a(a[898])，.b(b[898])，.c(c[898]))； xtfai899(.sum(sum[899])，.carry(carry[899])，.a(a[899])，.b(b[899])，.c(c[899]))； xtfai900(.sum(sum[900])，.carry(carry[900])，.a(a[900])，.b(b[900])，.c(c[900]))； xtfai901(.sum(sum[901])，.carry(carry[901])，.a(a[901])，.b(b[901])，.c(c[901]))； xtfai902(.sum(sum[902])，.carry(carry[902])，.a(a[902])，.b(b[902])，.c(c[902]))； xtfai903(.sum(sum[903])，.carry(carry[903])，.a(a[903])，.b(b[903])，.c(c[903]))； xtfai904(.sum(sum[904])，.carry(carry[904])，.a(a[904])，.b(b[904])，.c(c[904]))； xtfai905(.sum(sum[905])，.carry(carry[905])，.a(a[905])，.b(b[905])，.c(c[905]))； xtfai906(.sum(sum[906])，.carry(carry[906])，.a(a[906])，.b(b[906])，.c(c[906]))； xtfai907(.sum(sum[907])，.carry(carry[907])，.a(a[907])，.b(b[907])，.c(c[907]))； xtfai908(.sum(sum[908])，.carry(carry[908])，.a(a[908])，.b(b[908])，.c(c[908]))； xtfai909(.sum(sum[909])，.carry(carry[909])，.a(a[909])，.b(b[909])，.c(c[909]))； xtfai910(.sum(sum[910])，.carry(carry[910])，.a(a[910])，.b(b[910])，.c(c[910]))； xtfai911(.sum(sum[911])，.carry(carry[911])，.a(a[911])，.b(b[911])，.c(c[911]))； xtfai912(.sum(sum[912])，.carry(carry[912])，.a(a[912])，.b(b[912])，.c(c[912]))； xtfai913(.sum(sum[913])，.carry(carry[913])，.a(a[913])，.b(b[913])，.c(c[913]))； xtfai914(.sum(sum[914])，.carry(carry[914])，.a(a[914])，.b(b[914])，.c(c[914]))； xtfai915(.sum(sum[915])，.carry(carry[915])，.a(a[915])，.b(b[915])，.c(c[915]))； xtfai916(.sum(sum[916])，.carry(carry[916])，.a(a[916])，.b(b[916])，.c(c[916]))； xtfai917(.sum(sum[917])，.carry(carry[917])，.a(a[917])，.b(b[917])，.c(c[917]))； xtfai918(.sum(sum[918])，.carry(carry[918])，.a(a[918])，.b(b[918])，.c(c[918]))； xtfai919(.sum(sum[919])，.carry(carry[919])，.a(a[919])，.b(b[919])，.c(c[919]))； xtfai920(.sum(sum[920])，.carry(carry[920])，.a(a[920])，.b(b[920])，.c(c[920]))； xtfai921(.sum(sum[921])，.carry(carry[921])，.a(a[921])，.b(b[921])，.c(c[921]))； xtfai922(.sum(sum[922])，.carry(carry[922])，.a(a[922])，.b(b[922])，.c(c[922]))； xtfai923(.sum(sum[923])，.carry(carry[923])，.a(a[923])，.b(b[923])，.c(c[923]))； xtfai924(.sum(sum[924])，.carry(carry[924])，.a(a[924])，.b(b[924])，.c(c[924]))； xtfai925(.sum(sum[925])，.carry(carry[925])，.a(a[925])，.b(b[925])，.c(c[925]))；<dpn="d289"/> xtfai926(.sum(sum[926])，.carry(carry[926])，.a(a[926])，.b(b[926])，.c(c[926]))； xtfai927(.sum(sum[927])，.carry(carry[927])，.a(a[927])，.b(b[927])，.c(c[927]))； xtfai928(.sum(sum[928])，.carry(carry[928])，.a(a[928])，.b(b[928])，.c(c[928]))； xtfai929(.sum(sum[929])，.carry(carry[929])，.a(a[929])，.b(b[929])，.c(c[929]))； xtfai930(.sum(sum[930])，.carry(carry[930])，.a(a[930])，.b(b[930])，.c(c[930]))； xtfai931(.sum(sum[931])，.carry(carry[931])，.a(a[931])，.b(b[931])，.c(c[931]))； xtfai932(.sum(sum[932])，.carry(carry[932])，.a(a[932])，.b(b[932])，.c(c[932]))； xtfai933(.sum(sum[933])，.carry(carry[933])，.a(a[933])，.b(b[933])，.c(c[933]))； xtfai934(.sum(sum[934])，.carry(carry[934])，.a(a[934])，.b(b[934])，.c(c[934]))； xtfai935(.sum(sum[935])，.carry(carry[935])，.a(a[935])，.b(b[935])，.c(c[935]))； xtfai936(.sum(sum[936])，.carry(carry[936])，.a(a[936])，.b(b[936])，.c(c[936]))； xtfai937(.sum(sum[937])，.carry(carry[937])，.a(a[937])，.b(b[937])，.c(c[937]))； xtfai938(.sum(sum[938])，.carry(carry[938])，.a(a[938])，.b(b[938])，.c(c[938]))； xtfai939(.sum(sum[939])，.carry(carry[939])，.a(a[939])，.b(b[939])，.c(c[939]))； xtfai940(.sum(sum[940])，.carry(carry[940])，.a(a[940])，.b(b[940])，.c(c[940]))； xtfai941(.sum(sum[941])，.carry(carry[941])，.a(a[941])，.b(b[941])，.c(c[941]))； xtfai942(.sum(sum[942])，.carry(carry[942])，.a(a[942])，.b(b[942])，.c(c[942]))； xtfai943(.sum(sum[943])，.carry(carry[943])，.a(a[943])，.b(b[943])，.c(c[943]))； xtfai944(.sum(sum[944])，.carry(carry[944])，.a(a[944])，.b(b[944])，.c(c[944]))； xtfai945(.sum(sum[945])，.carry(carry[945])，.a(a[945])，.b(b[945])，.c(c[945]))； xtfai946(.sum(sum[946])，.carry(carry[946])，.a(a[946])，.b(b[946])，.c(c[946]))； xtfai947(.sum(sum[947])，.carry(carry[947])，.a(a[947])，.b(b[947])，.c(c[947]))； xtfai948(.sum(sum[948])，.carry(carry[948])，.a(a[948])，.b(b[948])，.c(c[948]))； xtfai949(.sum(sum[949])，.carry(carry[949])，.a(a[949])，.b(b[949])，.c(c[949]))； xtfai950(.sum(sum[950])，.carry(carry[950])，.a(a[950])，.b(b[950])，.c(c[950]))； xtfai951(.sum(sum[951])，.carry(carry[951])，.a(a[951])，.b(b[951])，.c(c[951]))； xtfai952(.sum(sum[952])，.carry(carry[952])，.a(a[952])，.b(b[952])，.c(c[952]))； xtfai953(.sum(sum[953])，.carry(carry[953])，.a(a[953])，.b(b[953])，.c(c[953]))； xtfai954(.sum(sum[954])，.carry(carry[954])，.a(a[954])，.b(b[954])，.c(c[954]))； xtfai955(.sum(sum[955])，.carry(carry[955])，.a(a[955])，.b(b[955])，.c(c[955]))；<dpn="d290"/> xtfai956(.sum(sum[956])，.carry(carry[956])，.a(a[956])，.b(b[956])，.c(c[956]))； xtfai957(.sum(sum[957])，.carry(carry[957])，.a(a[957])，.b(b[957])，.c(c[957]))； xtfai958(.sum(sum[958])，.carry(carry[958])，.a(a[958])，.b(b[958])，.c(c[958]))； xtfai959(.sum(sum[959])，.carry(carry[959])，.a(a[959])，.b(b[959])，.c(c[959]))； xtfai960(.sum(sum[960])，.carry(carry[960])，.a(a[960])，.b(b[960])，.c(c[960]))； xtfai961(.sum(sum[961])，.carry(carry[961])，.a(a[961])，.b(b[961])，.c(c[961]))； xtfai962(.sum(sum[962])，.carry(carry[962])，.a(a[962])，.b(b[962])，.c(c[962]))； xtfai963(.sum(sum[963])，.carry(carry[963])，.a(a[963])，.b(b[963])，.c(c[963]))； xtfai964(.sum(sum[964])，.carry(carry[964])，.a(a[964])，.b(b[964])，.c(c[964]))； xtfai965(.sum(sum[965])，.carry(carry[965])，.a(a[965])，.b(b[965])，.c(c[965]))； xtfai966(.sum(sum[966])，.carry(carry[966])，.a(a[966])，.b(b[966])，.c(c[966]))； xtfai967(.sum(sum[967])，.carry(carry[967])，.a(a[967])，.b(b(967])，.c(c[967]))； xtfai968(.sum(sum[968])，.carry(carry[968])，.a(a[968])，.b(b[968])，.c(c[968]))； xtfai969(.sum(sum[969])，.carry(carry[969])，.a(a[969])，.b(b[969])，.c(c[969]))； xtfai970(.sum(sum[970])，.carry(carry[970])，.a(a[970])，.b(b[970])，.c(c[970]))； xtfai971(.sum(sum[971])，.carry(carry[971])，.a(a[971])，.b(b[971])，.c(c[971]))； xtfai972(.sum(sum[972])，.carry(carry[972])，.a(a[972])，.b(b[972])，.c(c[972]))； xtfai973(.sum(sum[973])，.carry(carry[973])，.a(a[973])，.b(b[973])，.c(c[973]))； xtfai974(.sum(sum[974])，.carry(carry[974])，.a(a[974])，.b(b[974])，.c(c[974]))； xtfai975(.sum(sum[975])，.carry(carry[975])，.a(a[975])，.b(b[975])，.c(c[975]))； xtfai976(.sum(sum[976])，.carry(carry[976])，.a(a[976])，.b(b[976])，.c(c[976]))； xtfai977(.sum(sum[977])，.carry(carry[977])，.a(a[977])，.b(b[977])，.c(c[977]))； xtfai978(.sum(sum[978])，.carry(carry[978])，.a(a[978])，.b(b[978])，.c(c[978]))； xtfai979(.sum(sum[979])，.carry(carry[979])，.a(a[979])，.b(b[979])，.c(c[979]))； xtfai980(.sum(sum[980])，.carry(carry[980])，.a(a[980])，.b(b[980])，.c(c[980]))； xtfai981(.sum(sum[981])，.carry(carry[981])，.a(a[981])，.b(b[981])，.c(c[981]))； xtfai982(.sum(sum[982])，.carry(carry[982])，.a(a[982])，.b(b[982])，.c(c[982]))； xtfai983(.sum(sum[983])，.carry(carry[983])，.a(a[983])，.b(b[983])，.c(c[983]))； xtfai984(.sum(sum[984])，.carry(carry[984])，.a(a[984])，.b(b[984])，.c(c[984]))； xtfai985(.sum(sum[985])，.carry(carry[985])，.a(a[985])，.b(b[985])，.c(c[985]))；<dpn="d291"/> xtfai986(.sum(sum[986])，.carry(carry[986])，.a(a[986])，.b(b[986])，.c(c[986]))； xtfai987(.sum(sum[987])，.carry(carry[987])，.a(a[987])，.b(b[987])，.c(c[987]))； xtfai988(.sum(sum[988])，.carry(carry[988])，.a(a[988])，.b(b[988])，.c(c[988]))； xtfai989(.sum(sum[989])，.carry(carry[989])，.a(a[989])，.b(b[989])，.c(c[989]))； xtfai990(.sum(sum[990])，.carry(carry[990])，.a(a[990])，.b(b[990])，.c(c[990]))； xtfai991(.sum(sum[991])，.carry(carry[991])，.a(a[991])，.b(b[991])，.c(c[991]))； xtfai992(.sum(sum[992])，.carry(carry[992])，.a(a[992])，.b(b[992])，.c(c[992]))； xtfai993(.sum(sum[993])，.carry(carry[993])，.a(a[993])，.b(b[993])，.c(c[993]))； xtfai994(.sum(sum[994])，.carry(carry[994])，.a(a[994])，.b(b[994])，.c(c[994]))； xtfai995(.sum(sum[995])，.carry(carry[995])，.a(a[995])，.b(b[995])，.c(c[995]))； xtfai996(.sum(sum[996])，.carry(carry[996])，.a(a[996])，.b(b[996])，.c(c[996]))； xtfai997(.sum[sum[997])，.carry(carry[997])，.a(a[997])，.b(b[997])，.c(c[997]))； xtfai998(.sum(sum[998])，.carry(carry[998])，.a(a[998])，.b(b[998])，.c(c[998]))； xtfai999(.sum(sum[999])，.carry(carry[999])，.a(a[999])，.b(b[999])，.c(c[999]))； xtfai1000(.sum(sum[1000])，.carry(carry[1000])，.a(a[1000])，.b(b[1000])，.c(c[1000]))； xtfai1001(.sum(sum[1001])，.carry(carry[1001])，.a(a[1001])，.b(b[1001])，.c(c[1001]))； xtfai1002(.sum(sum[1002])，.carry(carry[1002])，.a(a[1002])，.b(b[1002])，.c(c[1002]))； xtfai1003(.sum(sum[1003])，.carry(carry[1003])，.a(a[1003])，.b(b[1003])，.c(c[1003]))； xtfai1004(.sum(sum[1004])，.carry(carry[1004])，.a(a[1004])，.b(b[1004])，.c(c[1004]))； xtfai1005(.sum(sum[1005])，.carry(carry[1005])，.a(a[1005])，.b(b[1005])，.c(c[1005]))； xtfai1006(.sum(sum[1006])，.carry(carry[1006])，.a(a[1006])，.b(b[1006])，.c(c[1006]))； xtfai1007(.sum(sum[1007])，.carry(carry[1007])，.a(a[1007])，.b(b[1007])，.c(c[1007]))； xtfai1008(.sum(sum[1008])，.carry(carry[1008])，.a(a[1008])，.b(b[1008])，.c(c[1008]))； xtfai1009(.sum(sum[1009])，.carry(carry[1009])，.a(a[1009])，.b(b[1009])，.c(c[1009]))； xtfai1010(.sum(sum[1010])，.carry(carry[1010])，.a(a[1010])，.b(b[1010])，.c(c[1010]))； xtfai1011(.sum(sum[1011])，.carry(carry[1011])，.a(a[1011])，.b(b[1011])，.c(c[1011]))； xtfai1012(.sum(sum[1012])，.carry(carry[1012])，.a(a[1012])，.b(b[1012])，.c(c[1012]))； xtfai1013(.sum(sum[1013])，.carry(carry[1013])，.a(a[1013])，.b(b[1013])，.c(c[1013]))； xtfai1014(.sum(sum[1014])，.carry(carry[1014])，.a(a[1014])，.b(b[1014])，.c(c[1014]))； xtfai1015(.sum(sum[1015])，.carry(carry[1015])，.a(a[1015])，.b(b[1015])，.c(c[1015]))；<dpn="d292"/> xtfai1016(.sum(sum[1016])，.carry(carry[1016])，.a(a[1016])，.b(b[1016])，.c(c[1016]))； xtfai1017(.sum(sum[1017])，.carry(carry[1017])，.a(a[1017])，.b(b[1017])，.c(c[1017]))； xtfai1018(.sum(sum[1018])，.carry(carry[1018])，.a(a[1018])，.b(b[1018])，.c(c[1018]))； xtfai1019(.sum(sum[1019])，.carry(csrry[1019])，.a(a[1019])，.b(b[1019])，.c(c[1019]))； xtfai1020(.sum(sum[1020])，.carry(carry[1020])，.a(a[1020])，.b(b[1020])，.c(c[1020]))； xtfai1021(.sum(sum[1021])，.carry(carry[1021])，.a(a[1021])，.b(b[1021])，.c(c[1021]))； xtfai1022(.sum(sum[1022])，.carry(carry[1022])，.a(a[1022])，.b(b[1022])，.c(c[1022]))； xtfai1023(.sum(sum[1023])，.carry(carry[1023])，.a(a[1023])，.b(b[1023])，.c(c[1023]))；endmodule//LocalVariables***//modeverilog**//End***verysys/verifysem.vmodulexmTIE_gf_Regfile(rd0_data_C1，rd0_addr_C0，rd0_width8_C0，rd0_use1_C0， rd1_data_C1，rd1_addr_C0，rd1_width8_C0，rd1_use1_C0，rd2_data_C1， rd2_addr_C0，rd2_width8_C0，rd2_use1_C0，wd_addr_C0，wd_width8_C0， wd_def1_C0，wd_def2_C0，wd_data8_C1，wd_data8_C2，wd_wen_C1，wd_wen_C2， Kill_E，KillPipe_W，Stall_R，clk)； output[70]rd0_data_C1； input[30]rd0_addr_C0； inputrd0_width8_C0； inputrd0_use1_C0； output[70]rd1_data_C1； input[30]rd1_addr_C0； inputrd1_width8_C0； inputrd1_use1_C0； output[70]rd2_data_C1； input[30]rd2_addr_C0； inputrd2_width8_C0； inputrd2_use1_C0； input[30]wd_addr_C0； inputwd_width8_C0； inputwd_def1_C0； inputwd_def2_C0； input[70]wd_data8_C1； input[70]wd_data8_C2； inputwd_wen_C1； inputwd_wen_C2； inputKill_E； inputKillPipe_W； outputStall_R； inputclk； /***********************************************************************<dpn="d293"/> TEADPOPTrd0***********************************************************************/ //computetheaddressmask wirerd0_addr_mask_C0＝1′d0； //maskedaddresspipeline wirerd0_maddr_C0＝1′d0； //bank-qualifieduse wirerd0_use1_bank0_C0＝(rd0_use1_C0&amp;(rd0_maddr_C0＝＝(1′d0&amp;rd0_addr_mask_C0)))； //alignmentmuxforuse1 wire[70]rd0_data_bank0_C1； assignrd0_data_C1[70]＝rd0_data_bank0_C1；/*********************************************************************** READPORTrd1***********************************************************************/ //computetheaddressmask wirerd1_addr_mask_C0＝1′d0； //maskedaddresspipeline wirerd1_maddr_C0＝1′d0； //bank-qualifieduse wirerd1_use1_bank0_C0＝(rd1_use1_C0&amp;(rd1_maddr_C0＝＝(1′d0&amp;rd1_addr_mask_C0)))； //alignmentmuxforuse1 wire[70]rd1_data_bank0_C1； assignrd1_data_C1[70]＝rd1_data_bank0_C1；/*********************************************************************** READPORTrd2***********************************************************************/ //computetheaddressmask wirerd2_addr_mask_C0＝1′d0； //maskedaddresspipeline wirerd2_maddr_C0＝1′d0； //bank-qua1ifieduse wirerd2_usel_bank0_C0＝(rd2_usel_C0&amp;(rd2_maddr_C0＝＝(1′d0&amp;rd2_addr_mask_C0))) //alignmentmuxforuse1 wire[70]rd2_data_bank0_C1； assignrd2_data_C1[70]＝rd2_data_bank0_C1；/***********************************************************************<dpn="d294"/> WRITEPORTwd***********************************************************************/ //computetheaddressmask wirewd_addr_mask_C0＝1′d0； //bank-qualifiedwritedefforportwd wirewd_def1-bank0_C0＝(wd_def1_C0&amp;((wd_addr_C0&amp;wd_addr_mask_C0)＝＝(1′d0&amp;wd_addr_mask_C0)))； wirewd_def2_bank0_C0＝(wd_def2_C0&amp;((wd_addr_C0&amp;wd_addr_mask_C0)＝＝(1′d0&amp;wd_addr_mask_C0)))； //writemuxfordef1 wire[70]wd_wdata_C1； assignwd_wdata_C1＝{1{wd_data8_C1[70]}}； //writemuxfordef2 wire[70]wd_wdata_C2； assignwd_wdata_C2＝{1{wd_data8_C2[70]}}； wireStall_R0；/*********************************************************************** PIPELINEDBANK***********************************************************************/ xmTIE_gf_Regfile_bankTIE_gf_Regfile_bank0(rd0_data_bank0_C1， rd0_addr_C0[30]，rd0_use1_bank0_C0，rd1_data_bank0_C1，rd1_addr_C0[30]， rd1_use1_bank0_C0，rd2_data_bank0_C1，rd2_addr_C0[30]，rd2_use1_bank0_C0， wd_addr_C0[30]，wd_def1_bank0_C0，wd_def2_bank0_C0，wd_wdata_C1[70]， wd_wdata_C2[70]，wd_wen_C1，wd_wen_C2，Kill_E，KillPipe_W，Stall_R0， clk)； assignStall_R＝Stall_R0|1′b0；endmodulemodulexmTIE_gf_Regfile_bank(rd0_data_C1，rd0_addr_C0，rd0_use1_C0， rd1_data_C1，rd1_addr_C0，rd1_use1_C0，rd2_data_C1，rd2_addr_C0， rd2_use1_C0，wd_addr_C0，wd_def1_C0，wd_def2_C0，wd_data_C1，wd_data_C2， wd_wen_C1，wd_wen_C2，Kill_E，KillPipe_W，Stall_R，clk)； output[70]rd0_data_C1； input[30]rd0_addr_C0； inputrd0_use1_C0； output[70]rd1_data_C1； input[30]rd1_addr_C0； inputrd1_use1_C0； output[70]rd2_data_C1； input[30]rd2_addr_C0； inputrd2_use1_C0； input[30]wd_addr_C0； inputwd_def1_C0； inputwd_def2_C0； input[70]wd_data_C1；<dpn="d295"/>input[70]wd_data_C2；inputwd_wen_C1；inputwd_wen_C2；inputKill_E；inputKillPipe_W；outputStall_R；inputclk；wirerd0_use2_C0＝1′d0；wirerd1_use2_C0＝1′d0；wirerd2_use2_C0＝1′d0；wirekill_C0＝Ki1lPipe_W；wirekill_C1＝KillPipe_W|Kill_E；wirekill_C2＝KillPipe_W；wirekill_C3＝KillPipe_W；//writedefinitionpipelinewirewd_ns_def1_C0＝wd_def1_C0&amp;1′b1&amp;-kill_C0；wirewd_def1_C1；xtdelay1#(1)iwd_def1_C1(wd_def1_C1，wd_ns_def1_C0，clk)；wirewd_ns_def2_C0＝wd_def2_C0&amp;1′b1&amp;-kill_C0；wirewd_def2_C1；xtdelay1#(1)iwd_def2_C1(wd_def2_C1，wd_ns_def2_C0，clk)；wirewd_ns_def2_C1＝wd_def2_C1&amp;wd_wen_C1&amp;-kill_C1;wirewd_def2_C2；xtdelay1#(1)iwd_def2_C2(wd_def2_C2，wd_ns_def2_C1，clk)；//writeenablepipelinewirewd_we_C2；wirewd_we_C3；wirewd_ns_we_C1＝(1′d0|(wd_def1_C1&amp;wd_wen_C1))&amp;-kill_C1；wirewd_ns_we_C2＝(wd_we_C2|(wd_def2_C2&amp;wd_wen_C2))&amp;-kill_C2；wirewd_ns_we_C3＝(wd_we_C3|(1′d0&amp;1′d0))&amp;-kill_C3；xtdelay1#(1)iwd_we_C2(wd_we_C2，wd_ns_we_C1，clk)；xtdelay1#(1)iwd_we_C3(wd_we_C3，wd_ns_we_C2，clk);//writeaddresspipelinewire[30]wd_addr_C1；wire[30]wd_addr_C2；wire[30]wd_addr_C3；xtdelay1#(4)iwd_addr_C1(wd_addr_C1，wd_addr_C0，clk)；xtdelay1#(4)iwd_addr_C2(wd_addr_C2，wd_addr_C1，clk)；xtdelay1#(4)iwd_addr_C3(wd_addr_C3，wd_addr_C2，clk)；//writedatapipelinewire[70]wd_result_C2；wire[70]wd_result_C3；wire[70]wd_mux_C1＝wd_data_C1；wire[70]wd_mux_C2＝wd_def2_C2？wd_data_C2wd_result_C2；xtdelay1#(8)iwd_result_C2(wd_result_C2，wd_mux_C1，clk)；xtdelay1#(8)iwd_result_C3(wd_result_C3，wd_mux_C2，clk)；wire[70]rd0_data_C0；wire[70]rd1_data_C0；wire[70]rd2_data_C0；xtdelay1#(8)ird0_data_C1(rd0_data_C1，rd0_data_C0，Clk)；xtdelay1#(8)ird1_data_C1(rd1_data_C1，rd1_data_C0，clk)；<dpn="d296"/> xtdelay1#(8)ird2_data_C1(rd2_data_C1，rd2_data_C0，clk)； assignStall_R＝ ((wd_addr_C1＝＝rd0_addr_C0)&amp;( (rd0_use1_C0&amp;(wd_ns_def2C1))))| ((wd_addr_C1＝＝rd1_addr_C0)&amp;( (rd1_use1_C0&amp;(wd_ns_def2_C1))))| ((wd_addr_C1＝＝rd2_addr_C0)&amp;( (rd2_use1_C0&amp;(wd_ns_def2_C1))))| 1′b0； //verificationregisterfilereplacement wire[70]xwd_verify； xtenflop#(8)wd_verify(xwd_verify，wd_result_C3，wd_ns_we_C3，clk)； xtflop#(8)rd0_verify(rd0_data_C0，xwd_verify，clk)； xtflop#(8)rd1_verify(rd1_dataC0，xwd_verify，clk)； xtflop#(8)rd2_verify(rd2_data_C0，xwd_verify，clk)；endmodulemodulexmTIE_gfmod_State(ps_data_C1，ps_width8_C0，ps_use1_C0，ns_width8_C0，ns_def1_C0，ns_data8_C1，ns_wen_C1，Kill_E，KillPipe_W，stall_R，clk)； output[70]ps_data_C1； inputps_width8_C0； inputps_use1_C0； inputns_width8_C0； inputns_def1_C0； input[70]ns_data8_C1； inputns_wen_C1； inputKill_E； inputKillPipe_W； outputStall_R； inputclk； wireps_addr_C0＝1′d0； wirens_addr_C0＝1′d0； wirens_wen_C2＝1′d1；/*********************************************************************** READPORTps***********************************************************************/ //computetheaddressmask wireps_addr_mask_C0＝1′d0； //maskedaddtesspipeline wire_ps_maddr_C0＝1′d0； //bank-qualifieduse wireps_usel_bank0_C0＝(ps_use1_C0&amp;(ps_maddr_C0＝＝(1′d0&amp;ps_addr_maskC0)))； //alignmentmuxforuse1 wire[70]ps_data_bank0_C1； assignps_data_C1[70]＝ps_data_bank0_C1；<dpn="d297"/>/*********************************************************************** WRITEPORTns***********************************************************************/ //computetheaddressmask wirens_addr_mask_C0＝1′d0； //bank-qualifiedwritedefforportns wirens_def1_bank0_C0＝(ns_def1_C0&amp;((ns_addr_C0&amp;ns_addr_mask_C0)＝＝(1′d0&amp;ns_addr_mask_C0)))； //writemuxfordef1 wire[70]ns_wdata_C1； assignns_wdata_C1＝{1{ns_data8_C1[70]}}； wireStall_R0；/*********************************************************************** PIPELINEDBANK***********************************************************************/ xmTIE_gfmod_State_bankTIE_gfmod_State_bank0(ps_data_bank0_C1， ps_use1_bank0_C0，ns_def1_bank0_C0，ns_wdata_C1[70]，ns_wen_C1， ns_wen_C2，Kill_E，KillPipe_W，Stall_R0，clk)； assignstall_R＝Stall_R0|1′b0；endmodulemodulexmTIE_gfmod_State_bank(ps_data_C1，ps_use1_C0，ns_def1_C0，ns_data_C1，ns_wen_C1，ns_wen_C2，Kill_E，KillPipe_W，Stall_R，clk)； output[70]ps_data_C1； inputps_use1_C0； inputns_def1_C0； input[70]ns_data_C1； inputns_wen_C1； inputns_wen_C2； inputKill_E； inputKillPipe_W； outputStall_R； inputclk； wireps_addr_C0＝1′d0； wireps_use2_C0＝1′d0； wirens_addr_C0＝1′d0； wirens_def2_C0＝1′d0； wire[70]ns_data_C2＝0； wirekill_C0＝KillPipe_W； wirekill_C1＝KillPipe_W|Kill_E； wirekill_C2＝KillPipe_W； wirekill_C3＝KillPipe_W； //writedefinitionpipeline wirens_ns_def1_C0＝ns_def1_C0&amp;1′b1&amp;-kill_C0； wirens_def1_C1；<dpn="d298"/> xtdelay1#(1)ins_def1_C1(ns_def1_C1，ns_ns_def1_C0，clk)； wirens_ns_def2_C0＝1′d0； wirens_def2_C1＝1′d0； wirens_ns_def2_C1＝1′d0； wirens_def2_C2＝1′d0； //writeenablepipeline wirens_we_C2； wirens_we_C3； wirens_ns_we_C1＝(1′d0|(ns_def1_C1&amp;ns_wen_C1))&amp;-kill_C1； wirens_ns_we_C2＝(ns_we_C2|(ns_def2_C2&amp;ns_wen_C2))&amp;-kill_C2； wirens_ns_we_C3＝(ns_we_C3|(1′d0&amp;1′d0))&amp;-kill_C3； xtdelay1#(1)ins_we_C2(ns_we_C2，ns_ns_we_C1，clk)； xtdelay1#(1)ins_we_C3(ns_we_C3，ns_ns_we_C2，clk)； //writeaddresspipeline wirens_addr_C1； wirens_addr_C2； wirens_addr_C3； assignns_addr_C1＝1′d0； assignns_addr_C2＝1′d0； assignns_addr_C3＝1′d0； //writedatapipeline wire[70]ns_result_C2； wire[70]ns_result_C3； wire[70]ns_mux_C1＝ns_data_C1； wire[70]ns_mux_C2＝ns_def2_C2？ns_data_C2ns_result_C2； xtdelay1#(8)ins_result_C2(ns_result_C2，ns_mux_C1，clk)； xtdelay1#(8)ins_result_C3(ns_result_C3，ns_mux_C2，clk)； wire[70]ps_data_C0； xtdelay1#(8)ips_data_C1(ps_data_C1，ps_data_C0，clk)； assignStall_R＝ ((ns_addr_C1＝＝ps_addr_C0)&amp;( (ps_use1_C0&amp;(ns_ns_def2_C1))))| 1′b0； //verificationregisterfilereplacement wire[70]xns_verify； xtenflop#(8)ns_verify(xns_verify，ns_result_C3，ns_ns_we_C3，clk)； xtflop#(8)ps_verify(ps_data_C0，xns_verify，clk)；endmodulemodulexmTIE_decoder(GFADD8，GFADD8I，GFMULX8，GFRWMOD8，LGF8_I，SGF8_I，LGF8_IU，SGF8_IU，LGF8_X，SGF8_X，LGF8_XU，SGF8_Xu，<dpn="d299"/>RUR0，WUR0，imm4，imm8，art_use，art_def，arS_use，ars_def，arr_use，arr_def，br_use，br_def，bs_use，bs_def，bt_use，bt_def，bs4-use，bs4_def，bs8_use，bs8_def，gr_use，gr_def，gs_use，gs_def，gt_use，gt_def，gfmod_use1，gfmod_def1，AR_rd0_use1，AR_rd0_width32，AR_rd1_use1，AR_rd1_width32，AR_wd_def1，AR_wd_width32，gf_rd0_addr，gf_rd0_use1，gf_rd0_width8，gf_rd1_addr，gf_rd1_use1，gf_rd1_width8，gf_rd2_addr，gf_rd2_use1，gf_rd2_width8，gf_wd_addr，gf_wd_def2，gf_wd_def1，gf_wd_width8，gf1_semantic，gf4_semantic，gf2_semantic，gf3_semantic，lgf_semantic，sgf_semantic，RUR0_semantic，WUR0_semantic，load_instruction，store_instruction，TIE_Inst，Inst)；<dpn="d300"/>outputGFADD8；outputGFADD8I；outputGFMULX8；outputGFRWMOD8；outputLGF8_I；outputSGF8_I；outputLGF8_IU；outputSGF8_IU；outputLGF8_X；outputSGF8_X；outputLGF8_XU；outputSGF8_XU；outputRUR0；outputWUR0；output[310]imm4；output[70]imm8；outputart_use；outputart_def；outputars_use；outputars_def；outputarr_use；outputarr_def；outputbr_use；outputbr_def；outputbs_use；outputbs_def；outputbt_use；outputbt_def；outputbs4_use；outputbs4_def；outputbs8_use；outputbs8_def；outputgr_use；outputgr_def；outputgs_use；outputgs_def；outputgt_use；outputgt_def；outputgfmod_use1；outputgfmod_def1；outputAR_rd0_use1；outputAR_rd0_width32；outputAR_rd1_use1；outputAR_rd1_width32；outputAR_wd_def1；outputAR_wd_width32；output[30]gf_rd0_addr；outputgf_rd0_use1；outputgf_rd0_width8；output[30]gf_rd1_addr；outputgf_rd1_use1；outputgf_rd1_width8；output[30]gf_rd2_addr；outputgf_rd2_use1；outputgf_rd2_width8；output[30]gf_wd_addr；outputgf_wd_def2；outputgf_wd_def1；outputgf_wd_width8；outputgf1_semantic；<dpn="d301"/>outputgf4_semantic；outputgf2_semantic；outputgf3_semantic；output1gf_semantic；outputsgf_semantic；outputRUR0_semantic；outputWUR0_semantic；outputload_instruction；outputstore_instruction；outputTIE_Inst；input[230]Inst；wire[30]op2＝{Inst[2320]}；wire[30]op1＝{Inst[1916]}；wire[30]op0＝{Inst[30]}；wireCUST0＝(op1＝＝4′b0110)&amp;QRST；assignGFADD8I＝(op2＝＝4′b0100)&amp;CUST0；assignGFMULX8＝(op2＝＝4′b0001)&amp;CUST0；assignGFRWMOD8＝(op2＝＝4′b0010)&amp;CUST0；wire[30]r＝{Inst[1512]}；wireLSCI＝(op0＝＝4′b0011)；assignLGF8_I＝(r＝＝4′b0000)&amp;LSCI；assignLGF8_IU＝(r＝＝4′b0010)&amp;LSCI；assignSGF8_IU＝(r＝＝4′b0011)&amp;LSCI；wireLSCX＝(op1＝＝4′b1000)&amp;QRST；assignLGF8_X＝(op2＝＝4′b0000)&amp;LSCX；assignSGF8_X＝(op2＝＝4′b0001)&amp;LSCX；assignLGF8_XU＝(op2＝＝4′b0010)&amp;LSCX；assignSGF8_XU＝(op2＝＝4′b0011)&amp;LSCX；wire[30]s＝{Inst[118]}；wire[30]t＝{Inst[74]}；wire[70]st＝{s，t}；wire[70]sr＝{r，s}；wireWUR＝(op2＝＝4′b1111)&amp;RST3；assigngfmod_use1＝GFMULX8|GFRWMOD8|RUR0|1′b0；assigngfmod_def1＝GFRWMOD8|WUR0|1′b0；assignAR_rd0_use1＝1′b0 |LGF8_I |SGF8_I |LGF8_IU |SGF8_IU |LGF8_X |SGF8_X |LGF8_XU |SGF8_XU；assignAR_rd0_width32＝1′b0；assignAR_rd1_use1＝1′b0 |LGF8_X |SGF8_X |LGF8_XU |SGF8_XU |WIR0；assignAR_rd1_width32＝1′b0；<dpn="d302"/>assignAR_wd_def1＝1′b0 |LGF8_IU |SGF8_IU |LGF8_XU |SGF8_XU |RUR0；assignAR_wd_width32＝1′b0；assigngf_rd0_use1＝1′b0 |GFADD8 |GFADD8I |GFMULX8；assigngf_rd0_width8＝1′b0；assigngf_rd1_use1＝1′b0 |GFADD8 |GFRWMOD8 |SGF8_I |SGF8_IU；assigngf_rd1_width8＝1′b0；assigngf_rd2_use1＝1′b0 |SGF8_X |SGF8_XU；assigngf_rd2_width8＝1′b0；assigngf_wd_def2＝1′b0 |LGF8_I |LGF8_IU |LGF8_X |LGF8_XU；assigngf_wd_def1＝1′b0 |GFADD8 |GFADD8I |GFMULX8 |GFRWMOD8；assigngf_wd_width8＝1′b0；assignart_def＝1′b0；assignart_use＝LGF8_X|SGF8_X|LGF8_XU|SGF8_XU|WURO|1′b0；assignars_def＝LGF8_IU|SGF8_IU|LGF8_XU|SGF8_XU|1′bo；assignars_use＝LGF8_I|SGF8_I|LGF8_IU|SGF8_IU|LGF8_X|SGF8_X|LGF8_XU|SGF8_XU|1′b0；assignarr_def＝RUR0|1′b0；assignarr_use＝1′b0；assignbr_def＝1′b0；assignbr_use＝1′b0；assignbs_def＝1′b0；assignbs_use＝1′b0；assignbt_def＝1′b0；assignbt_use＝1′b0；assignbs4_def＝1′b0；assignbs4_use＝1′b0；assignbs8_def＝1′b0；assignbs8_use＝1′b0；assigngr_def＝GFADD8|GFADD8I|GFMULX8|LGF8_X|LGF8_XU|1′b0；assigngr_use＝SGF8_X|SGF8_XU|1′b0；assigngs_def＝1′b0；assigngs_use＝GFADD8|GFADD8I|GFMULX8|1′b0；assigngt_def＝GFRWMOD8|LGF8_I|LGF8_IU|1′b0；assigngt_use＝GFADD8|GFRWMOD8|SGF8_I|SGF8_IU|1′b0；wire[30]gr_addr＝r；wire[30]gs_addr＝s；wire[30]gt_addr＝t；assigngf_wd_addr＝4′b0<dpn="d303"/> |{4{gr_def}}&amp;gr_addr |{4{gt_def}}&amp;gt_addr；assigngf_rd0_addr＝gs_addr；assigngf_rd1_addr＝gt_addr；assigngf_rd2_addr＝gr_addr；assigngf1_semantic＝GFADD8|1′b0；assigngf4_semantic＝GFADD8I|1′b0；assigngf2_semantic＝GFMULX8|1′b0；assigngf3_semantic＝GFRWMOD8|1′b0；assignlgf_semantic＝LGF8_I|LGF8_IU|LGF8_X|LGF8_XU|1′b0；assignsgf_semantic＝SGF8_|SGF8_IU|SGF8_X|SGF8_XU|1′b0；assignRUR0_semantic＝RUR0|1′b0；assignWUR0_semantic＝WUR0|1′b0；assignimm4＝t；wire[70]imm8＝{Inst[2316]}；assignload_instruction＝1′b0 |LGF8_I |LGF8_IU |LGF8_X |LGF8_XU；assignstore_instruction＝1′b0 |SGF8_I |SGF8_IU |SGF8_X |SGF8_XU；assignTIE_Inst＝1′b0 |GFADD8 |GFADD8I |GFMULX8 |GFRWMOD8 |LGF8_I |SGF8_I |LGF8_IU |SGF8_IU |GF8_X |SGF8_X |LGF8_XU |SGF8_XU |RUR0 |WUR0；endmodulemodulexmTIE_gf1(GFADD8_C0，gr_o_C1，gr_kill_c1，gs_i_C1，gt_i_C1，clk)；inputGFADD8_C0；output[70]gr_o_Cl；outputgr_kill_C1；input[70]gs_i_C1；input[70]gt_i_C1；inputclk；assigngr_o_C1＝(gs_i_C1)＾(gt_i_C1)；wireGFADD8_C1；xtdelay1#(1)iGFADD8_C1(.xtin(GFADD8_C0)，.xtout(GFADD8_C1)，.clk(clk))；assigngr_kill_C1＝(1′b0)&amp;(GFADD8_C1)；<dpn="d304"/>endmodulemodulexmTIE_gf4(GFADD8I_C0，gr_o_C1，gr_kill_C1，gs_i_C1，imm4_C0，clk)；inputGFADD8I_C0；output[70]gr_o_C1；outputgr_kill_C1；input[70]gs_i_C1；input[310]imm4_C0；inputclk；wire[310]imm4_C1；xtdelay1#(32)iimm4_C1(.xtin(imm4_C0)，.xtout(imm4_C1)，.clk(clk))；assigngr_o_C1＝(gs_i_C1)^(imm4_C1)；wireGFADD8I_C1；xtdelay1#(1)iGFADD8I_C1(.xtin(GFADD8I_C0)，.xtout(GFADD8I_C1)，.clk(clk))；assigngr_kill_C1＝(1′b0)&amp;(GFADD8I_C1)；endmodulemodulexmTIE_gf2(GFMUIX8_C0，gr_o_C1，gr_kill_C1，gs_i_C1，gfmod_ps_C1，clk)；inputGFMULX8_C0；output[70]gr_o_C1；outputgr_kill_C1；input[70]gs_i_C1；input[70]gfmod_ps_C1；inputclk；assigngr_o_C1＝(gs_i_C1[7])？(({gs_i_C1[60]，1′b0})^(gfmod_ps_C1))({gs_i_C1[60]，1′b0})；wireGFMULX8_C1；xtdelay1#(1)iGFMUIX8_C1(.xtin(GFMULX8_C0)，.xtout(GFMULX8_C1)，.clk(clk))；assigngr_kill_C1＝(1′b0)&amp;(GFMULX8_C1)；endmodulemodulexmTIE_gf3(GFRWMOD8_C0，gt_i_C1，gt_o_C1，gt_kill_C1，gfmod_ps_C1，gfmod_ns_C1，gfmod_kill_C1，clk)；inputGFRWMOD8_C0；input[70]gt_i_C1；output[70]gt_o_C1；<dpn="d305"/>outputgt_kill_C1；input[70]gfmod_ps_C1；output[70]gfmod_ns_C1；outputgfmod_kill_C1；inputclk；wire[70]t1_C1；assignt1_C1＝gt_i_C1；wire[70]t2_C1；agsignt2_C1＝gfmod_ps_C1；assigngfmod_ns_C1＝t1_C1；assigngt_o_C1＝t2_C1；wireGFRWMOD8C1；xtdelay1#(1)iGFRWMOD8_C1(.xtin(GFRWMOD8_C0)，.xtout(GFRWMOD8_C1)，.clk(clk))；assigngfmod_kill_C1＝(1′b0)&amp;(GFRWMOD8_C1)；assigngt_kill_C1＝(1′b0)&amp;(GFRWMOD8_C1)；endmodulemodulexmTIE_lgf(LGF8_I_C0，LGF8_IU_C0，LGF8_X_C0，LGF8_XU_C0，gt_o_C2，gt_kill_C2，ars_i_C1，ars_o_C1，ars_kill_C1，imm8_C0，gr_o_C2，gr_kill_C2，art_i_C1，MemDataIn8_C2，VAddrIn_C1，LSSize_C0，VAddrBase_C1，VAddrIndex_C1，VAddrOffset_C0，LSIndexed_C0，clk)；inputLGF8_I_C0；inputLGF8_IU_CO；inputLGF8_X_C0；inputLGF8_XU_C0；output[70]gt_o_C2；outputgt_kill_C2；input[310]ars_i_C1；output[310]ars_o_C1；outputars_kill_C1；input[70]imm8_C0；output[70]gr_o_C2；outputgr_kill_C2；input[310]art_i_C1；input[70]MemDataIn8_C2；input[310]VAddrIn_C1；output[40]LSSize_C0；output[310]VAddrBase_C1；output[310]VAddrIndex_C1；output[310]VAddrOffset_C0；<dpn="d306"/>outputLSIndexed_C0；inputclk；wireindexed_C0；assignindexed_C0＝(LGF8_X_C0)|(LGF8_XU_C0)；assignLSSize_C0＝32′h1；assignVAddrBase_C1＝ars_i_C1；assignLSIndexed_C0＝indexed_C0；assignVAddrOffset_C0＝imm8_C0；assignVAddrIndex_C1＝arti_C1；assigngt_o_C2＝MemDataIn8_C2；assigngr_o_C2＝MemDataIn8_C2；assignars_o_C1＝VAddrIn_C1；wireLGF8_I_C2；xtdelay2#(1)iLGF8_I_C2(.xtin(LGF8_I_C0)，.xtout(LGF8_I_C2)，.clk(clk))；wireLGF8_IU_C2；xtdelay2#(1)iLGF8_IU_C2(.xtin(LGF8_IU_C0)，.xtout(LGF8_IU_C2)，.clk(clk))；assigngt_ki1l_C2＝(1′b0)&amp;((LGF8_I_C2)|(LGF8_IU_C2))；wireLGF8_IU_C1；xtdelay1#(1)iLGF8_IU_C1(.xtin(LGF8_IU_C0)，.xtout(LGF8_IU_C1)，.clk(clk))；wireLGF8_XU_C1；xtdelay1#(1)iLGF8_XU_C1(.xtin(LGF8_XU_C0)，.xtout(LGF8_XU_C1)，.clk(clk))；assignars_kill_C1＝(1′b0)&amp;((LGF8_IU_C1)|(LGF8_XU_C1))；wireLGF8_X_C2；xtdelay2#(1)iLGF8_X_C2(.xtin(LGF8_X_C0)，.xtout(LGF8_X_C2)，.clk(clk))；wireLGF8_XU_C2；xtdelay2#(1)iLGF8_XU_C2(.xtin(LGF8_XU_C0)，.xtout(LGF8_XU_C2)，.clk(clk))；assigngr_kill_C2＝(1′b0)&amp;((LGF8_X_C2)|(LGF8_XU_C2))；endmodulemodulexmTIE_sgf(SGF8_I_C0，SGF8_IU_C0，SGF8_X_C0，SGF8_XU_C0，gt_i_C1，ars_i_C1，ars_o_C1，ars_kill_C1，imm8_C0，gr_i_C1，art_i_C1，VAddrIn_C1，LSSize_C0，MemDataOut_8_C1，VAddrBase_C1，VAddrIndex_C1，VAddrOffset_C0，LSIndexed_C0，clk)；inputSGF8_I_C0；inputSGF8_IU_C0；inputSGF8_X_C0；inputSGF8_XU_C0；input[70]gt_i_C1；input[310]ars_i_C1；<dpn="d307"/>output[310]ars_o_C1；outputars_kill_C1；input[70]imm8_C0；input[70]gr_i_C1;input[310]art_i_C1；input[310]VAddrIn_C1；output[40]LSSize_C0；output[70]MemDataOut8_C1；output[310]VAddrBase_C1；output[310]VAddrIndex_C1；output[310]VAddrOffset_C0；outputLSIndexed_C0；inputclk；wireindexed_C0；assignindexed_C0＝(SGF8_X_C0)|(SGF8_XU_C0)；assignLSSize_C0＝32′h1；assignVAddrBase_C1＝ars_i_C1；assignLSIndexed_C0＝indexedC0；assignVAddrOffset_C0＝imm8_C0；assignVAddrIndex_C1＝art_i_C1；wireSGF8_X_C1；xtdelay1#(1)iSGF8_X_C1(.xtin(SGF8_X_C0)，.xtout(SGF8_X_C1)，.clk(clk))；wireSGF8_XU_C1；xtdelay1#(1)iSGF8_XU_C1(.xtin(SGF8_XU_C0)，.xtout(SGF8_XU_C1)，.clk(clk))；assignMemDataOut8_C1＝((SGF8_X_C1)|(SGF8_XU_C1))？(gr_i_C1)(gt_i_C1)；assignars_o_C1＝VAddrIn_C1；wireSGF8_IU_C1；xtdelay1#(1)iSGF8_IU_C1(.xtin(SGF8_IU_C0)，.xtout(SGF8_IU_C1)，.clk(clk))；assignars_kill_C1＝(1′b0)&amp;((SGF8_IU_C1)|(SGF8_XU_C1))；endmodulemodulexmTIE_RUR0(RUR0_C0，arr_o_C1，arr_kill_C1，gfmod_ps_C1，clk)；inputRUR0_C0；output[310]arr_o_C1；outputarr_kill_C1；input[70]gfmod_ps_C1；inputclk；ass1gnarr_o_C1＝{gfmod_ps_C1}；wireRUR0_C1；xtdelay1#(1)iRUR0_C1(.xtin(RUR0_C0)，.xtout(RUR0_C1)，.clk(clk))；assignarr_kill_C1＝(1′b0)&amp;(RUR0_C1)；endmodulemodulexmTIE_WUR0(WUR0_C0，art_i_C1，gfmod_ns_Cl，gfmod_kill_C1，clk)；inputWUR0_C0；<dpn="d308"/>input[310]art_i_C1；output[70]gfmod_ns_C1；outputgfmod_kill_C1；inputclk；assigngfmod_ns_C1＝{art_i_C1[70]}；wireWUR0_C1；xtdelay1#(1)iWUR0_C1(.xtin(WUR0_C0)，.xtout(WUR0_C1)，.clk(clk))；assigngfmod_kill_C1＝(1′b0)&amp;(WUR0_C1)；endmodulemodulexmTIE(TIE_inst_R，TIE_asRead_R，TIE_atRead_R，TIE_atWrite_R，TIE_arWrite_R，TIE_asWrite_R，TIE_aWriteM_R，TIE_aDataKill_E，TIE_aWriteData_E，TIE_aDataKill_M，TIE_aWriteData_M，TIE_Load_R，TIE_Store_R，TIE_LSSize_R，TIE_LSIndexed_R，TIE_LSOffset_R，TIE_MemLoadData_M，TIE_MemStoreData8_E，TIE_MemStoreData16_E，TIE_MemStoreData32_E，TIE_MemStoreData64_E，TIE_MemStoreData128_E，TIE_Stall_R，TIE_Exception_E，TIE_ExcCause_E，TIE_bsRead_R，TIE_btRead_R，TIE_btWrite_R，TIE_brWrite_R，TIE_bsWrite_R，TIE_bsReadSize_R，TIE_btReadSize_R，TIE_bWriteSize_R，TIE_bsReadData_E，TIE_btReadData_E，TIE_bWriteData1_E，TIE_bWriteData2_E，TIE_bWriteData4_E，TIE_bWriteData8_E，TIE_bWriteData16_E，TIE_bDataKill_E，CpEnable，Instr_R，SBus_ETBus_E，MemOpAddr_E，Kill_E，Except_W，Replay_W，<dpn="d309"/>G1WCLK，Reset)；outputTIE_inst_R；outputTIE_asRead_R；outputTIE_atRead_R；outputTIE_atWrite_R；outputTIE_arWrite_R；outputTIE_asWrite_R；outputTIE_aWriteM_R；outputTIE_aDataKill_E；output[310]TIEaWriteData_E；outputTIE_aDataKill_M；output[310]TIE_aWriteData_M；outputTIE_Load_R；outputTIE_Store_R；output[40]TIE_LSSize_R；outputTIE_LSIndexed_R；output[310]TIELSOffset_R；input[1270]TIEMemLoadData_M；output[70]TIEMemStoreData8_E；output[150]TIEMemStoreData16_E；output[310]TIEMemStoreData32_E；output[630]TIEMemStoreData64_E；output[1270]TIEMemStoreData128_E；outputTIE_Stall_R；outputTIE_Exception_E；output[50]TIE_ExcCause_E；outputTIEbsReadR；outputTIE_btRead_R；outputTIE_btWrite_R；outputTIE_brWrite_R；outputTIE_bsWrite_R；output[40]TIE_bsReadSize_R；output[40]TIE_btReadSize_R；output[40]TIE_bWriteSize_R；input[150]TIE_bsReadData_E；input[150]TIE_btReadData_E；outputTIE_bWriteData1_E；output[10]TIEbWriteData2_E；output[30]TIEbWriteData4_E；output[70]TIEbWriteData8_E；output[150]TIEbWriteData16_E；outputTIE_bDataKill_E；input[70]CPEnable；input[230]Instr_R；input[310]SBus_E；input[310]TBus_E；input[310]MemOpAddr_E；inputKill_E；inputExcept_W；inputReplay_W；inputG1WCLK；inputReset；//unusedsignalswireTMode＝0；//controlsignalswireKillPipe_W；<dpn="d310"/>wireclk；//decodedsignalswireGFADD8_C0；wireGFADD8I_C0；wireGFMULX8_C0；wireGFRWMOD8_C0；wireLGF8_I_C0；wireSGF8_I_C0；wireLGF8_IU_C0；wireSGF8_IU_C0；wireLGF8_X_C0；wireSGF8_X_C0；wireLGF8_XU_C0；wireSGF8_XU_C0；wireRUR0_C0；wireWUR0_C0；wire[310]imm4_C0；wire[70]imm8_C0；wireart_use_C0；wireart_def_C0；wirears_use_C0；wirears_def_C0；wirearr_use_C0；wirearr_def_C0；wirebr_use_C0；wirebr_def_C0；wirebs_use_C0；wirebs_def_C0；wirebt_use_C0；wirebt_def_C0；wirebs4_useC0；wirebs4_def_C0；wirebs8_use_C0；wirebs8_def_C0；wiregr_use_C0；wiregr_def_C0；wiregs_use_C0；wiregs_def_C0；wiregt_use_C0；wiregt_def_C0；wiregfmod_use1_C0；wiregfmod_def1_C0；wireAR_rd0_use1_C0；wireAR_rd0_width32_C0；wireAR_rd1_use1_C0；wireAR_rd1_width32_C0；wireAR_wd_def1_C0；wireAR_wd_width32_C0；wire[30]gf_rd0_addr_C0；wiregf_rd0_use1_C0；wiregf_rd0_width8_C0；wire[30]gf_rd1_addr_C0；wiregf_rd1_usel_C0；wiregf_rd1_width8_C0；wire[30]gf_rd2_addr_C0；wiregf_rd2_use1_C0；wiregf_rd2_width8_C0；wire[30]gf_wd_addr_C0；wiregf_wd_def2_C0；<dpn="d311"/>wiregf_wd_def1_C0；wiregf_wd_width8_C0；wiregf1_semantic_C0；wiregf4_semantic_C0；wiregf2_semantic_C0；wiregf3_semantic_C0；wirelgf_semantic_C0；wiresgf_semantic_C0；wireRUR0_semantic_C0；wireWUR0_semantic_C0；wireload_instruction_C0；wirestore_instructior_C0；wireTIE_Inst_C0；wire[230]Inst_C0；//statedata，write-enableandstallsignalswire[70]gfmod_ps_C1；wire[70]gfmod_ns_C1；wiregfmod_kill_C1；wiregfmod_stall_C1；//registerdata，write-enableandstallsignalswire[310]AR_rd0_data_C1；wire[310]AR_rd1_data_C1；wire[310]AR_wd_data32_C1；wireAR_wd_kill_C1；wire[70]gf_rd0_data_C1；wire[70]gf_rd1_data_C1；wire[70]gf_rd2_data_C1；wire[70]gf_wd_data8_C2；wiregf_wd_kill_C2；wire[70]gf_wd_data8_C1；wiregf_wd_kill_C1；wiregf_Stall_C1；//operandswire[310]art_i_C1；wire[310]art_o_C1；wireart_kill_C1；wire[310]ars_i_C1；wire[310]ars_o_C1；wirears_kill_C1wire[310]arr_o_C1；wirearr_kill_C1；wire[70]gr_i_C1；wire[70]gr_o_C2；wiregr_kill_C2；wire[70]gr_o_C1；wiregr_kill_C1；wire[70]gs_i_C1；wire[70]gt_i_C1；wire[70]gt_o_C2；wiregt_kill_C2；wire[70]gt_o_C1；wiregt_kill_C1；//outputstateofsemanticgf1//outputinterfaceofsemanticgf1<dpn="d312"/>//outputoperandofsemanticgf1wire[70]gf1_gr_o_C1；wiregfl_gr_kill_C1；//outputstateofsemanticgf4//outputinterfaceofsemanticgf4//outputoperandofsemanticgf4wire[70]gf4_gr_o_C1；wiregf4_gr_kill_C1；//outputstateofsemanticgf2//outputinterfaceofsemanticgf2//outputoperandofsemanticgf2wire[70]gf2_gr_o_C1；wiregf2_gr_kill_C1；//outputstateofsemanticgf3wire[70]gf3_gfmod_ns_C1；wiregf3_gfmod_kill_C1；//outputinterfaceofsemanticgf3//outputoperandofsemanticgf3wire[70]gf3_gt_o_C1；wiregf3_gt_kill_C1；//outputstateofsemanticlgf//outputinterfaceofsemanticlgfwire[40]lgf_LSSize_C0；wire[310]lgf_VAddrBase_C1；wire[310]lgf_VAddrIndex_C1；wire[310]lgf_VAddrOffset_C0；wirelgf_LSIndexed_C0；//outputoperandofsemanticlgfwire[70]lgf_gt_o_C2；wirelgf_gt_kill_C2；wire[310]lgf_ars_o_C1；wirelgf_ars_kill_C1；wire[70]lgf_gr_o_C2；wirelgf_gr_kill_C2；//outputstateofsemanticsgf//outputinterfaceofsemanticsgfwire[40]sgf_LSSize_C0；wire[70]sgf_MemDataOut8_C1；wire[310]sgf_VAddrBase_C1；wire[310]sgf_VAddrIndex_C1；wire[310]sgf_VAddrOffset_C0；wiresgf_LSIndexed_C0；//outputoperandofsemanticsgfwire[310]sgf_ars_o_C1；wiresgf_ars_kill_C1；<dpn="d313"/>//outputstateofsemanticRUR0//outputinterfaceofsemanticRUR0//outputoperandofsemanticRUR0wire[310]RUR0_arr_o_C1；wireRUR0_arr_kill_C1；//outputstateofsemanticWUR0wire[70]WUR0_gfmod_ns_C1；wireWUR0_gfmod_kill_C1；//outputinterfaceofsemanticWUR0//outputoperandofsemanticWUR0//TIE-definedinterfacesignalswire[310]VAddr_C1；wire[310]VAddrBase_C1；wire[310]VAddrOffset_C0；wire[310]VAddrIndex_C1；wire[310]VAddrIn_C1；wire[40]LSSize_C0；wireLSIndexed_C0；wire[1270]MemDataIn128_C2；wire[630]MemDataIn64_C2；wire[310]MemDataIn32_C2；wire[150]MemDataIn16_C2；wire[70]MemDataIn8_C2；wire[1270]MemDataOut128_C1；wire[630]MemDataOut64_C1；wire[310]MemDataOut32_C1；wire[150]MemDataOut16_C1；wire[70]MemDataOut8_C1；wireException_C1；wire[50]ExcCause_C1；wire[70]CPEnable_C1； xtflop#(1)reset(localReset，Reset，G1WCLK)；xmTIE_decoderTIE_decoder( .GFADD8(GFADD8_C0)， .GFADD8I(GFADD8I_C0)， .GFMULX8(GFMULX8_C0)， .GFRWMOD8(GFRWMOD8_C0)， .LGF8_I(LGF8_I_C0)， .SGF8_I(SGF8_I_C0)， .LGF8_IU(LGF8_IU_C0)， .SGF8_IU(SGF8_IU_C0)， .LGF8_X(LGF8_X_C0)， .SGF8_X(SGF8_X_C0)， .LGF8_XU(LGF8_XU_C0)， .SGF8_XU(SGF8_XU_C0)， .RUR0(RUR0_C0)， .WUR0(WUR0_C0)， .imm4(imm4_C0)， .imm8(imm8_C0)， .art_use(art_use_C0)， .art_def(art_def_C0)， .ars_use(ars_use_C0)，<dpn="d314"/> .ars_def(ars_def_C0)， .arr_use(arr_use_C0)， .arr_def(arr_def_C0)， .br_use(br_use_C0)， .brdef(br_def_C0)， .bs_use(bs_use_C0)， .bs_def(bs_def_C0)， .bt_use(bt_use_C0)， .bt_def(bt_def_C0)， .bs4_use(bs4_use_C0)， .bs4_def(bs4_def_C0)， .bs8_use(bs8_use_C0)， .bs8_def(bs8_def_C0)， .gr_use(gr_use_C0)， .gr_def(gr_def_C0)， .gs_use(gs_use_C0)， .gs_def(gs_def_C0)， .gt_use[gt_use_C0)， .gt_def(gt_def_C0)， .gfmod_use1(gfmod_use1_C0)， .gfmod_def1(gfmod_def1_C0)， .AR_rd0_use1(AR_rd0_use1_C0)， .AR_rd0_width32(AR_rd0_width32_C0)， .AR_rd1_use1(AR_rd1_use1_C0)， .AR_rd1_width32(AR_rd1_width32_C0)， .AR_wd_def1(AR_wd_def1_C0)， .AR_wd_width32(AR_wd_width32_C0)， .gf_rd0_addr(gf_rd0_addr_C0)， .gf_rd0_use1(gf_rd0_use1_C0)， .gf_rd0_width8(gf_rd0_width8_C0)， .gf_rd1_addr(gf_rd1_addr_C0)， .gf_rd1_use1(gf_rd1_use1_C0)， .gf_rd1_width8(gf_rd1_width8_C0)， .gf_rd2_addr(gf_rd2_addr_C0)， .gf_rd2_use1(gf_rd2_use1_C0)， .gf_rd2_width8(gf_rd2_width8_C0)， .gf_wd_addr(gf_wd_addr_C0)， .gf_wd_def2(gf_wd_def2_C0)， .gf_wd_def1(gf_wd_def1_C0)， .gf_wd_width8(gf_wd_width8_C0)， .gf1_semantic(gf1_semantic_C0)， .gf4_semantic(gf4_semantic_C0)， .gf2_semantic(gf2_semantic_C0)， .gf3_semantic(gf3_semantic_C0)， .lgf_semantic(lgf_semantic_C0)， .sgf_semantic(sgf_semantic_C0)， .RUR0_semantic(RUR0_semantic_C0)， .WUR0_semantic(WUR0_semantic_C0)， .load_instruction(load_instruction_C0)， .store_instruction(store_instruction_C0)， .TIE_Inst(TIE_Inst_C0)， .Inst(Inst_C0))；xmTIE_gf1TIE_gf1( .GFADD8_C0(GFADD8_C0)， .gr_o_C1(gf1_gr_o_C1)， .gr_kill_C1(gf1_gr_kill_C1)， .gs_i_C1(gs_i_C1)， .gt_i_C1(gt_i_C1)，<dpn="d315"/> .clk(clk))；xmTIE_gf4TIE_gf4( .GFADD8I_C0(GFADD8I_C0)， .gr_o_C1(gf4_gr_o_C1)， .gr_kill_C1(gf4_gr_kill_C1)， .gs_i_C1(gs_i_C1)， .imm4_C0(imm4_C0)， .clk(clk))；xmTIE_gf2TIE_gf2( .GFMULX8_C0(GFMULX8_C0)， .gr_o_C1(gf2_gr_o_C1)， .gr_kill_C1(gf2_gr_kill_C1)， .gs_i_C1(gs_i_C1)， .gfmod_ps_C1(gfmod_ps_C1)， .clk(clk))；xmTIE_gf3TIE_gf3( .GFRWMOD8_C0(GFRWMOD8_C0)， .gt_i_C1(gt_i_C1)， .gt_o_C1(gf3_gt_o_C1)， .gt_kill_C1(gf3_gt_kill_C1)， .gfmod_ps_C1(gfmod_ps_C1)， .gfmod_ns_C1(gf3_gfmod_ns_C1)， .gfmod_kill_C1(gf3_gfmod_kill_C1)， .clk(clk))；xmTIE_lgf_TIE_1gf( .LGF8_I_C0(LGF8_I_C0)， .LGF8_IU_C0(LGF8_IU_C0)， .LGF8_X_C0(LGF8_X_C0)， .LGF8_XU_C0(LGF8_XU_C0)， .gt_o_C2(lgf_gt_o_C2)， .gt_kill_C2(lgf_gt_kill_C2)， .ars_i_C1(ars_i_C1)， .ars_o_C1(lgf_ars_o_C1)， .ars_kill_C1(lgf_ars_kill_C1)， .imm8_C0(imm8_C0)， .gr_o_C2(lgf_gr_o_C2)， .gr_kill_C2(lgf_gr_kill_C2)， .art_i_C1(art_i_C1)， .MemDataIn8_C2(MemDataIn8_C2)， .VAddrIn_C1(VkddrIn_C1)， .LSSize_C0(lgf_LSSize_C0)， .VAddrBase_C1(lgf_VAddrBase_C1)， .VAddrIndex_C1(lgf_VAddrIndex_1)， .VAddrOffset_C0(lgf_VAddrOffset_0)， .LSIndexed_C0(lgf_LSIndexed_C0)， .clk(clk))；xmTIE_sgfTIE_sgf( .SGF8_I_C0(SGF8_I_C0)， .SGF8_IU_C0(SGF8_IU_C0)， .SGF8_X_C0(SGF8_X_C0)， .SGF8_XU_C0(SGF8_XU_C0)， .gt_i_C1(gt_i_C1)， .ars_i_C1(ars_i_C1)， .ars_o_C1(sgf_ars_o_C1)， .ars_kill_C1(sgf_ars_kill_C1)，<dpn="d316"/> .imm8_C0(imm8_C0)， .gr_i_C1(gr_i_C1)， .art_i_C1(art_i_C1)， .VAddrIn_C1(VAddrIn_C1)， .LSSize_C0(sgf_LSSize_C0)， .MemDataOut8_C1(sgf_MemDataOut8_C1)， .VAddrBase_C1(sgf_VAddrBase_C1)， .VAddrIndex_Cl(sgf_VAddrIndex_C1)， .VAddrOffset_C0(sgf_VAddrOffset_C0)， .LSIndexed_C0(sgf_LSIndexed_C0)， .clk(clk))；xmTIE_RUR0TIE_RUR0( .RUR0_C0(RUR0_C0)， .arr_o_C1(RUR0_arr_o_C1)， .arr_kill_C1(RUR0_arr_kill_C1)， .gfmod_ps_C1(gfmod_ps_C1)， .clk(clk))；xmTIE_WUR0TIE_WUR0( .WUR0_C0(WUR0_C0)， .art_i_C1(art_i_C1)， .gfmod_ns_C1(WUR0_gfmod_ns_C1)， .gfmod_kill_C1(WUR0_gfmod_kill_C1)， .clk(clk))；xmTIE_gfmod_StateTIE_gfmod_State( .ps_width8_C0(1′b1)， .ps_use1_C0(gfmod_use1_C0)， .ps_data_C1(gfmod_ps_C1)， .ns_width8_C0(1′b1)， .ns_def1_C0(gfmod_def1_C0)， .ns_data8_C1(gfmod_ns_C1)， .ns_wen_Cl(-gfmod_kill_C1)， .Kill_E(Kill_E)， .KillPipe_W(KillPipe_W)， .Stall_R(gfmod_Stall_C1)， .clk(clk))；xmTIE_gf_RegfileTIE_gf_Regfile( .rd0_addr_C0(gf_rd0_addr_C0)， .rd0_use1_C0(gf_rd0_use1_C0)， .rd0_data_C1(gf_rd0_data_C1)， .rd0_width8_C0(gf_rd0_width8_C0)， .rd1_addr_C0(gf_rd1_addr_C0)， .rd1_use1_C0(gf_rd1_use1_C0)， .rd1_data_C1(gf_rd1_data_C1)， .rd1_width8_C0(gf_rd1_width8_C0)， .rd2_addr_C0(gf_rd2_addr_C0)， .rd2_use1_C0(gf_rd2_use1_C0)， .rd2_data_C1(gf_rd2_data_C1)， .rd2_width8_C0(gf_rd2_width8_C0)， .wd_addr_C0(gf_wd_addr_C0)， .wd_def2_C0(gf_wd_def2_C0)， .wd__wen_C2(-gf_wd_kill_C2)， .wd_data8_C2(gf_wd_data8_C2)， .wd_def1_C0(gf_wd_def1_C0)， .wd_wen_C1(-gf_wd_kill_C1)， .wd_data8_C1(gf_wd_data8_C1)，<dpn="d317"/> .wd_width8_C0(gf_wd_width8_C0)， .Kill_E(Kill_E)， .KillPipe_W(KillPipe_W)， .Stall_R(gf_Stall_C1)， .clk(clk))；//StalllogicassignTIE_Stall_R＝1′b0 |gf_Stall_C1 |gfmod_Stall_C1；//pipelinesemanticselectsignalstoeachstagewirelgf_semantic_C1；xtdelay1#(1)ilgf_semantic_C1(.xtin(lgf_semantic_C0)，xtout(lgf_semantic_C1)，.clk(clk))；wiresgf_semantic_C1；xtdelayl#(1)isgf_semantic_C1(.xtin(sgf_semantic_C0)，.xtout(sgf_semantic_C1)，.clk(clk))；wiregf3_semantic_C1；xtdelay1#(1)igf3_semantic_C1(.xtin(gf3_semantic_C0)，.xtout(gf3_semantic_C1)，.clk(clk))；wireWUR0_semantic_C1；xtdelay1#(1)iWUR0_semantic_C1(.xtin(WUR0_semantic_C0)，.xtout(WUR0_semantic_C1)，.clk(clk))；wireRUR0_semantic_C1；xtdelay1#(1)iRUR0_semantic_C1(.xtin(RUR0_semantic_C0)，.xtout(RUR0_semantic_C1)，.clk(clk))；wirelgf_semantic_C2；xtdelay2#(1)ilgf_semantic_C2(.xtin(lgf_semantic_C0)，.xtout(lgf_semantic_C2)，.clk(clk))；wiregf1_semantic_C1；xtdelay1#(1)igf1_semantic_C1(.xtin(gf1_semantic_C0)，.xtout(gf1_semantic_C1)，.clk(clk))；wiregf4_semantic_C1；xtdelay1#(1)igf4_semantic_C1(.xtin(gf4_semantic_C0)，.xtout(gf4_semantic_C1)，.clk(clk))；wiregf2_semantic_C1；xtdelay1#(1)igf2_semantic_C1(.xtin(gf2_semantic_C0)，.xtout(gf2_semantic_C1)，.clk(clk))；//combineoutputinterfacesignalsfromallsemanticsassignVAddr_C1＝32′b0；assignVAddrBase_C1＝32′b0 |(lgf_VAddrBase_C1&amp;{32{lgf_semantic_C1}}) |(sgf_VAddrBase_C1&amp;{32{sgf_semantic_C1}})；assignVAddrOffset_C0＝32′b0 |(lgf_VAddrOffset_C0&amp;{32{lgf_semantic_C0}}) |(sgf_VAddrOffset_C0&amp;{32{sgf_sematic_C0}})；assignVAddrIndex_C1＝32′b0 |(lgf_VAddrIndex_C1&amp;{32{lgf_semantic_C1}}) |(sgf_VAddrIndex_C1&amp;{32{sgf_semantic_C1}})；assignLSSize_C0＝5′b0 |(lgf_LSSize_C0&amp;{5{lgf_semantic_C0}}) |(sgf_LSSize_C0&amp;{5{sgf_semantic_C0}})；assignLSIndexed_C0＝1′b0 |(lgf_LSIndexed_C0&amp;lgf_semantic_C0) |(sgf_LSIndexed_C0&amp;sgf_semantic_C0)；assignMemDataOut128_C1＝128′b0；assignMemDataOut64_C1＝64′b0；<dpn="d318"/>assignMemDataOut32_C1＝32′b0；assignMemDataOut16_C1＝16′b0；assignMemDataOut8_C1＝8′b0 |(sgf_MemDataOut8_C1&amp;{8{sgf_semantic_C1}})；assignException_C1＝1′b0；assignExcCause_C1＝6′b0；//combineoutputstatesignalsfromallsemanticsassigngfmod_ns_C1＝8′b0 |(gf3_gfmod_ns_C1&amp;{8{gf3_semantic_C1}}) |(WUR0_gfmod_ns_C1&amp;{8{WUR0_semantic_C1}})；assigngfmod_kill_C1＝1′b0 |(gf3_gfmod_kill_C1&amp;gf3_semantic_C1) |(WUR0_gfmod_kill_C1&amp;WUR0_semantic_C1)；//combineoutputoperandsignalsfromallsemanticsassignart_o_C1＝32′b0；assignart_kill_C1＝1′b0；assignars_o_C1＝32′b0 |(lgf_ars_o_C1&amp;{32{lgf_semantic_C1}}) |(sgf_ars_o_C1&amp;{32{sgf_semantic_C1}})；assignars_kill_C1＝1′b0 |(lgf_ars_kill_C1&amp;lgf_semantic_C1) |(sgf_ars_kill_C1&amp;sgf_semantic_C1)；assignarr_o_C1＝32′b0 |(RUR0_arr_o_C1&amp;{32{RUR0_semantic_C1}})；assignarr_kill_C1＝1′b0 |(RUR0_arr_kill_C1&amp;RUR0_semantic_C1)；assigngr_o_C2＝8′b0 |(lgf_gr_o_C2&amp;{8{lgf_semantic_C2}})；assigngr_kill_C2＝1′b0 |(lgf_gr_kill_C2&amp;lgf_semantic_C2)；assigngr_o_C1＝8′b0 |(gf1_gr_o_C1&amp;{8{gf1_semantic_C1}}) |(gf4_gr_o_C1&amp;{8{gf4_semantic_C1}}) |(gf2_gr_o_C1&amp;{8{gf2_semantic_C1}})；assigngr_kill_C1＝1′b0 |(gf1_gr_kill_C1&amp;gf1_semantic_C1) |(gf4_gr_kill_C1&amp;gf4_semantic_C1) |(gf2_gr_kill_C1&amp;gf2_semantic_C1)；assigngt_o_C2＝8′b0 |(1gf_gt_c_C2&amp;{8{lgf_semantic_C2}})；assigngt_kill_C2＝1′b0 |(lgf_gt_kill_C2&amp;lgf_semantic_C2)；assigngt_o_C1＝8′b0 |(gf3_gt_o_C1&amp;{8{gf3_semantic_C1}})；assigngt_kill_C1＝1′b0 |(gf3_gt_kill_C1&amp;gf3_semantic_C1)；//outputoperandtowriteportmappinglogicassignAR_wd_data32_C1＝ars_o_C1|arr_o_C1|32′b0；assignAR_wd_kill_C1＝ars_kill_C1|arr_kill_C1|1′b0；assigngf_wd_data8_C2＝gt_o_C2|gr_o_C2|8′b0；assigngf_wd_kill_C2＝gt_kill_C2|gr_kill_C2|1′b0；assigngf_wd_data8_C1＝gr_o_C1|gt_o_C1|8′b0；assigngf_wd_kill_C1＝gr_kill_C1|gt_kill_C1|1′b0；//readporttoinputoperandmapping1ogicassignars_i_C1＝AR_rd0_data_C1；assignart_i_C1＝AR_rd1_data_C1；<dpn="d319"/>assigngs_i_C1＝gf_rd0_data_C1；assigngt_i_C1＝gf_rd1_data_C1；assigngr_i_C1＝gf_rd2_data_C1；//logictosupportverificationwireignore_TIE_aWriteData_E＝-(AR_wd_def1_C0&amp;(TIE_arWrite_R|TIE_asWrite_R|TIE_atWrite_R)&amp;-TIE_aDataKill_E)；wireignore_TIE_aWriteData_M＝-(1′b0&amp;(TIE_arWrite_R|TIE_asWrite_R|TIE_atWrite_R)&amp;-TIE_aDataKill_M)；wireignore_TIE_bWriteData_E＝(-TIE_btWrite_R&amp;-TIE_btWrite_R)|TIE_bDataKill_E；wireignore_TIE_bWriteData16_E＝ignore_TIE_bWriteData_E；wireignore_TIE_bWriteData8_E＝ignore_TIE_bWriteData_E；wireignore_TIE_bWriteData4_E＝ignore_TIE_bWriteData_E；wireignore_TIE_bWriteData2_E＝ignore_TIE_bWriteData_E；wireignore_TIE_bWriteData1_E＝ignore_TIE_bWriteData_E；wireignore_TIE_LSSize_R＝-TIE_Load_R&amp;-TIE_Store_R；wireignore_TIE_LSIndexed_R＝-TIE_Load_R&amp;-TIE_Store_R；wireignore_TIE_LSOffset_R＝-TIE_Load_R&amp;-TIE_Store_R|TIE_LSIndexed_R；wireignore_TIE_MemStoreData128_E＝(TIE_LSSize_R！＝5′b10000)|-TIE_Store_R；wireignore_TIE_MemStoreData64_E＝(TIE_LSSize_R！＝5′b01000)|-TIE_Store_R；wireignore_TIE_MemStoreData32_E＝(TIE_LSSize_R！＝5′b00100)|-TIE_Store_R；wireignore_TIE_MemStoreData16_E＝(TIE_LSSize_R！＝5′b00010)|-TIE_Store_R；wireignore_TIE_MemStoreData8_E＝(TIE_LSSize_R_！＝5′b00001)|-TIE_Store_R；//clockandinstructionsassignclk＝G1WCLK；assignInst_C0＝Instr_R；asgignTIE_inst_R＝TIE_Inst_C0；//AR-relatedsignalsto/fromcoreassignTIE_asRead_R＝ars_use_C0；assignTIE_atRead_R＝art_use_C0；assignTIE_atWrite_R＝art_def_C0；assignTIE_arWrite_R＝arr_def_C0；assignTIE_asWrite_R＝ars_def_C0；assignTIE_aWriteM_R＝0；assignTIE_aWriteData_E＝ignore_TIE_aWriteData_E？0AR_wd_data32_C1；assignTIE_aWriteData_M＝ignore_TIE_aWriteData_M？00；assignTIE_aDataKill_E＝AR_wd_kill_C1；assignTIE_aDataKill_M＝0；assignAR_rd0_data_C1＝SBus_E；assignAR_rd1_data_C1＝TBus_E；//BR-relatedsignalsto/fromcoreassignTIE_bsRead_R＝1′b0|bs_use_C0|bs4_use_C0|bs8_use_C0；assignTIE_btRead_R＝1′b0|bt_use_C0；assignTIE_btWrite_R＝1′b0|bt_def_C0；assignTIE_bsWrite_R＝1′b0|bs_def_C0|bs4_def_C0|bs8_def_C0；assignTIE_brWrite_R＝1′b0|br_def_C0；assignTIE_bWriteData16_E＝ignore_TIE_bWriteData16_E？00；assignTIE_bWriteData8_E＝ignore_TIE_bWriteData8_E？00；assignTIE_bWriteData4_E＝ignore_TIE_bWriteData4_E？00；assignTIE_bWriteData2_E＝ignore_TIE_bWriteData2_E？00；assignTIE_bWriteData1_E＝ignore_TIE_bWriteData1_E？00；<dpn="d320"/>assignTIE_bDataKill_E＝0；assignTIE_bWriteSize_R＝{1′b0，1′b0，1′b0，1′b0，1′b0}；assignTIE_bsReadSize_R＝{1′b0，1′b0，1′b0，1′b0，1′b0}；assignTIE_btReadSize_R＝{1′b0，1′b0，1′b0，1′b0，1′b0}；//Load/storesignalsto/fromcoreassignTIE_Load_R＝load_instruction_C0；assignTIE_Store_R＝store_instruction_C0；assignTIE_LSSize_R＝ignore_TIE_LSSize_R？0LSSize_C0；assignTIE_LSIndexed_R＝ignore_TIE_LSIndexed_R？0LSIndexed_C0；assignTIE_LSOffset_R＝ignore_TIE_LSOffseT_R？0VAddrOffseT_C0；assignTIE_MemStoreData128_E＝ignore_TIE_MemStoreData128_E？0MemDataOut128_C1；assignTIE_MemStoreData64_E＝ignore_TIE_MemStoreData64_E？0MemDataOut64_C1；assignTIE_MemStoreData32_E＝ignore_TIE_MemStoreData32_E？0MemDataOut32_C1；assignTIE_MemStoreData16_E＝ignore_TIE_MemStoreData16_E？0MemDataOut16_C1；assignTIE_MemStoreData8_E＝ignore_TIE_MemStoreData8_E？0MemDataOut8_C1；assignMemDataIn128_C2＝TIE_MemLoadData_M；assignMemDataIn64_C2＝TIE_MemLoadData_M；assignMemDataIn32_C2＝TIE_MemLoadData_M；assignMemDataIn16_C2＝TIE_MemLoadData_M；assignMemDataIn8_C2＝TIE_MemLoadData_M；assignVAddrIn_C1＝MemOpAddr_E；//CPEnableandcontrolsignalsto/fromcoreassignCPEnable_C1＝CPEnable；assignTIE_Exception_E＝Exception_C1；assignTIE_ExcCause_E＝ExcCause_C1；assignKillPipe_W＝Except_W|Replay_W；endmodulemodulextdelay1(xtout，xtin，clk)；parametersize＝1；output[size-10]xtout；input[size-10]xtin；inputclk； assignxtout＝xtin；endmodulemodulextdelay2(xtout，xtin，clk)；parametersize＝1；output[size-10]xtout；input[size-10]xtin；inputclk； assignxtout＝xtin；endmodulemodulextRFenlatch(xtRFenlatchout，xtin，xten，clk)； parametersize＝32； output[size-10]xtRFenlatchout； input[size-10]xtin； inputxten； inputclk； reg[size-10]xtRFenlatchout；always@(clkorxtenorxtinorxtRFenlatchout)begin<dpn="d321"/> if(clk)begin xtRFenlatchout＜＝#1(xten)？xtinxtRFenlatchout； endendendmodulemodulextRFlatch(xtRFlatchout，xtin，clk)； parametersize＝32； output[size-10]xtRFlatchout； input[size-10]xtin； inputclk； reg[size-10]xtRFlatchout； always@(clkorxtin)begin if(clk)begin xtRFlatchout＜＝#1xtin； endendendmodulemodulextadd(xtout，a，b)；parametersize＝32；output[size-10]xtout；input[size-10]a；input[size-10]b；assignxtout＝a+b；endmodulemodulextaddc(sum，carry，a，b，c)； parametersize＝32； output[size-10]sum； outputcarry； input[size-10]a； input[size-10]b； inputc； wirejunk； assign{carry，sum，junk}＝{a，c}+{b，c}；endmodulemodulextaddcin(xtout，a，b，c)； parametersize＝32； output[size-10]xtout； input[size-10]a； input[size-10]b； inputc； assignxtout＝({a，c}+{b，c})＞＞1；endmodulemodulextaddcout(sum，carry，a，b)； parametersize＝1； output[size-10]sum；<dpn="d322"/> outputcarry； input[size-10]a； input[size-10]b； assign{carry，sum}＝a+b；endmodulemodulextbooth(out，cin，a，b，sign，negate)；parametersize＝16；output[size+10]out；outputcin；input[size-10]a；input[20]b；inputsign，negate； wirease＝sign&amp;a[size-1]； wire[size+10]ax1＝{ase，ase，a}； wire[size+10]ax2＝{ase，a，1′d0}； wireone＝b[1]^b； wiretwo＝b[2]？-b[1]&amp;-bb[1]&amp;b； wirecin＝negate？(-b[2]&amp;(b[1]|b))(b[2]&amp;-(b[1]&amp;b))； assignout＝{size+2{cin}}^(ax1&amp;{size+2{one}}|ax2&amp;{size+2{two}})；endmodulemodulextclock_gate_nor(xtout，xtin1，xtin2)；outputxtout；inputxtin1，xtin2；assignxtout＝-(xtin1||xtin2)；endmodulemodulextclock_gate_or(xtout，xtin1，xtin2)；outputxtout；inputxtin1，xtin2；assignxtout＝(xtin1||xtin2)；endmodulemodulextcsa(sum，carry，a，b，c)；parametersize＝1；output[size-10]sum；output[size-10]carry；input[size-10]a；input[size-10]b；input[size-10]c；assignsum＝a^b^c；assigncarry＝(a&amp;b)|(b&amp;c)|(c&amp;a)；endmodulemodulextenflop(xtout，xtin，en，clk)； parametersize＝32； output[size-10]xtout； input[size-10]xtin； inputen； inputclk； reg[size-10]tmp； assignxtout＝tmp； always@(posedgeclk)begin<dpn="d323"/> if(en) tmp＜＝#1xtin；endendmodulemodulextfa(sum，carry，a，b，c)；outputsum，carry；inputa，b，c； assignsum＝a^b^c； assigncarry＝a&amp;b|a&amp;c|b&amp;c；endmodulemodulextflop(xtout，xtin，clk)； parametersize＝32； output[size-10]xtout； input[size-10]xtin； inputclk； reg[size-10]tmp； assignxtout＝tmp； always@(posedgeclk)begin tmp＜＝#1xtin； endendmodulemodulextha(sum，carry，a，b)；outputsum，carry；inputa，b； assignsum＝a^b； assigncarry＝a&amp;b；endmodulemodulextinc(xtout，a)； parametersize＝32； output[size-10]xtout； input[size-10]a； assignxtout＝a+1；endmodulemodulextmux2e(xtout，a，b，sel)； parametersize＝32； output[size-10]xtout； input[size-10]a； input[size-10]b； inputsel； assignxtout＝(-sel)？ab；endmodulemodulextmux3e(xtout，a，b，c，sel)； parametersize＝32； outpit[size-10]xtout； input[size-10]a； input[size-10]b； input[size-10]c； input[10]sel； reg[size-10]xtout；<dpn="d324"/> always@(aorborcorsel)begin xtout＝sel[1]？c(sel？ba)； endendmodulemodulextmux4e(xtout，a，b，c，d，sel)； parametersize＝32； output[size-10]xtout； input[size-10]a； input[size-10]b； input[size-10]c； input[size-10]d； input[10]sel； reg[size-10]xtout； //synopsysinfer_mux″xtmux4e″ always@(seloraorborcord)beginxtmux4e case(sel)//synopsysparallel_casefull_case 2′b00 xtout＝a； 2′b01 xtout＝b； 2′b10 xtout＝c； 2′b11 xtout＝d； default xtout＝{size{1′bx}}； endcase//case(sel) end//always@(seloraorborcord)endmodulemodulextnflop(xtout，xtin，clk)；parametersize＝32；output[size-10]xtout；input[size-10]xtin；inputclk；reg[size-10]tmp；assignxtout＝tmp；always@(negedgeclk)begin tmp＜＝#1xtin；end//always@(negedgeclk)endmodulemodulextscflop(xtout，xtin，clrb，clk)；//syncclearffparametersize＝32；output[size-10]xtout；input[size-10]xtin；inputclrb；inputclk；reg[size-10]tmp；assignxtout＝tmp；always@(posedgeclk)begin if(！clrb)tmp＜＝0；<dpn="d325"/> elsetmp＜＝#1xtin；endendmodulemodulextscenflop(xtout，xtin，en，clrb，clk)；//syncclear parametersize＝32； output[size-10]xtout； input[size-10]xtin； inputen； inputclrb； inputclk； reg[size-10]tmp； assignxtout＝tmp； always@(posedgeclk)begin if(！clrb)tmp＜＝0； elseif(en) tmp＜＝#1xtin； endendmoduleverysys/verifyref.vmodulexmTIE_gf_Regile(rd0_data_C1，rd0_addr_C0，rd0_width8_C0，rd0_use1_C0，rd1_data_C1，rd1_addr_C0，rd1_width8_C0，rd1_use1_C0，rd2_data_C1，rd2_addr_C0，rd2_width8_C0，rd2_use1_C0，wd_addr_C0，wd_width8_C0，wd_def1_C0，wddef2_Co，wd_data8_C1，wd_data8_C2，wd_wen_C1，wd_wen_C2，kill_E，KillPipe_W，Stall_R，clk)； output[70]rd0_data_C1； input[30]rd0_addr_C0； inputrd0_width8_C0； inputrd0_use1_C0； output[70]rd1_data_C1； input[30]rd1_addr_C0； inputrd1_width8_C0； inputrd1_use1_C0； output[70]rd2_data_C1； input[30]rd2_addr_C0； inputrd2_width8_C0； inputrd2_use1_C0； input[30]wd_addr_C0； inputwd_width8_C0； inputwd_def1_C0； inputwd_def2_C0； input[70]wd_data8_C1； input[70]wd_data8_C2； inputwd_wen_C1； inputwd_wen_C2； inputKill_E； inputKillPipe_W； outputStall_R； inputclk；/***********************************************************************<dpn="d326"/> READPORTrd0***********************************************************************/ //computetheaddressmask wirerd0_addr_mask_C0＝1′d0； //maskedaddresspipeline wirerd0_maddr_C0＝1′d0； //bank-qualifieduse wirerd0_use1_bank0_C0＝(rd0_use1_C0&amp;(rd0_maddr_C0＝＝(1′d0&amp;rd0_addr_mask_C0)))； //alignmentmuxforuse1 wire[70]rd0_data_bank0_C1； assignrd0_data_C1[70]＝rd0_data_bank0_C1；/*********************************************************************** READPORTrd1***********************************************************************/ //computetheaddressmask wirerd1_addr_mask_C0＝1′d0； //maskedaddresspipeline wirerd1_maddr_C0＝1′d0； //bank-qualifieduse wirerd1_use1_bank0_C0＝(rd1_use1_C0&amp;(rd1_maddr_C0＝＝(1′d0&amp;rd1_addr_mask_C0)))； //alignmentmuxforuse1 wire[70]rd1_data_bank0_C1； assignrd1_data_C1[70]＝rd1_data_bank0_C1；/*********************************************************************** READPORTrd2***********************************************************************/ //computetheaddresgmask wirerd2_addr_mask_C0＝1′d0； //maskedaddresspipeline wirerd2_maddr_C0＝1′d0； //bank-qualifieduse wirerd2_use1_bank0_C0＝(rd2_use1_C0&amp;(rd2_maddr_C0＝＝(1′d0&amp;rd2_addr_mask_C0)))； //alignmentmuxforuse1 wire[70]rd2_data_bank0_C1； assignrd2_data_C1[70]＝rd2_data_bank0_C1；/***********************************************************************<dpn="d327"/> WRITEPORTwd***********************************************************************/ //computetheaddressmask wirewd_addr_mask_C0＝1′d0； //bank-qualifiedwritedefforportwd wirewd_def1_bank0_C0＝(wd_def1_C0&amp;((wd_addr_C0&amp;wd_addr_mask_C0)＝＝(1′d0&amp;wd_addr_mask_C0)))； wirewd_def2_bank0_C0＝(wd_def2_C0&amp;((wd_addr_C0&amp;wd_addr_mask_C0)＝＝(1′d0&amp;wd_addr_maskC0)))； //writemuxfordef1 wire[70]wd_wdata_C1； assignwd_wdata_C1＝{1{wd_data8_C1[70]}}； //writemuxfordef2 wire[70]wd_wdata_C2； assignwd_wdata_C2＝{1{wd_data8_C2[70]}}； wireStall_R0；/*********************************************************************** PIPELINEDBANK***********************************************************************/ xmTIE_gf_Regfile_bankTIE_gf_Regfile_snk0(rd0_data_bank0_C1， rd0_addr_C0[30]，rd0_use1_bank0_C0，rd1_data_bank0_C1，rd1_addr_C0[30]， rd1_use1_bank0_C0，rd2_data_bank0_C1，rd2_addr_C0[30]，rd2_use1_bank0_C0， wd_addr_C0[30]，wd_def1_bank0_C0，wd_def2_bank0_C0，wd_wdata_C1[70]， wd_wdata_C2[70]，wd_wen_C1，wd_wen_C2，Kill_E，KillPipe_W，Stall_R0， clk)； assignStall_R＝Stall_R0|1′b0；endmodulemodulexmTIE_gf_Regfile_bank(rd0_data_C1，rd0_addr_C0，rd0_use1_C0，rd1_data_C1，rd1_addr_C0，rd1_use1_C0，rd2_data_C1，rd2_addr_C0，rd2_use1_C0，wd_addr_C0，wd_def1_C0，wd_def2_C0，wd_data_C1，wd_data_C2，wdwer_C1，wd_wen_C2，Kill_E，KillPipe_W，stall_R，clk)；output[70]rd0_data_C1；input[30]rd0_addr_C0；inputrd0_use1_C0；output[70]rd1_data_C1；input[30]rd1_addr_C0；inputrd1_use1_C0；output[70]rd2_data_C1；input[30]rd2_addr_C0；inputrd2_use1_C0；input[30]wd_addr_C0；inputwd_def1_C0；inputwd_def2_C0；input[70]wd_data_C1；<dpn="d328"/>input[70]wd_data_C2；inputwd_wen_C1；inputwd_wen_C2；inputKill_E；inputKillPipe_W；outputStall_R；inputclk；wirerd0_use2_C0＝1′d0；wirerdl_use2_C0＝1′d0；wirerd2_use2_C0＝1′d0；wirekill_C0＝KillPipe_W；wirekill_C1＝KillPipe_W|Kill_E；wirekill_C2＝KillPipe_W；wirekill_C3＝KillPipe_W；//writedefinitionpipelinewirewd_ns_def1_C0＝wd_def1_C0&amp;1′b1&amp;-kill_C0；wirewd_def1_C1；xtdelay1#(1)iwd_def1_C1(wd_def1_c1，wd_ns_def1_C0，clk)；wirewd_ns_def2_C0＝wd_def2_C0&amp;1′b1&amp;-kill_C0；wirewd_def2_C1；xtdelay1#(1)iwd_def2_C1(wd_def2_C1，wd_ns_def2_C0，clk)；wirewd_ns_def2_C1＝wd_def2_C1&amp;wd_wen_C1&amp;-kill_C1；wirewd_def2_C2；xtdelay1#(1)iwd_def2_C2(wd_def2_C2，wd_ns_def2_C1，clk)；//writeenablepipelinewirewd_we_C2；wirewd_we_C3；wirewd_ns_we_C1＝(1′d0|(wd_defl_C1&amp;wd_wen_C1))&amp;-kill_C1；wirewd_ns_we_C2＝(wd_we_C2|(wd_def2_C2&amp;wd_wen_C2))&amp;-kill_C2；wirewd_ns_we_C3＝(wd_we_C3|(1′d0&amp;1′d0))&amp;-kill_C3；xtdelay1#(1)iwd_we_C2(wd_we_C2，wd_ns_we_C1，clk)；xtdelay1#(1)iwd_we_C3(wd_we_C3，wd_ns_we_C2，clk)；//writeaddresspipelinewire[30]wd_addr_C1；wire[30]wd_addr_C2；wire[30]wd_addr_C3；xtdelay1#(4)iwd_addr_C1(wd_addr_C1，wd_addr_C0，clk)；xtdelayl#(4)iwd_addr_C2(wd_addr_C2，wd_addr_C1，clk)；xtdelay1#(4)iwd_addr_C3(wd_addr_C3，wd_addr_C2，clk)；//writedatapipelinewire[70]wd_result_C2；wire[70]wd_result_C3；wire[70]wd_mux_C1＝wd_data_C1；wire[70]wd_mux_C2＝wd_def2_C2？wd_data_C2wd_result_C2；xtdelay1#(8)iwd_result_C2(wd_result_C2，wd_mux_C1，clk)；xtdelay1#(8)iwd_result_C3(wd_result_C3，wd_mux_C2，clk)；wire[70]rd0_data_C0；wire[70]rd1_data_C0；wire[70]rd2_data_C0；xtdelay1#(8)ird0_data_C1(rd0_data_C1，rd0_data_C0，clk)；xtdelay1#(8)ird1_data_C1(rd1_data_C1，rd1_data_C0，clk)；<dpn="d329"/> xtdelay1#(8)ird2_data_C1(rd2_data_C1，rd2_data_C0，clk)； assignStall_R＝ ((wd_addr_C1＝＝rd0_addr_C0)&amp;( (rd0_use1_C0&amp;(wd_ns_def2_C1))))| ((wd_addr_C1＝＝rd1_addr_C0)&amp;( (rd1_use1_C0&amp;(wd_ns_def2_C1))))| ((wd_addr_C1＝＝rd2_addr_C0)&amp;( (rd2_use1_C0&amp;(wd_ns_def2_C1))))| 1′b0； //verificationregisterfilereplacement wire[70]xwd_verify； xtenflop#(8)wd_verify(xwd_verify，wd_result_C3，wd_ns_we_C3，clk)； xtflop#(8)rd0_verify(rd0_dataC0，xwd_verify，clk)； xtflop#(8)rd1_verify(rd1_data_C0，xwd_verify，c1k)； xtflop#(8)rd2_verify(rd2_data_C0，xwd_verify，clk)；endmodulemodulexmTIE_gfmod_State(ps_dataC1ps_width8_C0，ps_use1_C0，ns_width8_C0，ns_def1_C0，ns_data8_C1，ns_wen_C1，Kill_E，KillPipe_w，stall_R，clk)； output[70]ps_data_C1； inputps_width8_C0； inputps_use1_C0； inputns_width8_C0； inputns_def1_C0； input[70]ns_data8_C1； inputns_wen_C1； inputKill_E； inputKillPipe_W； outputStall_R； inputclk； wireps_addr_C0＝1′d0； wirens_addr_C0＝1′d0； wirens_wen_C2＝1′d1；/***************************************************************************************** READPORTps*********************************************************************************************/ //computetheaddressmask wireps_addr_mask_C0＝1′d0； //maskedaddresspipeline wireps_maddr_C0＝1′d0； //bank-qualifieduse wireps_use1_bank0_C0＝(ps_use1_C0&amp;(ps_maddr_C0＝＝(1′d0&amp;ps_addr__mask_C0)))； //alignmentmuxforuse1 wire[70]ps_data_bank0_C1； assignps_dataC1[70]＝ps_data_bank0_C1；<dpn="d330"/>/************************************************************************************** WRITEPORTns****************************************************************************/ //computetheaddressmask wirens_addr_mask_C0＝1′d0； //bank-qualifiedwritedefforportns wirens_def1_bank0_C0＝(ns_def1_C0&amp;((ns_addr_C0&amp;ns_addrmask_C0)＝＝(1′d0&amp;ns_addr_mask_C0)))； //writemuxfordef1 wire[70]ns_wdata_C1； assignns_wdata_C1＝{1{ns_data8_C1[70]}}； wireStall_R0；/********************************************************************************************* PIPELINEDBANK*****************************************************************************************************/ xmTIE_gfmod_State_bankTIE_gfmod_State_bank0(ps_data_bank0_C1， ps_use1_bank0_C0，ns_def1_bank0_C0，ns_wdata_C1[70]，ns_wen_C1， ns_wen_C2，Kill_E，KillPipe_W，Stall_R0，clk)； assignStall_R＝Stall_R0|1′b0；endmodulemodulexmTIE_gfmod_State_bank(ps_data_C1，ps_use1_C0，ns_def1_C0，ns_data_C1， ns_wen_C1，ns_wen_C2，Kill_E，KillPipe_W，Stall_R，clk)； output[70]ps_data_C1； inputps_use1_C0； inputns_def1_C0； input[70]ns_data_C1； inputns_wen_C1； inputns_wen_C2； inputKill_E； inputKillPipe_W； outputStall_R； inputclk； wireps_addr_C0＝1′d0； wireps_use2_C0＝1′d0； wirens_addr_C0＝1′d0； wirens_def2_C0＝1′d0； wire[70]ns_data_C2＝0； wirekill_C0＝KillPipe_W； wirekill_C1＝KillPipe_W|Kill_E； wirekill_C2＝KillPipe_W； wirekill_C3＝KillPipe_W； //writedefinitionPipeline wirens_ns_def1_C0＝ns_def1_C0&amp;1′b1&amp;-kill_C0； wirens_def1_C1；<dpn="d331"/>xtde1ay1#(1)ins_def1_C1(ns_def1_C1，ns_ns_def1_C0，clk)； wirens_ns_def2_C0＝1′d0； wirens_def2_C1＝1′d0； wirens_ns_def2C1＝1′d0； wireng_def2_C2＝1′d0； //writeenablepipeline wirens_we_C2； wirens_we_C3； wirens_ns_we_C1＝(1′d0|(ns_def1_C1&amp;ns_wen_C1))&amp;-kill_C1； wirens_ns_we_C2＝(ns_we_C2|(ns_def2_C2&amp;ns_wen_C2))&amp;-kill_C2； wirens_ns_we_C3＝(ns_we_C3|(1′d0&amp;1′d0))&amp;-kill_C3； xtdelay1#(1)ins_we_C2(ns_we_C2，ns_ns_we_C1，clk)； xtdelay1#(1)ins_we_C3(ns_we_C3，ns_ns_we_C2，clk)； //writeaddresspipeline wirens_addr_C1； wirens_addr_C2； wirens_addr_C3； assignns_addr_C1＝1′d0； assignns_addr_C2＝1′d0； assignns_addr_C3＝1′d0； //writedatapipeline wire[70]ns_result_C2； wire[70]ns_result_C3； wire[70]ns_mux_C1＝ns_data_C1； wire[70]ns_mux_C2＝ns_def2_C2？ns_data_C2ns_result_C2； xtde1ay1#(8)ins_result_C2(ns_result_C2，ns_mux_C1，clk)； xtdelay1#(8)ins_result_C3(ns_result_C3，ns_mux_C2，clk)； wire[70]ps_data_C0； xtdelay1#(8)ips_data_C1(ps_data_C1，ps_data_C0，clk)； assignStall_R＝ ((ns_addr_C1＝＝ps_addr_C0)&amp;( (ps_usel_C0&amp;(ns_ns_def2_C1))))| 1′b0； //verificationregisterfilereplacement wire[70]xns_verify； xtenflop#(8)ns_verify(xns_verify，ns_result_C3，ns_ns_we_C3，clk)； xtflop#(8)ps_verify(ps_data_C0，xns_verify，clk)；endmodulemodulexmTIE_decoder(GFADD8，GFADD8I，GFMULX8GFRWMOD8，LGF8_I，SGF8_I，LGF8_IU，SGF8_IU，LGF8_X，SGF8_X，LGF8_XU，SGF8_XU，<dpn="d332"/>RUR0，WUR0，imm4，imm8，art_use，art_def，ars_use，ars_def，arr_use，arr_def，br_use，br_def，bs_use，bs_def，bt_use，bt_def，bs4_use，bs4_def，bs8_use，bs8_def，gr_use，gr-def，gs_use，gs_def，gt_use，gt_def，gfmod_use1，gfmod_def1，AR_rd0_use1，AR_rd0_width32，AR_rd1_use1，AR_rd1_width32，AR_wd_def1，AR_wd_width32，gf_rd0_addr，gf_rd0_use1，gf_rd0_width8，gf_rd1_addr，gf_rd1_use1，gf_rd1_width8，gf_rd2_addr，gf_rd2_use1，gf_rd2_width8，gf_wd_addr，gf_wd_def2，gf_wd_def1，gf_wd_width8，GFADD8_semantic，GFADD8I_semantic，GFMULX8_semantic，GFRWMOD8_semantic，LGF8_I_semantic，LGF8_IU_semantic，LGF8_X_semantic，LGF8_XU_semantic，SGF8_I_semantic，SGF8_IU_semantic，SGF8_X_semantic，SGF8_XU_semantic，RUR0_semantic，<dpn="d333"/>WUR0_semantic，load_instruction，store_instruction，TIE_Inst，Inst)；outputGFADD8；outputGFADD8I；outputGFMULX8；outputGFRWMOD8；outputLGF8_I；outputSGF8_I；outputLGF8_IU；outputSGF8_IU；outputLGF8_X；outputSGF8_X；outputLGF8_XU；outputSGF8_XU；outputRUR0；outputWUR0；output[310]imm4；output[70]imm8；outputart_use；outputart_def；outputars_use；outputars_def；outputarr_use；outputarr_def；outputbr_use；outputbr_def；outputbs_use；outputbs_def；outputbt_use；outputbt_def；outputbs4_use；outputbs4_def；outputbs8_use；outputbs8_def；outputgr_use；outputgr_def；outputgs_use；outputgs_def；outputgt_use；outputgt_def；outputgfmod_use1；outputgfmod_def1；outputAR_rd0_use1；outputAR_rd0_width32；outputAR_rd1_use1；outputAR_rd1_width32；outputAR_wd_def1；outputAR_wd_width32；output[30]gf_rd0_addr；outputgf_rd0_use1；outputgf_rd0_width8；output[30]gf_rd1_addr；outputgf_rd1_use1；outputgf_rd1_width8；output[30]gf_rd2_addr；outputgf_rd2_use1；<dpn="d334"/>outputgf_rd2_width8；output[30]gf_wd_addr；outputgf_wd_def2；outputgf_wd_def1；outputgf_wd_width8；outputGFADD8_semantic；outputGFADD8I_semantic；outputGFMULX8_semantic；outputGFRWMOD8_semantic；outputLGF8_I_semantic；outputLGF8_IU_semantic；outputLGF8_X_semantic；outputLGF8_XU_semantic；outputSGF8_I_semantic；outputSGF8_IU_semantic；outputSGF8_X_semantic；outputSGF8_XU_semantic；outputRUR0_semantic；outputWUR0_semantic；outputload_instruction；outputstore_instruction；outputTIE_Inst；input[230]Inst；wire[30]op2＝{Inst[2320])；wire[30]op1＝{Inst[1916]}；wire[30]op0＝{Inst[30]}；wireQRST＝(op0＝＝4′b0000)；wireCUST0＝(op1＝＝4′b0110)&amp;QRST；assignGFADD8＝(op2＝＝4′b0000)&amp;CUST0；assignGFADD8I＝(op2＝＝4′b0100)&amp;CUST0；assignGFMULX8＝(op2＝＝4′b0001)&amp;CUST0；assignGFRWMOD8＝(op2＝＝4′b0010)&amp;CUST0；wire[30]r＝{Inst[1512]}；wireLSCI＝(op0＝＝4′b0011)；assignLGF8_I＝(r＝＝4′b0000)&amp;LSCI；assignSGF8_I＝(r＝＝4′b0001)&amp;LSCI；assignLGF8_IU＝(r＝＝4′b0010)&amp;LSCI；assignSGF8_IU＝(r＝＝4′b0011)&amp;LSCI；wireLSCX＝(op1＝＝4′b1000)&amp;QRST；assignLGF8_X＝(op2＝＝4′b0000)&amp;LSCX；assignSGF8_X＝(op2＝＝4′b0001)&amp;LSCX；assignLGF8_XU＝(op2＝＝4′b0010)&amp;LSCX；assignSGF8_XU＝(op2＝＝4′b0011)&amp;LScX；wire[30]s＝{Inst[118]}；wire[30]t＝{Inst[74]}；wire[70]st＝{s，t}；wireRST3＝(op1＝＝4′b0011)&amp;QRST；wireRUR＝(op2＝＝4′b1110)&amp;RST3；assignRUR0＝(st＝＝8′b00000000)&amp;RUR；wire[70]sr＝{r，s}；wireWUR＝(op2＝＝4′b1111)&amp;RST3；assignWUR0＝(sr＝＝8′b00000000)&amp;WUR；assigngfmod_use1＝GFMULX8|GFRWMOD8|RUR0|1′b0；assigngfmod_def1＝GFRWMOD8|WUR0|1′b0；assignAR_rd0_use1＝1′b0 |LGF8_I |SGF8_I |LGF8_IU |SGF8_IU<dpn="d335"/> |LGF8_X |SGF8_X |LGF8_XU |SGF8_XU；assignAR_rd0_width32＝1′b0；assignAR_rd1_use1＝1′b0 |LGF8_X |SGF8_X |LGF8_XU |SGF8_XU |WUR0；assignAR_rd1_width32＝1′b0；assignAR_wd_def1＝1′b0 |LGF8_IU |SGF8_IU |LGF8_XU |SGF8_XU |RUR0；assignAR_wd_width32＝1′b0；assigngf_rd0_use1＝1′b0 |GFADD8 |GFADD8I |GFMUX8；assigngf_rd0_width8＝1′b0；assigngf_rd1_use1＝1′b0 |GFADD8 |GFRWMOD8 |SGF8_I |SGF8_IU；assigngf_rd1_width8＝1′b0；assigngf_rd2_use1＝1′b0 |SGF8_X |SGF8_XU；assigngf_rd2_width8＝1′b0；assigngf_wd_def2＝1′b0 |LGF8_I |LGF8_IU |LGF8_X |LGF8_XU；assigngf_wd_def1＝1′b0 |GFADD8 |GFADD8I |GFMULX8 |GFRWMOD8；assigngf_wd_width8＝1′b0；assignart_def＝1′b0；assignart_use＝LGF8_X|SGF8_X|LGF8_XU|SGF8_XU|WUR0|1′b0；assignars_def＝LGF8_IU|SGF8_IU|LGF8_XU|SGF8_XU|1′b0；assignars_use＝LGF8_I|SGF8_I|LGF8_IU|SGF8_IU|LGF8_X|SGF8_X|LGF8_XU|SGF8_XU|1′b0；assignarr_def＝RUR0|1′b0；assignarr_use＝1′b0；assignbr_def＝1′b0；assignbr_use＝1′b0；assignbs_def＝1′b0；assignbs_use＝1′b0；assignbt_def＝1′b0；assignbt_use＝1′b0；assignbs4_def＝1′b0；assignbs4_use＝1′b0；<dpn="d336"/>assignbs8_def＝1′b0；assignbs8_use＝1′b0；assigngr_def＝GFADD8|GFADD8I|GFMULX8|LGF8_X|LGF8_XU|1′b0；assigngr_use＝SGF8_X|SGF8_XU|1′b0；assigngs_def＝1′b0；assigngs_use＝GFADD8|GFADD8I|GFMULX8|1′b0；assigngt_def＝GFRWMOD8|LGF8_I|LGF8_IU|1′b0；assigngt_use＝GFADD8|GFRWMOD8|SGF8_I|SGF8_IU|1′b0；wire[30]gr_addr＝r；wire[30]gs_addr＝s；wire[30]gt_addr＝t；assigngf_wd_addr＝4′b0 |{4{gr_def}}&amp;gr_addr |{4{gt_def}}&amp;gt_addr；assigngf_rd0_addr＝gs_addr；assigngf_rd1_addr＝gt_addr；assigngf_rd2_addr＝gr_addr；assignGFADD8_semantic＝GFADD8|1′b0；assignGFADD8I_semantic＝GFADD8I|1′b0；assignGFMULX8_semantic＝GFMULX8|1′b0；assignGFRWMOD8_semantic＝GFRWMOD8|1′b0；assignLGF8_I_semantic＝LGF8_I|1′b0；assignLGF8_IU_semantic＝LGF8_IU|1′b0；assignLGF8_X_semantic＝LGF8_X|1′b0；assignLGF8_XU_semantic＝LGF8_XU|1′b0；assignSGF8_I_semantic＝SGF8_I|1′b0；assignSGF8_IU_semantic＝SGF8_IU|1′b0；assignSGF8_X_semantic＝SGF8_X|1′b0；assignSGF8_XU_semantic＝SGF8_XU|1′b0；assignRUR0_semantic＝RUR0|1′b0；assignWUR0_semantic＝WUR0|1′b0；assignimm4＝t；wire[70]imm8＝{Inst[2316]}；assignload_instruction＝1′b0 |LGF8_I |LGF8_IU |LGF8_X |LGF8_XU；assignstore_instruction＝1′b0 |SGF8_I |SGF8_IU |SGF8_X |SGF8_XU；assignTIE_Inst＝1′b0 |GFADD8 |GFADD8I |GFMULX8 |GFRWMOD8 |LGF8_I |SGF8_I |LGF8_IU |SGF8_IU |LGF8_X |SGF8_X |LGF8_XU |SGF8_XU |RUR0 |WUR0；endmodule<dpn="d337"/>modulexmTIE_GFADD8(GFADD8_C0，gr_o_C1，gr_kill_C1，gs_i_C1，gt_i_C1，clk)；inputGFADD8_C0；output[70]gr_o_C1；outputgr_ki1l_C1；input[70]gs_i_C1；input[70]gt_i_C1；inputclk；assigngr_o_C1＝(gs_i_C1)＾(gt_i_C1)；wireGFADD8_C1；xtdelay1#(1)iGFADD8_C1(.xtin(GFADD8_C0)，.xtout(GFADD8_C1)，.clk(clk))；assigngr_kill_C1＝(1′b0)&amp;(GFADD8_C1)；endmodulemodulexmTIE_GFADD8I(GFADD8I_C0，gr_o_C1，gr_kill_C1，gs_i_C1，imm4_C0，clk)；inputGFADD8I_C0；output[70]gr_o_C1；outputgr_kill_C1；input[70]gs_i_C1；input[310]imm4_C0；inputclk；wire[310]imm4_C1；xtdelay1#(32)iimm4_C1(.xtin(imm4_C0)，.xtout(imm4_C1)，.clk(clk))；assigngr_o_C1＝(gs_i_C1)^(imm4_C1)；wireGFADD8I_C1；xtdelayl#(1)iGFADD8I_C1(.xtin(GFADD8I_C0)，.xtout(GFADD8I_C1)，.clk(clk))；assigngr_kill_C1＝(1′b0)&amp;(GFADD8I_C1)；endmodulemodulexmTIE_GFMULX8(GFMULX8_C0，gr_o_C1，gr_kill_C1，gs_i_C1，gfmod_ps_C1，clk)；inputGFMULX8_C0；output[70]gr_o_C1；outputgr_kill_C1；input[70]gs_i_C1；input[70]gfmod_ps_C1；inputclk；assigugr_o_C1＝(gs_i_C1[7])？(({gs_i_C1[60]，1′b0})＾(gfmod_ps_C1))({gs_i_C1[60]，1′b0})；wireGFMULX8_C1；<dpn="d338"/>xtdelay1#(1)iGFMULX8_C1(.xtin(GFMULX8_C0)，.xtout(GFMULX8_C1)，.clk(clk))；assigngr_kill_C1＝(1′b0)&amp;(GFMULX8_C1)；endmodulemodulexmTIE_GFRWMOD8(GFRWMOD8_C0，gt_i_C1，gt_o_C1，gt_kill_C1，gfmod_ps_C1，gfmod_ns_C1，gfmod_kill_C1，clk)；inputGFRWMOD8_C0；input[70]gt_i_C1；output[70]gt_o_C1；outputgt_kill_C1；input[70]gfmod_ps_C1；output[70]gfmod_ns_C1；outputgfmod_kill_C1；inputclk；wire[70]t1_C1；assignt1_C1＝gt_i_C1；wire[70]t2_C1；assignt2_C1＝gfmod_ps_C1；assigngfmod_ns_C1＝t1_C1；assigngt_o_C1＝t2_C1；wireGFRWMOD8_C1；xtdelay1#(1)iGFRWMOD8_C1(.xtin(GFRWMOD8_C0)，.xtout(GFRWMOD8_C1)，.clk(clk))；assigngfmod_kill_C1＝(1′b0)&amp;(GFRWMOD8_C1)；assigngt_kill_C1＝(1′b0)&amp;(GFRWMOD8_C1)；endmodulemodulexmTIE_LGF8_I(LGF8_I_C0，gt_o_C2，gt_kill_C2，ars_i_C1，imm8_C0，MemDataIn8_C2，LSSize_C0，VAddrBase_C1，VAddrOffset_C0，LSIndexed_C0，clk)；inputLGF8_I_C0；output[70]gt_o_C2；outputgt_kill_C2；input[310]ars_i_C1；input[70]imm8_C0；input[70]MemDataIn8_C2；output[40]LSSize_C0；output[310]VAddrBase_C1；output[310]VAddrOffset_C0；outputLSIndexed_C0；inputclk；<dpn="d339"/>assignLSSize_C0＝32′h1；assignVAddrBase_C1＝ars_i_C1；assignLSIndexed_C0＝1′b0；assignVAddrOffset_C0＝imm8_C0；assigngt_o_C2＝MemDataIn8_C2；wireLGF8_I_C2；xtdelay2#(1)iLGF8_I_C2(.xtin(LGF8_I_C0)，.xtout(LGF8_I_C2)，.clk(clk))；assigngt_kill_C2＝(1′b0)&amp;(LGF8_I_C2)；endmodulemodulexmTIE_LGF8_IU(LGF8_IU_C0，gt_o_C2，gt_kill_C2，ars_i_C1，ars_o_C1，ars_kill_C1，imm8_C0，MemDataIn8_C2，VAddrIn_C1，LSSize_C0，VAddrBase_C1，VAddrOffset_C0，LSIndexed_C0，clk)；inputLGF8_IU_C0；output[70]gt_o_C2；outputgt_kill_C2；input[310]ars_i_C1；output[310]ars_o_C1；outputars_kill_C1；input[70]imm8_C0；input[70]MemDataIn8_C2；input[310]VAddrIn_C1；output[40]LSSize_C0；output[310]VAddrBase_C1；output[310]VAddrOffset_C0；outputLSIndexed_C0；inputclk；assignLSSize_C0＝32′h1；assignVAddrBase_C1＝ars_i_C1；assignLSIndexed_C0＝1′b0；assignVAddrOffset_C0＝imm8_C0；assigngt_o_C2＝MemDataIn8_C2；assignars_o_C1＝VAddrIn_C1；wireLGF8_IU_C2；xtdelay2#(1)iLGF8_IU_C2(.xtin(LGF8_IU_C0)，.xtout(LGF8_IU_C2)，.clk(clk))；assigngt_kill_C2＝(1′b0)&amp;(LGF8_IU_C2)；wireLGF8_IU_C1；xtdelayl#(1)iLGF8_IU_C1(.xtin(LGF8_IU_C0)，.xtout(LGF8_IU_C1)，.clk(clk))；assignars_kill_C1＝(1′b0)&amp;(LGF8_IU_C1)；endmoduIemodulexmTIE_LGF8_X(LGF8_X_C0，gr_o_C2，gr_kill_C2，<dpn="d340"/>ars_i_C1，art_i_C1，MemDataIn8_C2，VAddrIn_C1，LSSize_C0，VAddrBase_C1，VAddrIndex_C1，LSIndexed_C0，clk)；inputLGF8_X_C0；output[70]gr_o_C2；outputgr_kill_C2；input[310]ars_i_C1；input[310]art_i_C1；input[70]MemDataIn8_C2；input[310]VAddrIn_C1；output[40]LSSize_C0；output[310]VAddrBase_C1；output[310]VAddrIndex_C1；outputLSIndexed_C0；inputclk；assignLSSize_C0＝32′h1；assignVAddrBase_C1＝ars_i_C1；assignLSIndexed_C0＝1′b1；assignVAddrIndex_C1＝arti_C1；assigngr_c_C2＝MemDataIn8_C2；assignars_o_C1＝VAddrIn_C1；wireLGF8_X_C2；xtdelay2#(1)iLGF8_X_C2(.xtin(LGF8_X_C0)，.xtout(LGF8_X_C2)，.clk(clk))；assigngr_kill_C2＝(1′b0)&amp;(LGF8_X_C2)；endmodulemodulexmTIE_LGF8_XU(LGF8_XU_C0，gr_o_C2，gr_kill_C2，ars_i_C1，ars_o_C1，ars_kill_C1，art_i_C1，MemDataIn8_C2，VAddrIn_C1，LSSize_C0，VAddrBase_C1，VAddrIndex_C1，LSIndexed_C0，clk)；inputLGF8_XU_C0；output[70]gr_o_C2；outputgr_kill_C2；input[310]ars_i_C1；output[310]ars_o_C1；outputars_kill_C1；input[310]art_i_C1；input[70]MemDataIn8_C2；input[310]VAddrIn_C1；output[40]LSSize_C0；output[310]VAddrBase_C1；<dpn="d341"/>output[310]VAddrIndex_C1；outputLSIndexed_C0；inputclk；assignLSSize_C0＝32′h1；assignVAddrBase_C1＝ars_i_C1；assignLSIndexed_C0＝1′b1；assignVAddrIndex_C1＝arti_C1；assigngr_o_C2＝MemDataIn8_C2；assignars_o_C1＝VAddrIn_C1；wireLGF8_XU_C2；xtdelay2#(1)iLGF8_XU_C2(.xtin(LGF8_XU_C0)，.xtout(LGF8_XU_C2)，.clk(clk))；assigngr_kill_C2＝(1′b0)&amp;(LGF8_XU_C2)；wireLGF8_XU_C1；xtdelay1#(1)iLGF8_XU_C1(.xtin(LGF8_XU_C0)，.xtout(LGF8_XU_C1)，.clk(clk))；assignars_kill_C1＝(1′b0)&amp;(LGF8_XU_C1)；endmodulemodulexmTIE_SGF8_I(SGF8_I_C0，gt_i_C1，ars_i_C1，imm8_C0，LSSize_C0，MemDataOut8_C1，VAddrBase_C1，VAddrOffset_C0，LSIndexed_C0，clk)；inputSGF8_I_C0；input[70]gt_i_C1；input[310]arsi_C1；input[70]imm8_C0；output[40]LSSize_C0；output[70]MemDataOut8_C1；output[310]VAddrBase_C1；output[310]VAddrOffset_C0；outputLSIndexed_C0；inputclk；assignLSSize_C0＝32′h1；assignVAddrBase_C1＝ars_i_C1；assignLSIndexed_C0＝1′b0；assignVAddrOffset_C0＝imm8_C0；assignMemDataOut8_C1＝gt_i_C1；endmodulemodulexmTIE_SGF8_IU(SGF8_IU_C0，gt_i_C1，ars_i_C1，ars_o_C1，ars_kill_C1，imm8_C0，VAddrIn_C1，LSSize_C0，MemDataOut8_C1，VAddrBase_C1，VAddrOffset_C0，<dpn="d342"/>LSIndexed_C0，clk)；inputSGF8_IU_C0；input[70]gt_i_C1；input[310]ars_i_C1；output[310]ars_o_C1；outputars_kill_C1；input[70]imm8_C0；input[310]VAddrIn_C1；output[40]LSSize_C0；output[70]MemDataOut8_C1；output[310]VAddrBase_C1；output[310]VAddrOffset_C0；outputLSIndexed_C0；inputclk；assignLSSize_C0＝32′h1；assignVAddrBase_C1＝ars_i_C1；assignLSIndexed_C0＝1′b0；assignVAddrOffset_C0＝imm8_C0；assignMemDataOut8_C1＝gt_i_C1；assignars_o_C1＝VAddrIn_C1；wireSGF8_IU_C1；xtdelay1#(1)iSGF8_IU_C1(.xtin(SGF8_IU_C0)，.xtout(SGF8_IU_C1)，.clk(clk))；assignars_kill_C1＝(1′b0)&amp;(SGF8_It_C1)；endmodulemodulexmTIE_SGF8_X(SGF8_X_C0，gr_i_C1，ars_i_C1，art_i_C1，LSSize_C0，MemDataOut8_C1，VAddrBase_C1，VAddrIndex_C1，LSIndexed_C0，clk)；inputSGF8_x_C0；input[70]gr_i_C1；input[310]ars_i_C1；input[310]art_i_C1；output[40]LSSize_C0；output[70]MemDataOut8_C1；output[310]VAddrBase_C1；output[310]VAddrIndex_C1；outputLSIndexed_C0；inputclk；assignLSSize_C0＝32′h1；assignVAddrBase_C1＝ars_i_C1；assignLSIndexed_C0＝1′b1；assignVAddrIndex_C1＝art_i_C1；assignMemDataOut8_C1＝gr_i_C1；endmodulemodulexmTIE_SGF8_XU(SGF8_XU_C0，gr_i_C1，<dpn="d343"/>ars_i_C1，ars_o_C1，ars_kill_C1，art_i_C1，VAddrIn_C1，LSSize_C0，MemDataOut8_C1，VAddrBase_C1，VAddrIndex_C1，LSIndexed_C0，clk)；inputSGF8_XU_C0；input[70]gr_i_C1；input[310]ars_i_C1；output[310]ars_o_C1；outputars_kill_C1；input[310]art_i_C1；input[310]VAddrIn_C1；output[40]LSSize_C0；output[70]MemDataOut8_C1；output[310]VAddrBase_C1；output[310]VAddrIndex_C1；outputLSIndexed_C0；inputclk；assignLSSize_C0＝32′h1；assignVAddrBase_C1＝ars_i_C1；assignLSIndexed_C0＝1′b1；assignVAddrIndex_C1＝art_i_C1；assignMemDataOut8_C1＝gr_i_C1；assignars_o_C1＝VAddrIn_C1；wireSGF8_XU_C1；xtdelay1#(1)iSGF8_XU_C1(.xtin(SGF8_XU_C0)，.xtout(SGF8_XU_C1)，.clk(clk))；assignars_kill_C1＝(1′b0)&amp;(SGF8_XU_C1)；endmodulemodulexmTIE_RUR0(RUR0_C0，arr_o_C1，arr_kill_C1，gfmod_ps_C1，clk)；inputRUR0_C0；output[310]arr_o_C1；outputarr_kill_C1；input[70]gfmod_ps_C1；inputclk；assignarr_o_C1＝{gfmod_ps_C1}；wireRUR0_C1；xtdelay1#(1)iRUR0_C1(.xtin(RUR0_C0)，.xtout(RUR0_C1)，.clk(clk))；assignarr_kill_C1＝(1′b0)&amp;(RUR0_C1)；endmodulemodulexmTIE_WUR0(WUR0_C0，art_i_C1，gfmod_ns_C1，gfmod_kill_C1，<dpn="d344"/>clk)；inputWUR0_C0；input[310]art_i_C1；output[70]gfmod_ns_C1；outputgfmod_kill_C1；inputclk；assigngfmod_ns_C1＝{art_i_C1[7o]}；wireWUR0_C1；xtdelay1#(1)iWUR0_C1(..xtin(WUR0_C0)，.xtout(WUR0_C1)，.clk(clk))；assigngfmod_kill_C1＝(1′b0)&amp;(WUR0_C1)；endmodulemodulexmTIE_ref(TIE_inst_R，TIE_asRead_R，TIE_atRead_R，TIE_atWrite_R，TIE_arWrite_R，TIE_asWrite_R，TIE_aWriteM_R，TIE_aDataKill_E，TIE_aWriteData_E，TIE_aDataKill_M，TIE_aWriteData_M，TIE_Load_R，TIE_Store_R，TIE_LSSize_R，TIE_LSIndexed_R，TIE_LSOffset_R，TIE_MemLoadData_M，TIE_MemStoreData8_E，TIE_MemStoreDatal6_E，TIE_MemStoreData32_E，TIE_MemStoreData64_E，TIE_MemStoreData128_E，TIE_Stall_R，TIE_Exception_E，TIE_ExcCause_E，TIE_bsRead_R，TIE_btRead_R，TIE_btWrite_R，TIE_brWrite_R，TIE_bsWrite_R，TIE_bsReadSize_R，TIE_btReadSize_R，TIE_bWriteSize_R，TIE_bsReadData_E，TIE_btReadData_E，TIE_bWriteData1_E，TIE_bWriteData2_E，TIE_bWriteData4_E，TIE_bWriteData8_E，TIE_bWriteDatal6_E，TIE_bDataKill_E，CPEnable，Instr_R，SBus_E，TBus_E，MemOpAddr_E，<dpn="d345"/>Kill_E，Except_W，Replay_W，G1WCLK，Reset)；outputTIE_inst_R；outputTIE_asRead_R；outputTIE_atRead_R；outputTIE_atWrite_R；outputTIE_arWrite_R；outputTIE_asWrite_R；outputTIE_aWriteM_R；outputTIE_aDataKill_E；output[310]TIE_aWriteData_E；outputTIE_aDataKill_M；output[310]TIE_aWriteData_M；outputTIE_Load_R；outputTIE_Store_R；output[40]TIE_LSSize_R；outputTIE_LSIndexed_R；output[310]TIE_LSOffset_R；input[1270]TIE_MemLoadData_M；output[70]TIE_MemStoreData8_E；output[150]TIE_MemStoreData16_E；output[310]TIE_MemStoreData32_E；output[630]TIE_MemStoreData64_E；output[1270]TIE_MemStoreData128_E；outputTIE_Stall_R；outputTIE_Exception_E；output[50]TIE_ExcCause_E；outputTIE_bsRead_R；outputTIE_btRead_R；outputTIE_btWrite_R；outputTIE_brWrite_R；outputTIE_bsWrite_R；output[40]TIE_bsReadSize_R；output[40]TIE_btReadSize_R；output[40]TIE_bWriteSize_R；input[150]TIE_bsReadData_E；input[150]TIE_btReadData_E；outputTIE_bWriteData1_E；output[10]TIE_bWriteData2_E；output[30]TIE_bWriteData4_E；output[70]TIE_bWriteData8_E；output[150]TIE_bWriteData16_E；outputTIE_bDataKill_E；input[70]CPEnable；input[230]Instr_R；input[310]SBus_E；input[310]TBus_E；input[310]MemOpAddr_E；inputKill_E；inputExcept_W；inputReplay_W；inputGlWCLK；inputReset；//unusedsignalswireTMode＝0；<dpn="d346"/>//controlsignalswireKillPipe_W；wireclk；//decodedsignalswireGFADD8_C0；wireGFADD8I_C0；wireGFMULX8_C0；wireGFRWMOD8_C0；wireLGF8I_C0；wireSGF8I_C0；wireLGF8_IU_C0；wireSGF8_IU_C0；wireLGF8_X_C0；wireSGF8_X_C0；wireLGF8_XU_C0；wireSGF8_XU_C0；wireRUR0_C0；wireWUR0_C0；wire[310]imm4_C0；wire[70]imm8_C0；w1reart_useC0；wireart_defC0；wirears_use_C0；wirears_def_C0；wirearr_use_C0；wirearr_def_C0；wirebr_use_C0；wirebr_def_C0；w1rebs_use_C0；wirebs_def_C0；w1rebt_use_C0；wirebt_def_C0；wirebs4_use_C0；wirebs4_def_C0；wirebs8_use_C0；wirebs8_def_C0；wiregr_use_C0；wiregr_def_C0；wiregs_use_C0；wiregs_def_C0；wiregt_use_C0；wiregt_def_C0；wIregfmod_use1_C0；wiregfmod_def1_C0；wireAR_rd0_use1_C0；wireAR_rd0_width32_C0；wireAR_rd1_use1_C0；wireAR_rd1_width32_C0；wireAR_wd_def1_C0；wireAR_wd_width32_C0；wire[30]gf_rd0_addr_C0；wiregf_rd0_use1_C0；wiregf_rd0_width8_C0；wire[30]gf_rd1_addr_C0；wiregf_rd1_usel_C0；wiregf_rd1_width8_C0；wire[30]gf_rd2_addr_C0；wiregf_rd2_use1_C0；<dpn="d347"/>wiregf_rd2_width8_C0；wire[30]gf_wd_addr_C0；wiregf_wd_def2_C0；wiregf_wd_def1_C0；wiregf_wd_width8_C0；wireGFADD8_semantic_C0；wireGFADD8I_semantic_C0；wireGFMULX8_semantic_C0；wireGFRWMOD8_semantic_C0；wireLGF8_I_semantic_C0；wireLGF8_IU_semantic_C0；wireLGF8_X_semantic_C0；wireLGF8_XU_semantic_C0；wireSGF8_I_semantic_C0；wireSGF8_IU_semantic_C0；wireSGF8_X_semantic_C0；wireSGF8_XU_semantic_C0；wireRUR0_semantic_C0；wireWUR0_semantic_C0；wireload_instruction_C0；wirestore_instruction_C0；wireTIE_Inst_C0；wire[230]Inst_C0；//statedata，write_enableandstallsignalswire[70]gfmod_ps_C1；wire[70]gfmod_ns_C1；wiregfmod_kill_C1；wiregfmod_Stall_C1；//registerdata，write_enableandstallsignalswire[310]AR_rd0_data_C1；wire[310]AR_rd1_data_C1；wire[310]AR_wd_data32_C1；wireAR_wd_kill_C1；wire[70]gf_rd0_dataC1；wire[70]gf_rd1_data_C1；wire[70]gf_rd2_data_C1；wire[70]gf_wd_data8_C2；wiregf_wd_kill_C2；wire[70]gf_wd_data8_C1；wiregf_wd_kill_C1；wiregf_Stall_C1；//operandswire[310]art_i_C1；wire[310]art_o_C1；wireart_kill_C1；wire[310]ars_i_C1；wire[310]ars_o_C1；wirears_kill_C1；wire[310]arr_o_C1；wirearr_kill_C1；wire[7；0]gr_i_C1；wire[7；0]gr_o_C2；wiregr_kill_C2；wire[70]gr_o_C1；wiregr_kill_C1；wire[70]gs_i_C1；wire[70]gt_i_C1；<dpn="d348"/>wire[70]gt_o_C2_；wiregt_kill_C2；wire[70]gt_oC1；wiregt_kill_C1；//outputstateofsemanticGFADD8//outputinterfaceofsemanticGFADD8//outputoperandofsemanticGFADD8wire[70]GFADD8_gr_o_C1；wireGFADD8_gr_kill_C1；//outputstateofsemanticGFADD8I//outputinterfaceofsemanticGFADD8I//outputoperandofsemanticGFADD8Iwire[70]GFADD8I_gr_o_C1；wireGFADD8I_gr_kill_C1；//outputstateofsemanticGFMULX8//outputinterfaceofsemanticGFMULX8//outputoperandofsemanticGFMULX8wire[70]GFMUIX8_gr_o_C1；wireGFMULX8_gr_kill_C1；//outputstateofsemanticGFRWMOD8wire[70]GFRWMOD8_gfmod_ns_C1；wireGFRWMOD8_gfmod_kill_C1；//outputinterfaceofsemanticGFRWMOD8//outputoperandofsemanticGFRWMOD8wire[70]GFRWMOD8_gt_o_C1；wireGFRWMOD8_gt_kill_C1；//outputstateofsemanticLGF8_I//outputinterfaceofsemanticLGF8_Iwire[40]LGF8_I_LSSize_C0；wire[310]LGF8_I_VAddrBase_C1；wire[310]LGF8_I_VAddrOffset_C0wireLGF8_I_LSIndexed_C0；//outputoperandofsemanticLGF8_Iwire[70]LGF8_I_g_to_C2；wireLGF8_I_gt_kill_C2；//outputstateofsemanticLGF8_IU//outputinterfaceofsemanticLGF8_IUwire[40]LGF8_IU_LSSize_C0；wire[310]LGF8_IU_VAddrBase_C1；wire[310]LGF8_IU_VAddrOffset_C0；wireLGF8_IU_LSIndexed_C0；//outputoperandofsemanticLGF8_IU<dpn="d349"/>wire[70]LGF8_IU_gt_o_C2；wireLGF8_IU_gt_kill_C2；wire[310]LGF8_IU_ars_o_C1；wireLGF8_IU_ars_kill_C1；//outputstateofsemanticLGF8_X//outputinterfaceofsemanticLGF8_Xwire[40]LGF8_X_LSSize_C0；wire[310]LGF8_X_VAddrBase_C1；wire[310]LGF8_X_VAddrIndex_C1；wireLGF8_X_LSIndexed_C0；//outputoperandofsemanticLGF8_Xwire[70]LGF8_X_gr_o_C2；wireLGF8_X_gr_kill_C2；//outputstateofsemanticLGF8_XU//outputinterfaceofsemanticLGF8_XUwire[40]LGF8_XU_LSSize_C0；wire[310]LGF8_XU_VAddrBase_C1；wire[310]LGF8_XU_VAddrIndex_C1；wireLGF8_XU_LSIndexed_C0；//outputoperandofsemanticLGF8_XUwire[70]LGF8_XU_gr_o_C2；wireLGF8_XU_gr_kill_C2；wire[310]LGF8_XU_ars_o_C1；wireLGF8_XU_ars_kill_C1；//outputstateofsemanticSGF8_I//outputinterfaceofsemanticSGF8_Iwire[40]SGF8_I_LSSize_C0；wire[70]SGF8_I_MemDataOut8_C1；wire[310]SGF8_I_VAddrBase_C1；wire[310]SGF8_I_VAddrOffset_C0；wireSGF8_I_LSIndexed_C0；//outputoperandofsemanticSGF8_I//outputstateofsemanticSGF8_IU//outputinterfaceofsemanticSGF8_IUwire[40]SGF8_IU_LSSize_C0；wire[70]SGF8_IU_MemDataOut8_C1；wire[310]SGF8_IU_VAddrBase_C1；wire[310]SGF8_IU_VAddrOffset_C0；wireSGF8_IU_LSIndexed_C0；//outputoperandofsemanticSGF8_IUwire[310]SGF8_IU_ars_o_C1；wireSGF8_IU_ars_kill_C1；//outputstateofsemanticSGF8_X//outputinterfaceofsemanticSGF8_Xwire[40]SGF8_X_LSSize_C0；wire[70]SGF8_X_MemDataOut8_C1；<dpn="d350"/>wire[310]SGF8_X_VAddrBase_C1；wire[310]SGF8_X_VAddrIndex_C1；wireSGF8_X_LSIndexed_C0；//outputoperandofsemanticSGF8_X//outputstateofsemanticSGF8_XU//outputinterfaceofsemanticSGF8_XUwire[40]SGF8_XU_LSSize_C0；wire[70]SGF8_XU_MemDataOut8_C1；wire[310]SGF8_XU_VAddrBase_C1；wire[310]SGF8_XU_VAddrIndex_C1；wireSGF8_XU_LSIndexed_C0；//outputoperandofsemanticSGF8_XUwire[310]SGF8_XU_ars_o_C1；wireSGF8_XU_ars_kill_C1；//outputstateofsemanticRUR0//outputinterfaceofsemanticRUR0//outputoperandofsemanticRUR0wire[310]RUR0_arr_o_C1；wireRUR0_arr_kill_C1；//outputstateofsemanticWUR0wire[70]WUR0_gfmod_ns_C1；wireWUR0_gfmod_kill_C1；//outputinterfaceofsemanticWUR0//outputoperandofsemanticWUR0//TIE-definedinterfacesignalswire[310]VAddr_C1；wire[310]VAddrBase_C1；wire[310]VAddrOffset_C0；wire[310]VAddrIndex_C1；wire[310]VAddrIn_C1；wire[40]LSSize_C0；wireLSIndexed_C0；wire[1270]MemDataIn128_C2；wire[630]MemDataIn64_C2；wire[310]MemDataIn32_C2；wire[150]MemDataIn16_C2；wire[70]MemDataIn8_C2；wire[1270]MemDataOut128_C1；wire[630]MemDataOut64_C1；wire[310]MemDataOut32_C1；wire[150]MemDataOut16_C1；wire[70]MemDataOut8_C1；wireException_C1；wire[5；0]ExcCause_C1；wire[70]CpEnable_C1； xtflop#(1)reset(localReset，Reset，GlWCLK)；xmTIE_decoderTIE_decoder( .GFADD8(GFADD8_C0)，<dpn="d351"/>.GFADD8I(GFADD8I_C0)，.GFMULX8(GFMULX8_C0)，.GFRWMOD8(GFRWMOD8_C0)，.LGF8_I(LGF8_I_C0)，.SGF8_I(SGF8_I_C0)，.LGF8_IU(LGF8_IU_C0)，.SGF8_IU(SGF8_IU_C0)，.LGF8_X(LGF8_X_C0)，.SGF8_X(SGF8_X_C0)，.LGF8_XU(LGF8_XU_C0)，.SGF8_XU(SGF8_XU_C0)，.RUR0(RUR0_C0)，.WUR0(WUR0_C0)，.imm4(imm4_C0)，.imm8(imm8_C0)，.art_use(art_use_C0)，.art_def(art_def_C0)，.ars_use(ars_use_C0)，.ars_def(ars_def_C0)，.arr_use(arr_use_C0)，.arr_def(arr_def_C0)，.br_use(br_use_C0)，.br_def(brdefC0)，.bs_use(bs_use_C0)，.bs_def(bs_def_C0)，.bt_use(bt_use_C0)，.bt_def(bt_def_C0)，.bs4_use(bs4_use_C0)，.bs4_def(bs4_def_C0)，.bs8_use(bs8_use_C0)，.bs8_def(bs8_def_C0)，.gr_use(gr_use_C0)，.gr_def(gr_def_C0)，.gs_use(gs_use_C0)，.gs_def(gs_def_C0)，.gt_use(gt_use_C0)，.gt_def(gt_def_C0)，.gfmod_use1(gfmod_use1_C0)，.gfmod_def1(gfmod_def1_C0)，.AR_rd0_use1(AR_rd0_use1_C0)，.AR_rd0_width32(AR_rd0_width32_C0)，.AR_rd1_use1(AR_rd1_use1_C0)，.AR_rd1_width32(AR_rd1_width32_C0)，.AR_wd_def1(AR_wd_def1_C0)，.AR_wd_width32(AR_wd_width32_C0)，.gf_rd0_addr(gf_rd0_addr_C0)，.gf_rd0_use1(gf_rd0_use1C0)，.gf_rd0_width8(gf_rd0_width8_C0)，.gf_rd1_addr(gf_rd1_addr_C0)，.gf_rd1_use1[gf_rd1_use1_C0)，.gf_rd1_width8(gf_rd1_width8_C0)，.gf_rd2_addr(gf_rd2_addr_C0)，.gf_rd2_usel(gf_rd2_use1_C0)，.gf_rd2_width8(gf_rd2_width8_C0)，.gf_wd_addr(gf_wd_addr_C0)，.gf_wd_def2(gf_wd_def2_C0)，.gf_wd_def1(gfwd_def1_C0)，.gf_wd_width8(gf_wd_width8_C0)，.GFADD8_semantic(GFADD8_semantic_C0)，.GFADD8I_semantic(GFADD8I_semantic_C0)，<dpn="d352"/> .GFMULX8_semantic(GFMULX8_semantic_C0)， .GFRWMOD8_semantic(GFRWMOD8_semantic_C0)， .LGF8_I_semantic(LGF8_I_semantic_C0)， .LGF8_IU_semantic(LGF8_IU_semantic_C0)， .LGF8_X_semantic(LGF8_X_semantic_C0)， .LGF8_XU_semantic(LGF8_XU_semantic_C0)， .SGF8_I_semantic(SGF8_I_semantic_C0)， .SGF8_IU_semantic(SGF8_IU_semantic_C0)， .SGF8_X_semantic(SGF8_X_semantic_C0)， .SGF8_XU_semantic(SGF8_XU_semantic_C0)， .RUR0_semantic(RUR0_semantic_C0)， .WUR0_semantic(WUR0_semantic_C0)， .load_instruction(load_instruction_C0)， .store_instruction(store_instruction_C0)， .TIE_Inst(TIE_Inst_C0)， .Inst(Inst_C0))；xmTIE_GFADD8TIE_GFADD8( .GFADD8_C0(GFADD8_C0)， .gr_o_C1(GFADD8_gr_o_C1)， .gr_kill_C1(GFADD8_gr_kill_C1)， .gs_i_C1(gs_i_C1)， .gt_i_C1(gt_i_C1)， .clk(clk))；xmTIE_GFADD8ITIE_GFADD8I( .GFADD8I_C0(GFADD8I_C0)， .gr_o_C1(GFADD8I_gr_o_C1)， .gr_kill_C1(GFADD8I_gr_kill_C1)， .gs_i_C1(gs_i_C1)， .imm4_C0(imm4_C0)， .clk(clk))；xmTIE_GFMULX8TIE_GFMULX8( .GFMULX8_C0(GFMULX8_C0)， .gr_o_C1(GFMULX8_gr_o_C1)， .gr_kill_C1(GFMULX8_gr_kill_C1)， .gs_i_C1(gs_i_C1)， .gfmod_ps_C1(gfmod_ps_C1)， .clk(clk))；xmTIE_GFRWMOD8TIE_GFRWMOD8( .GFRWMOD8_C0(GFRWMOD8_C0)， .gt_i_C1(gt_i_C1)， .gt_o_C1(GFRWMOD8_gto_C1)， .gt_kill_C1(GFRWMOD8_gt_kill_C1)， .gfmod_ps_C1(gfmod_ps_C1)， .gfmod_ns_C1(GFRWMOD8_gfmod_ns_C1)， .gfmod_kill_C1(GFRWMOD8_gfmod_kill_C1)， .clk(clk))；kmTIE_LGF8_I_TIE_LGF8_I( .LGF8_I_C0(LGF8_I_C0)， .gt_o_C2(LGF8_I_gt_o_C2)， .gt_kill_C2(LGF8_I_gt_kill_C2)， .ars_i_C1(ars_i_C1)， .imm8_C0(imm8_C0)， .MemDataIn8_C2(MemDataIn8_C2)， .LSSize_C0(LGF8_I_LSSize_C0)，<dpn="d353"/> .VAddrBase_C1(LGF8_I_VAddrBase_C1)， .VAddrOffset_C0(LGF8_I_VAddrOffset_C0)， .LSIndexed_C0(LGF8_I_LSIndexed_C0)， .clk(clk))；xmTIE_LGF8_IUTIE_LGF8_IU( .LGF8_IU_C0(LGF8_IU_C0)， .gt_o_C2(LGF8_IU_gt_o_C2)， .gt_kill_C2(LGF8_IU_gt_kill_C2)， .ars_i_C1(ars_i_C1)， .ars_o_C1(LGF8_IU_ars_o_C1)， .ars_kill_C1(LGF8_IU_ars_kill_C1)， .imm8_C0(imm8_C0)， .MemDataIn8_C2(MemDataIn8_C2)， .VAddrIn_C1(VAddrIn_C1)， .LSSize_C0(LGF8_IU_LSSize_C0)， .VAddrBase_C1(LGF8_IU_VAddrBase_C1)， .VAddrOffset_C0(LGF8_IU_VAddrOffset_C0)， .LSIndexed_C0(LGF8_IU_LSIndexed_C0)， .clk(clk))；xmTIE_LGF8_XTIE_LGF8_X( .LGF8_X_C0(LGF8_X_C0)， .gr_o_C2(LGF8_X_gr_o_C2)， .gr_kill_C2(LGF8_X_gr_kill_C2)， .ars_i_C1(ars_i_C1)， .art_i_C1(art_i_C1)， .MemDataIn8_C2(MemDataIn8_C2)， .VAddrIn_C1(VAddrIn_C1)， .LSSize_C0(LGF8_X_LSSize_C0)， .VAddrBase_C1(LGF8_X_VAddrBase-C1)， .VAddrIndex_C1(LGF8_X_VAddrIndex_C1)， .LSIndexed_C0(LGF8_X_LSIndexed_C0)， .clk(clk))；xmTIE_LGF8_XU_TIE_LGF8_XU( .LGF8_XU_C0(LGF8_XU_C0)， .gr_o_C2(LGF8_XU_gr_o_C2)， .gr_kill_C2(LGF8_XU_gr_kill_C2)， .ars_i_C1(ars_i_C1)， .ars_o_C1(LGF8_XU_ars_o_C1)， .ars_kill_C1(LGF8_XU_ars_kill_C1)， .art_i_C1(art_i_C1)， .MemDataIn8_C2(MemDataIn8_C2)， .VAddrIn_C1(VAddrIn_C1)， .LSSize_C0(LGF8_XU_LSSize_C0)， .VAddrBase_C1(LGF8_XU_VAddrBase_C1)， .VAdrIndex_C1(LGF8_XU_VAddrIndex_C1)， .LSIndexed_C0(LGF8_XU_LSIndexed_C0)， .clk(clk))；xmTIE_SGF8_I_TIE_SGF8_I( .SGF8_I_C0(SGF8_I_C0)， .gt_i_C1(gt_i_C1)， .ars_i_C1(ars_i_C1)， .imm8_C0(imm8_C0)， .LSSize_C0(SGF8_I_LSSize_C0)， .MemDataOut8_C1(SGF8_I_MemDataOut8_C1)， .VAddrBase_C1(SGF8_I_VAddrBase_C1)， .VAddrOffset_C0(SGF8_I_VAddrOffset_C0)，<dpn="d354"/> .LSIndexed_C0(SGF8_I_LSIndexed_C0)， .clk(clk))；xmTIE_SGF8_IUTIE_SGF8_IU( .SGF8_IU_C0(SGF8_IU_C0)， .gt_i_C1(gt_i_C1)， .ars_i_C1(ars_i_C1)， .ars_o_C1(SGF8_IU_ars_o_C1)， .ars_kill_C1(SGF8_IU_ars_kill_C1)， .imm8_C0(imm8_C0)， .VAddrIn_C1(VAddrIn_C1)， .LSSize_C0(SGF8_IU_LSSize_C0)， .MemDataOut8_C1(SGF8_IU_MemDataOut8_C1)， .VAddrBase_C1(SGF8_IU_VAddrBase_C1)， .VAddrOffset_C0(SGF8_IU_VAddrOffset_C0)， .LSIndexed_C0(SGF8_IU_LSIndexed_C0)， .clk(clk))；xmTIE_SGF8_XTIE_SGF8_X( .SGF8_X_C0(SGF8_X_C0)， .gr_i_C1(gr_i_C1)， .ars_i_C1(ars_i_C1)， .art_i_C1(art_i_C1)， .LSSize_C0(SGF8_X_LSSize_C0)， .MemDataOut8_C1(SGF8_X_MemDataOut8_C1)， .VAddrBase_C1(SGF8_X_VAddrBase_C1)， VAddrIndex_C1(SGF8_X_VAddrIndex_C1)， .LSIndexed_C0(SGF8_X_LSIndexed_C0)， .clk(clk))；xmTIE_SGF8_XUTIE_SGF8_XU( .SGF8_XU_C0(SGF8_XU_C0)， .gr_i_C1(gr_i_C1)， .ars_i_C1(ars_i_C1)， .ars_o_C1(SGF8_XU_ars_o_C1)， .ars_kill_C1(SGF8_XU_ars_kill_C1)， .art_i_C1(art_i_C1)， .VAddrIn_C1(VAddrIn_C1)， .LSSize_C0(SGF8_XU_LSSize_C0)， .MemDataOut8_C1(SGF8_XU_MemDataOut8_C1)， .VAddrBase_C1(SGF8_XU_VAddrBase_C1)， .VAddrIndex_C1(SGF8_XU_VAddrIndex_C1)， .LSIndexed_C0(SGF8_XU_LSIndexed_C0)， .clk(clk))；xmTIE_RUR0TIE_RUR0( .RUR0_C0(RUR0_C0)， .arr_o_C1(RUR0_arr_o_C1)， .arr_kill_C1(RUR0_arr_kill_C1)， .gfmod_ps_C1(gfmod_ps_C1)， .clk(clk))；xmTIE_WUR0TIE_WUR0( .WUR0_C0(WUR0_C0)， .art_i_C1(art_i_C1)， .gfmod_ns_C1(WUR0_gfmod_ns_C1)， .gfmod_kill_C1(WURo_gfmod_kill_C1)， .clk(clk))；xmTIE_gfmod_StateTIE_gfmod_State(<dpn="d355"/> .ps_width8_C0(1′b1)， .ps_use1_C0(gfmod_use1_C0)， .ps_data_C1(gfmod_ps_C1)， .ns_width8_C0(1′b1)， .ns_def1_C0(gfmod_def1_C0)， .ns_data8_C1(gfmod_ns_C1)， .ns_wen_C1(-gfmod_kill_C1)， .Kill_E(Kill_E)， .KillPipe_W(KillPipe_W)， .Stall_R(gfmod_Stall_C1)， .clk(clk))；xmTIE_gf_RegfileTIE_gf_Regfile( .rd0_addr_C0(gf_rd0_addr_C0)， .rd0_use1_C0(gf_rd0_use1_C0)， .rd0_data_C1(gf_rd0_vdata_C1)， .rd0_width8_C0(gf_rd0_width8_C0)， .rd1_addr_C0(gf_rd1_addr_C0)， .rd1_use1_C0(gf_rd1_use1_C0)， .rd1_data_C1(gf_rd1_data_C1)， .rd1_width8_C0(gf_rd1_width8_C0)， .rd2_addr_C0(gf_rd2_addr_C0)， .rd2_use1_C0(gf_rd2_use1_C0)， .rd2_data_C1(gf_rd2_data_C1)， .rd2_width8_C0(gf_rd2_width8_C0)， .wd_addr_C0(gf_wd_addr_C0)， .wd_def2_C0(gf_wd_def2_C0)， .wd_wen_C2(-gf_wd_kill_C2)， .wd_data8_C2(gf_wd_data8_C2)， .wd_def1_C0(gf_wd_def1_C0)， .wd_wen_C1(-gf_wd_kill_C1)， .wd_data8_C1(gf_wd_data8_C1)， .wd_width8_C0(gf_wd_width8_C0)， .Kill_E(Kill_E)， .KillPipe_W(KillPipe_W)， .Stall_R(gf_Stall_C1)， .clk(clk))；//StalllogicassignTIE_Stall_R＝1′b0 |gf_Stall_C1 |gfmod_Stall_C1；//pipelinesemanticselectsignalstoeachstagewireLGF8_I_semantic_C1；xtdelay1#(1)iLGF8_I_semantic_C1(.xtin(LGF8_I_semantic_C0)，.xtout(LGF8_I_semantic_C1)，.clk(clk))；wireLGF8_IU_semantic_C1；xtdelay1#(1)iLGF8_IU_semantic_C1(.xtin(LGF8_IU_semantic_C0)，.xtout(LGF8_IU_semantic_C1)，.clk(clk))；wireLGF8_X_semantic_C1；xtdelay1#(1)iLGF8_X_semantic_C1(.xtin(LGF8_X_semantic_C0)，.xtout(LGF8_X_semantic_C1)，.clk(clk))；wireLGF8_XU_semantic_C1；xtdelay1#(1)iLGF8_XU_semantic_C1(.xtin(LGF8_XU_semantic_C0)，.xtout(LGF8_XU_semantic_C1)，.clk(clk))；wireSGF8_I_semantic_C1；<dpn="d356"/>xtdelay1#(1)iSGF8_I_semantic_C1(.xtin(SGF8_I_semantic_C0)，.xtout(SGF8_I_semantic_C1)，.clk(clk))；wireSGF8_IU_semantic_C1；xtdelay1#(1)iSGF8_IU_semantic_C1(.xtin(SGF8_IU_semantic_C0)，.xtout(SGF8_IU_semantic_C1)，.clk(clk))；wireSGF8_X_semantic_C1；xtdelay1#(1)iSGF8_X_semantic_C1(.xtin(SGF8_X_semantic_C0)，.xtout(SGF8_X_semantic_C1)，.clk(clk))；wireSGF8_XU_semantic_C1；xtdelay1#(1)iSGF8_XU_semantic_C1(.xtin(SGF8_XU_semantic_C0)，.xtout(SGF8_XU_semantic_C1)，.clk(clk))；wireGFRWMOD8_semantic_C1；xtdelay1#(1)iGFRWMOD8_semantic_C1(.xtin(GFRWMOD8_semantic_C0)，.xtout(GFRWMOD8_semantic_C1)，.clk(clk))；wireWUR0_semantic_C1；xtdelay1#(1)iWUR0_semantic_C1(.xtin(WUR0_semantic_C0)，.xtout(WUR0_semantic_C1)，.clk(clk))；wireRUR0_semantic_C1；xtdelay1#(1)iRUR0_semantic_C1(.xtin(RUR0_semantic_C0)，.xtout(RUR0_semantic_C1)，.clk(clk))；wireLGF8_X_semantic_C2；xtdelay2#(1)iLGF8_X_semantic_C2(.xtin(LGF8_X_semantic_C0)，.xtout(LGF8_X_semantic_C2)，.clk(clk))；wireLGF8_XU_semantic_C2；xtdelay2#(1)iLGF8_XU_semantic_C2(.xtin(LGF8_XU_semantic_C0)，.xtout(LGF8_XU_semantic_C2)，.clk(clk))；wireGFADD8_semantic_C1；xtdelay1#(1)iGFADD8_semantic_C1(.xtin(GFADD8_semantic_C0)，.xtout(GFADD8_semantic_C1)，.clk(clk))；wireGFADD8I_semantic_C1；xtdelay1#(1)iGFADD8I_semantic_C1(.xtin(GFADD8I_semantic_C0)，.xtout(GFADD8I_semantic_C1)，.clk(clk))；wireGFMULX8_semantic_C1；xtdelay1#(1)iGFMULX8_semantic_C1(.xtin(GFMULX8_semantic_C0)，.xtout(GFMULX8_semantic_C1)，.clk(clk))；wireLGF8_I_semantic_C2；xtdelay2#(1)iLGF8_I_semantic_C2(.xtin(LGF8_I_semantic_C0)，.xtout(LGF8_I_semantic_C2)，.clk(clk))；wireLGF8_IU_semantic_C2；xtdelay2#(1)iLGF8_IU_semantic_C2(.xtin(LGF8_IU_semantic_C0)，.xtout(LGF8_IU_semantic_C2)，.clk(clk))；//combineoutputinterfacesignalsfromallsemanticsassignVAddr_C1＝32′b0；assignVAddrBase_C1＝32′b0 |(LGF8_I_VAddrBase_C1&amp;{32{LGF8_I_semantic_C1}}) |(LGF8_IU_VAddrBase_C1&amp;{32{LGF8_IU_semantic_C1}}) |(LGF8_X_VAddrBase_C1&amp;{32{LGF8_X_semantic_C1}}) |(LGF8_XU_VAddrBase_C1&amp;{32{LGF8_XU_semantic_C1}}) |(SGF8_I_VAddrBase_C1&amp;{32{SGF8_I_semantic_C1}}) |(SGF8_IU_VAddrBase_C1&amp;{32{SGF8_IU_semantic_C1}})|(SGF8_X_VAddrBase_C1&amp;{32{SGF8_X_semantic_C1}}) |(SGF8_XU_VAddrBase_C1&amp;{32{SGF8_XU_semantic_C1}})；assignVAddrOffset_C0＝32′b0 |(LGF8_I_VAddrOffset_C0&amp;{32{LGF8_I_semantic_C0}}) |(LGF8_IU_VAddrOffset_C0&amp;{32{LGF8_IU_semantic_C0}}) |(SGF8_I_VAddrOffset_C0&amp;{32{SGF8_I_semantic_C0}}) |(SGF8_IU_VAddrOffset_C0&amp;{32{SGF8_IU_semantic_C0}})；assignVAddrIndex_C1＝32′b0 |(LGF8_X_VAddrIndex_C1&amp;{32{LGF8_X_semantic_C1}})<dpn="d357"/> |(LGF8_XU_VAddrIndex_C1&amp;{32{LGF8_XU_semantic_C1}}) |(SGF8_X_VAddrIndex_C1&amp;{32{SGF8_X_semantic_C1}}) |(SGF8_XU_VAddrIndex_C1&amp;{32{SGF8_XU_semantic_C1}})；assignLSSize_C0＝5′b0 |(LGF8_I_LSSize_C0&amp;{5{LGF8_I_semantic_C0}}) |(LGF8_IU_LSSize_C0&amp;{5{LGF8_IU_semantic_C0}}) |(LGF8_X_LSSize_C0&amp;{5{LGF8_X_semantic_C0}}) |(LGF8_XU_LSSize_C0&amp;{5{LGF8_XU_semantic_C0}}) |(SGF8_I_LSSize_C0&amp;{5{SGF8_I_semantic_C0}}) |(SGF8_IU_LSSize_C0&amp;{5{SGF8_IU_semantic_C0}}) |(SGF8_X_LSSize_C0&amp;{5{SGF8_X_semantic_C0}}) |(SGF8_XU_LSSize_C0&amp;{5{SGF8_XU_semantic_C0}})；assignLSIndexed_C0＝1′b0 |(LGF8_ILSIndexed_C0&amp;LGF8_I_semantic_C0) |(LGE8_IU_LSIndexed_C0&amp;LGF8_IU_semantic_C0) |(LGF8_X_LSIndexed_C0&amp;LGF8_X_semantic_C0) |(LGF8_XU_LSIndexed_C0&amp;LGF8_XU_semantic_C0) |(SGF8_I_LSIndexed_C0&amp;SGF8_I_semantic_C0) |(SGF8_IU_LSIndexed_C0&amp;SGF8_IU_semantic_C0) |(SGF8_X_LSIndexed_C0&amp;SGF8_X_semantic_C0) |(SGF8_XU_LSIndexed_C0&amp;SGF8_XU_semantic_C0)；assignMemDataOut128_C1＝128′b0；assignMemDataOut64_C1＝64′b0；assignMemDataOut32_C1＝32′b0；assignMemDataOut16_C1＝16′b0；assignMemDataOut8_C1＝8′b0 |(SGF8_I_MemDataOut8_C1&amp;{8{SGF8_I_semantic_C1}}) |(SGF8_IU_MemDataOut8_C1&amp;{8{SGF8_IU_semantic_C1}}) |(SGF8_X_MemDataOut8_C1&amp;{8{SGF8_X_semantic_C1}}) |(SGF8_XU_MemDataOut8_C1&amp;{8{SGF8_XU_semantic_C1}})；assignException_C1＝1′b0；assignExcCause_C1＝6′b0；//combineoutputstatesignalsfroma11semanticsassigngfmod_ns_C1＝8′b0 |(GFRWMOD8_gfmod_ns_C1&amp;{8{GFRWMOD8_semantic_C1}}) |(WUR0_gfmod_ns_C1&amp;{8{WUR0_semantic_C1}})；assigngfmod_kill_C1＝1′b0 |(GFRWMOD8_gfmod_kill_C1&amp;GFRWMOD8_semantic_C1) |(WUR0_gfmod_kill_C1&amp;WUR0_semantic_C1)；//combineoutputoperandsignalsfromallsemanticsassignart_o_C1＝32′b0；assignart_kill_C1＝1′b0；assignars_o_C1＝32′b0 |(LGF8_IU_ars_o_C1&amp;{32{LGF8_IU_semantic_C1}}) |(LGF8_XU_ars_o_C1&amp;{32{LGF8_XU_semantic_C1}}) |(SGF8_IU_ars_o_C1&amp;{32{SGF8_IU_semantic_C1}}) |(SGF8_XU_ars_o_C1&amp;{32{SGF8_XU_semantic_C1}})；assignars_kill_C1＝1′b0 |(LGF8_IU_ars_ki1l_C1&amp;LGF8_IU_semantic_C1) |(LGF8_XU_ars_kill_C1&amp;LGF8_XU_semantic_C1) |(SGF8_IU_ars_kill_C1&amp;SGF8_IU_semantic_C1) |(SGF8_XU_ars_kill_C1&amp;SGF8_XU_semantic_C1)；assignarr_o_C1＝32′b0 |(RUR0_arr_o_C1&amp;{32{RUR0_semantic_C1}})；assignarr_kill_C1＝1′b0 |(RUR0_arr_kill_C1&amp;RUR0_semantic_C1)；assigngr_o_C2＝8′b0 |(LGF8_X_gr_o_C2&amp;{8{LGF8_X_semantic_C2}})<dpn="d358"/> |(LGF8_XU_gr_o_C2&amp;{8{LGF8_XU_semantic_C2}})；assigngr_kill_C2＝1′b0 |(LGF8_X_gr_ki11_C2&amp;LGF8_X_semantic_C2) |(LGF8_XU_gr_kill_C2&amp;LGF8_XU_semantic_C2)；assigngr_o_C1＝8′b0 |(GFADD8_gr_o_C1&amp;{8{GFADD8_semantic_C1}}) |(GFADD8I_gr_o_C1&amp;{8{GFADD8I_semantic_C1}}) |(GFMULX8_gr_o_C1&amp;{8{GFMULX8_semantic_C1}})；assigngr_kill_C1＝1′b0 |(GFADD8_gr_kill_C1&amp;GFADD8_semantic_C1) |(GFADD8I_gr_kill_C1&amp;GFADD8I_semantic_C1) |(GFMULX8_gr_kill_C1&amp;GFMULX8_semantic_C1)；assigngt_o_C2＝8′b0 |(LGF8_I_gt_o_C2&amp;{8{LGF8_I_semantic_C2}}) |(LGF8_IU_gt_o_C2&amp;{8{LGF8_IU_semantic_C2}})；assigngt_kill_C2＝1′b0 |(LGF8_I_gt_kill_C2&amp;LGF8_I_semantic_C2) |(LGF8_IU_gt_kill_C2&amp;LGF8_IU_semantic_C2)；assigngt_o_C1＝8′b0 |(GFRWMOD8_gt_o_C1&amp;{8{GFRWMOD8_semantiC_C1}})；assigngt_kill_C1＝1′b0 |(GFRWMOD8_gt_kill_C1&amp;GFRWMOD8_semantic_C1)；//outputoperandtowriteportmappinglogicassignAR_wd_data32_C1＝ars_o_C1|arr_o_C1|32′b0；assignAR_wd_kill_C1＝ars_kill_C1|arr_kill_C1|1′b0；assigngf_wd_data8_C2＝gt_o_C2|gr_o_C2|8′b0；assigngf_wd_kill_C2＝gt_kill_C2|gr_kill_C2|1′b0；assigngf_wd_data8_C1＝gr_o_C1|gt_o_C1|8′b0；assigngf_wd_ki1l_C1＝gr_kill_C1|gt_kill_C1|1′b0；//readporttoinputoperandmapping1ogicassignars_i_C1＝AR_rd0_data_C1；assignart_i_C1＝AR_rd1_data_C1；assigngs_i_C1＝gf_rd0_data_C1；assigngt_i_C1＝gf_rd1_data_C1；assigngr_i_C1＝gf_rd2_data_C1；//logictosupportverificationwireignore_TIE_aWriteData_E＝-(AR_wd_def1_C0&amp;(TIE_arWrite_R|TIE_asWrite_R|TIE_atWrite_R)&amp;-TIE_aDataKill_E)；wireignore_TIE_aWriteData_M＝-(1′b0&amp;(TIE_arWrite_R|TIE_asWrite_R|TIE_atWrite_R)&amp;-TIE_aDataKill_M)；wireignore_TIE_bWriteData_E＝(-TIE_btWrite_R&amp;-TIE_btWrite_R)|TIE_bDataKill_E；wireignore_TIE_bWriteData16_E＝ignore_TIE_bWriteData_E；wireignore_TIE_bWriteData8_E＝ignore_TIE_bWriteData_E；wireignore_TIE_bWriteData4_E＝ignore_TIE_bWriteData_E；wireignore_TIE_bWriteData2_E＝ignore_TIE_bWriteData_E；wireignore_TIE_bWriteData1_E＝ignore_TIE_bWriteData_E；wireignore_TIE_LSSize_R＝-TIE_Load_R&amp;-TIE_Store_R；wireignore_TIE_LSIndexed_R＝-TIE_Load_R&amp;-TIE_Store_R；wireignore_TIE_LSOffset_R＝-TIE_Load_R&amp;-TIE_Store_R|TIE_LSIndexed_R；wireignore_TIE_MemStoreData128_E＝(TIE_LSSize_R！＝5′b10000)|_TIE_Store_R；wireignore_TIE_MemStoreData64_E＝(TIE_LSSize_R！＝5′b01000)|_TIE_Store_R；wireignore_TIE_MemStoreData32_E＝(TIE_LSSize_R！＝5′b00100)|_TIE_Store_R；<dpn="d359"/>wireignore_TIE_MemStoreData16_E＝(TIE_LSSize_R！＝5′b00010)|-TIE_Store_R；wireignore_TIE_MemStoreData8_E＝(TIE_LSSize_R！＝5′b00001)|-TIE_Store_R；//clockandinstructionsassignclk＝G1WCLK；assignInst_C0＝Instr_R；assignTIE_inst_R＝TIE_Inst_C0；//AR-relatedsignalsto/fromcoreassignTIE_asRead_R＝ars_use_C0；assignTIE_atRead_R＝art_use_C0；assignTIE_atWrite_R＝art_def_C0；assignTIE_arWrite_R＝arr_def_C0；assignTIE_asWrite_R＝ars_def_C0；assignTIE_aWriteM_R＝0；assignTIE_aWriteData_E＝ignore_TIE_aWriteData_E？0AR_wd_data32_C1；assignTIE_aWriteData_M＝ignore_TIE_aWriteData_M？00；assignTIE_aDataKill_E＝AR_wd_kill_C1；assignTIE_aDataKill_M＝0；assignAR_rd0_data_C1＝SBus_E；assignAR_rdl_data_C1＝TBus_E；//BR-relatedsignalsto/fromcoreassignTIE_bsRead_R＝1′b0|bs_use_C0|bs4_use_C0|bs8_use_C0；assignTIE_btRead_R＝1′b0|bt_use_C0；assignTIE_btWrite_R＝1′b0|bt_def_C0；assignTIE_bsWrite_R＝1′b0|bs_def_C0|bs4_def_C0|bs8_def_C0；assignTIE_brWrite_R＝1′b0|br_def_C0；assignTIE_bWriteData16_E＝ignore_TIE_bWriteData16_E？00；assignTIE_bWriteData8_E＝ignoreTIEbWriteData8_E？00；assignTIE_bWriteData4_E＝ignoreTIEbWriteData4_E？00；assignTIE_bWriteData2_E＝ignore_TIE_bWriteData2_E？00；assignTIE_bWriteData1_E＝ignore_TIE_bWriteData1E？00；assignTIE_bDataKill_E＝0；assignTIE_bWriteSize_R＝{1′b0，1′b0，1′b0，1′b0，1′b0}；assignTIE_bsReadSize_R＝{1′b0，1′b0，1′b0，1′b0，1′b0}；assignTIE_btReadSize_R＝{1′b0，1′b0，1′b0，1′b0，1′b0}；//Load/storesignalsto/fromcoreassignTIE_Load_R＝load_instruction_C0；assignTIE_Store_R＝store_instruction_C0；assignTIE_LSSize_R＝ignore_TIE_LSSize_R？0LSSize_C0；assignTIE_LSIndexed_R＝ignore_TIE_LSIndexed_R？0LSIndexed_C0；assignTIE_LSOffset_R＝ignore_TIE_LSOffset_R？0VAddrOffset_C0；assignTIE_MemStoreData128_E＝ignore_TIE_MemStoreData128_E？0MemDataOut128_C1；assignTIE_MemStoreData64_E＝ignore_TIE_MemStoreData64_E？0MemDataOut64_C1；assignTIE_MemStoreData32_E＝ignore_TIE_MemStoreData32_E？0MemDataOut32_C1；assignTIE_MemStoreDatal6_E＝ignore_TIE_MemStoreData16_E？0MemDataOutl6_C1；assignTIE_MemStoreData8_E＝ignore_TIE_MemStoreData8_E？0MemDataOut8_C1；assignMemDataInl28_C2＝TIE_MemLoadData_M；assignMemDataIn64_C2＝TIE_MemLoadData_M；assignMemDataIn32_C2＝TIE_MemLoadData_M；assignMemDataIn16_C2＝TIE_MemLoadData_M；<dpn="d360"/>assignMemDataIn8_C2＝TIE_MemLoadData_M；assignVAddrIn_C1＝MemOpAddr_E；//CpEnableandcontrolsignalsto/fromcoreassignCPEnable_C1＝CPEnable；assignTIE_Exception_E＝Exceptio_C1；assignTIE_ExcCause_E＝ExcCause_C1；assignKillPipe_W＝Except_W|Replay_W；endmodulemodulextdelay1(xtout，xtin，clk)；parametersize＝1；output[size-10]xtout；input[size-10]xtin；inputclk； assignxtout＝xtin；endmodulemodulextdelay2(xtout，xtin，clk)；parametersize＝1；output[size-10]xtout；input[size-10]xtin；inputclk； assignxtout＝xtin；endmodulemodulextRFenlatch(xtRFenlatchout，xtin，xten，clk)； parametersize＝32； output[size-10]xtRFenlatchout； input[size-10]xtin； inputxten； inputclk； reg[size-10]xtRFenlatchout；always@(clkorxtenorxtinorxtRFenlatchout)begin if(clk)begin xtRFenlatchout＜＝#1(xten)？xtinxtRFenlatchout； endendendmodulemodulextRFlatch(xtRFlatchout，xtin，clk)； parametersize＝32； output[size-10]xtRFlatchout； input[size-10]xtin； inputclk； reg[size-10]xtRFlatchout；always@(clkorxtin)begin if(clk)begin xtRFlatchout＜＝#1xtin； endendendmodulemodulextadd(xtout，a，b)； parametersize＝32； output[size-10]xtout；<dpn="d361"/> input[size-10]a； input[size-10]b； assignxtout＝a+b；endmodulemodulextaddc(sum，carry，a，b，c)； parametersize＝32； output[size-10]sum； outputcarry； input[size-10]a； input[size-10]b； inputc； wirejunk； assign{carry，sum，junk}＝{a，c}+{b，c}；endmodulemodulextaddcin(xtout，a，b，c)； parametersize＝32； output[size-10]xtout； input[size-10]a； input[size-10]b； inputc； assignxtout＝({a，c}+{b，c})＞＞1；endmodulemodulextaddcout(sum，carry，a，b)； parametersize＝1； output[size-10]sum； outputcarry； input[size-10]a； input[size-10]b； assign{carry，sum}＝a+b；endmodulemodulextbooth(out，cin，a，b，sign，negate)；parametersize＝16；output[size+10]out；outputcin；input[size-10]a；input[20]b；inputsign，negate； wirease＝sign&amp;a[size-1]； wire[size+10]ax1＝{ase，ase，a}； wire[size+10]ax2＝{ase，a，1′d0}； wireone＝b[1]＾b； wiretwo＝b[2]？-b[1]&amp;-bb[1]&amp;b； wirecin＝negate？(-b[2]&amp;(b[1]|b))(b[2]&amp;-(b[1]&amp;b))； assignout＝{size+2{cin}}^(axl&amp;{size+2{one}}|ax2&amp;{size+2{two}})；endmodulemodulextclock_gate_nor(xtout，xtin1，xtin2)；outputxtout；inputxtin1，xtin2；<dpn="d362"/>assignxtout＝-(xtin1||xtin2)；endmodulemodulextclock_gate_or(xtout，xtin1，xtin2)；outputxtout；inputxtin1，xtin2；assignxtout＝(xtin1||xtin2)；endmodulemodulextcsa(sum，carry，a，b，c)； parametersize＝1； output[size-10]sum； output[size-10]carry； input[size-10]a； input[size-10]b； input[size-10]c； assignsum＝a^b^c； assigncarry＝(a&amp;b)|(b&amp;c)|(c&amp;a)；endmodulemodulextenflop(xtout，xtin，en，clk)； parametersize＝32； output[size-10]xtout； input[size-10]xtin； inputen； inputclk； reg[size-10]tmp； assignxtout＝tmp； always@(posedgeclk)begin if(en) tmp＜＝#1xtin； endendmodulemodulextfa(sum，carry，a，b，c)；outputsum，carry；inputa，b，c； assignsum＝a^b^c； assigncarry＝a&amp;b|a&amp;c|b&amp;c；endmodulemodulextflop(xtout，xtin，clk)； parametersize＝32； output[size-10]xtout； input[size-10]xtin； inputclk； reg[size-10]tmp； assignxtout＝tmp； always@(posedgeclk)begin tmp＜＝#1xtin； endendmodule<dpn="d363"/>modulextha(sum，carry，a，b)；outputsum，carry；inputa，b； assignsum＝a＾b； assigncarry＝a&amp;b；endmodulemodulextinc(xtout，a)； parametersize＝32； output[size-10]xtout； input[size-10]a； assignxtout＝a+1；endmodulemodulextmux2e(xtout，a，b，sel)； parametersize＝32； output[size-10]xtout； input[size-10]a； input[size-10]b； inputsel； assignxtout＝(-sel)？ab；endmodulemodulextmux3e(xtout，a，b，c，sel)； parametersize＝32； output[size-10]xtout； input[size-10]a； input[size-10]b； input[size-10]c； input[10]sel； reg[size-10]xtout； always@(aorborcorsel)begin xtout＝sel[1]？c(sel？ba)； endendmodulemodulextmux4e(xtout，a，b，c，d，sel)； parametersize＝32； output[size-10]xtout； input[size-10]a； input[size-10]b； input[size-10]c； input[size-10]d； input[10]sel； reg[size-10]xtout； //synopsysinfer_mux″xtmux4e″ always@(seloraorborcord)beginxtmux4e case(sel)//synopsysparallel_casefull_case 2′b00 xtout＝a； 2′b01 xtout＝b； 2′b10；<dpn="d364"/> xtout＝c； 2′b11 xtout＝d； default xtout＝{size{1′bx}}； endcase//case(sel) end//always@(seloraorborcord)endmodulemodulextnflop(xtout，xtin，clk)； parametersize＝32； output[size-10]xtout； input[size-10]xtin； irputclk； reg[size-10]tmp； assignxtout＝tmp； always@(negedgeclk)begin tmp＜＝#1xtin； end//always@(negedgeclk)endmodulemodulextscflop(xtout，xtin，clrb，clk)；//syncclearff parametersize＝32； output[size-10]xtout； input[size-10]xtin； inputclrb； inputclk； reg[size-10]tmp； assignxtout＝tmp； always@(posedgeclk)begin if(！clrb)tmp＜＝0； elsetmp＜＝#1xtin； endendmodulemodulextscenflop(xtout，xtin，en，clrb，clk)；//syncclear parametersize＝32； output[size-10]xtout； input[size-10]xtin； inputen； inputclrb； inputclk； reg[size-10]tmp； assignxtout＝tmp； always@(posedgeclk)begin if(！clrb)tmp＜＝0； elseif(en) tmp＜＝#1xtin； endendmodulextensa-gf.h<dpn="d365"/>#ifndefXTENSA_NO_INTRINSICS#ifdef_XTENSA_/*Donotmodify.Thisisautomaticallygenerated.*/typedefintgf8_attribute_((user(″gf8″)))；#defineGFADD8_ASM(gr，gs，gt){\ _asm_(″gfadd8％0，％1，％2″″＝v″(gr)″v″(gs)，″v″(gt))；\}#defineGFADD8(gs，gt)({\gf8_gr；\gf8_gs＝gs；\gf8_gt＝gt；\GFADD8_ASM(_gr，_gs，_gt)；\_gr；\})#defineGFADD8I_ASM(gr，gs，imm4){\ _asm_(″gfadd8i％0，％1，％2″″＝v″(gr)″v″(gs)，″i″(imm4))；\}#defineGFADD8I(gs，imm4)({\gf8_gr；\gf8_gs＝gs；\GFADD8I_ASM(_gr，_gs，imm4)；\_gr；\})#defineGFMULX8_ASM(gr，gs){\ registerint_xt_stateasm(″state″)；\ _asm_(″gfmulx8％1，％2″″+t″(_xt_state)，″＝v″(gr)″v″(gs))；\}#defineGFMUIX8(gs)({\gf8_gr；\gf8_gs＝gs；\GFMULX8_ASM(_gr，_gs)；\_gr；\})#defineGFRWMOD8_ASM(gt){\registerint_xt_stateasm(″state″)；\_asm_(″gfrwmod8％1″″+t″(_xt_state)，″＝v″(gt)″1″(gt))；\}#defineGFRWMOD8(gt)({\gf8_gt＝gt；\GFRWMOD8_ASM(_gt)；\gt＝_gt；\})#defineLGF8_I_ASM(gt，ars，imm8){\ _asm_volatile(″lgf8_i％0，％1，％2″″＝v″(gt)″a″(ars)，″i″(imm8))；\}#defineLGF8_I(ars，imm8)({\gf8_gt；\<dpn="d366"/> constunsigned_ars＝ars；\ LGF8_I_ASM(_gt，_ars，imm8)；\ _gt；\})#defineSGF8_I_ASM(gt，ars，imm8){\_asm_volatile(″sgf8_i％0，％1，％2″″v″(gt)，″a″(ars)，″i″(imm8))；\}#defineSGF8_I(gt，ars，imm8)({\gf8_gt＝gt；\unsigned_ars＝ars；\SGF8_I_ASM(_gt，_ars，imm8)；\})#defineLGF8_IU_ASM(gt，ars，imm8){\ _asm_volatile(″lgf8_iu％0，％1，％3″″＝v″(gt)，″＝a″(ars)″1″(ars)，″i″(imm8))；\}#defineLGF8_IU(ars，imm8)({\gf8_gt；\unsigned_ars＝ars；\LGF8_IU_ASM(_gt，_ars，imm8)；\ars＝_ars；\_gt；\})#defineSGF8_IU_ASM(gt，ars，imm8){\ _asm_volatile(″sgf8_iu％1，％0，％3″″＝a″(ars)″v″(gt)，″0″(ars)，″i″(imm8))；\}#defineSGF8_IU(gt，ars，imm8)({\gf8_gt＝gt；\unsigned_ars＝ars；\SGF8_IU_ASM(_gt，_ars，imm8)；\ars＝_ars；\})#defineLGF8_X_ASM(gr，ars，art){\ _asm_volatile(″lgf8_x％0，％1，％2″″＝v″(gr)″a″(ars)，″a″(art))；\}#defineLGF8_X(ars，art)({\gf8_gr；\constunsigned_ars＝ars；\unsigned_art＝art；\LGF8_X_ASM(_gr，_ars，_art)；\_gr；\})#defineSGF8_X_ASM(gr，ars，art){\ _asm_volatile(″sgf8_x％0，％1，％2″″v″(gr)，″a″(ars)，″a″(art))；\}#defineSGF8_X(gr，ars，art)({\<dpn="d367"/>gf8_gr＝gr；\unsigned_ars＝ars；\unsigned_art＝art；\SGF8_X_ASM(_gr，_ars，_art)；\})#defineLGF8_XU_ASM(gr，ars，art){\ _asm_volatile(″lgf8_xu％0，％1，％3″″＝v″(gr)，″＝a″(ars)″1″(ars)，″a″(art))；\}#defineLGF8_XU(ars，art)({\gf8_gr；\unsigned_ars＝ars；\unsigned_art＝art；\LGF8_XU_ASM(_gr，_ars，_art)；\ars＝_ars；\_gr；\})#defineSGF8_XU_ASM(gr，ars，art){\ _asm_volatile(″sgf8_xu％1，％0，％3″″＝a″(ars)″v″(gr)，″0″(ars)，″a″(art))；\}<br/>#defineSGF8_XU(gr，ars，art)({\gf8_gr＝gr；\unsigned_ars＝ars；\unsigned_art＝art；\SGF8_XU_ASM(_gr，_ars，_art)；\ars＝_ars；\})#defineRUR0_ASM(arr){\registerint_xt_stateasm(″state″)；\_asm_(″rur0％1″″+t″(_xt_state)，″＝a″(arr))；\}#defineRUR0()({\unsigned_arr；\RUR0_ASM(_arr)；\_arr；\})#defineWUR0_ASM(art){\registerint_xt_stateasm(″state″)；\_asm_(″wur0％1″″+t″(_xt_state)″a″(art))；\}#defineWUR0(art)({\ unsigned_art＝art；\ WUR0_ASM(_art)；\})#definegf8_loadi(_s，o)({\ gf8t；\ gf8*s＝_s；\ LGF8_I_ASM(t，s，o)；\ t；\})<dpn="d368"/>#definegf8_storei(_t，_s，o)({\ gf8t＝_t；\ gf8*s＝_s；\ SGF8_I_ASM(t，s，o)；\})#definegf8_move(_r，_s)({\ gf8r＝_r；\ gf8s＝_s；\ GFADD8_ASM(r，s，0)；\})#defineRUR(n)({\ intv；\ registerint_xt_stateasm(″state″)；\ _asm_(″rur％1，％2″″+t″(_xt_state)，″＝a″(v)″i″(n))；\ v；\})#defineWUR(v，n)({\ registerint_xt_stateasm(″state″)；\ _asm_(″wur％1，％2″″+t″(_xt_state)″a″(v)，″i″(n))；\})#endif#endif附录B #！/usr/xtensa/tools/bin/perl-w useGetoptLong； usestrict； $maininline_mux_count＝0； subinline_mux{ my($data，$se1，$width，$out，$style，$code)＝@_； my($i，$n，$n1，$module，$inst，$d，$fail，@data，@data_uniq)； $n＝@$data； if($styleeq″encoded″){ $module＝″xtmux${n}e″； $fail＝0； }elsif($styleeq″priority″){ $fail＝scalar(@$data)！＝scalar(@$sel)+1； $module＝″xtmux${n}p″； }elsif($styleeq″selector″){ $fail＝scalar(@$data)！＝scalar(@$sel)； $module＝″xtmux${n}″； }else{ die″inline_muxbadstyle$style″； } if($fail){ die″inline_muxdata/selectionmismatchfor$style$n″； } if($n＝＝0){ print″assign$out＝0；\n″； }elsif($n＝＝1){ print″assign$out＝″.(shift@$data).″；\n″； }else{ @data_uniq＝uniq(@$data)； $n1＝@data_uniq； if($styleeq″priority″&amp;&amp;($n1！＝.$n||defined$code)){ if(！defined$code){ for($i＝0；$i＜$n1；$i++){ $code-＞{$data_uniq[$i]}＝$i； } } @data＝sort{$code-＞{$a}＜＝＞$code-＞{$b}}@data_uniq； print″wire[″.(ceil_log2($n1)-1).″0]${out}_sel=/n"； for($i＝0；$i＜$n-1；$i++){ print″$sel-＞[$i]？$code-＞{$data-＞[$i]}\n″； } print″$code-＞{$data-＞[$n-1]}；\n″； inline_mux(\@data，″${out}_sel″，$width，$out，″encoded″)； }else{ #dropaninstanceofthemux $inst＝$maininline_mux_count++； print″$module#($width)m$inst($out″； printmap(″，$_″，@$data)； if($styleeq″priority″||$styleeq″selector″){ printmap(″，$_″，@$sel)； print″)；\n″； }else{ print″，$sel)；\n″； }<dpn="d371"/> } }}#minofalistsubmin{ my($min，$v)； $min＝$_； foreach$v(@_){ $min＝$v＜$min？$v$min； } return$min；}#maxofalistsubmax{ my($max，$v)； $max＝$_； foreach$v(@_){ $max＝$v＞$max？$v$max； } return$max；}#ceil(log2(x))subceil_log2{ my($x)＝@_； my($n)； for($n＝0，$x-＝1；$x＞0；$x＞＞＝1，$n++){ } return$n；}#2＾xsubpow2{ my($x)＝@_； return1＜＜$x；}#uniqifyanarraysubuniq{ my(％seen)； returngrep(！$seen{$_}++，@_)；}#differencebetweentwoarrayssubdiff{ my($aref，$bref)＝@_； my(％hash)； grep($hash{$_}＝1，@$bref)； returngrep(！defined$hash{$_}，@$aref)；}<dpn="d372"/>subwfield{ my($name，$port，$stage)＝@_； $name＝″$port-＞{NAME}_$name″； return$stage＞＝0？″${name}_C$stage″$name；}gubrfield{ my($name，$port，$stage)＝@_； $name＝″$port-＞{NAME}_$name″； return$stage＞＝0？″${name}_C$stage″$name；}subwrite_def{ my($write_port，$stage)＝@_； returngrep($_＝＝$stage，@{$write_port-＞{DEF}})；} subread_$use{ my($read_port，$stage)＝@_； returngrep($_＝＝$stage，@{$read_port-＞{USE}})；}subinit_print_break{ my($indent)＝@_； $maincol＝0； $mainindent＝$indent；}subprint_break{ my($d)＝@_； if($maincol+length($d)+1＞＝85){ $maincol＝4； print(″\n″.(′′x$mainindent))； } print″$d″； $maincol+＝length($d)+1；}<dpn="d373"/> subdoc{ my($a)＝＜＜′END_OF_DOCUMENTATION′； Thepipelinedregisterfileinstantiatesanumberofpipelinedregisterfile banks，eachofwhichcontainsaregisterfilecore. Thecoreisasimplemultiple-readportmultiple-writeportregisterfile.The addresssizeis$rf-＞{ADDR_SIZE}(lg2$rf-＞{MIN_HEIHGT})anditsdeclarationis.$rf-＞{ADDR_DECL}.Thedatasizeis$rf-＞{DECL_SIZE}($rf-＞{MIN_WIDTH})andits declarationis$rf-＞{DECL_DECL}. Multiplebanksareusedtosupportmultiplewidthsforreadandwriteports. WebuildNUM_BANK($rf-＞MAX_WIDTH/$rf-＞MIN_WIDTH)pipelinedregisterbanks， eachofwhichhasMIN_HEIGHTwordsandMIN_WIDTHbitsineachword.Eachwidth mustbeapowerof2multipleoftheminimumwidth；inparticular，NUM_BANK mustalsobeapowerof2. Afinalreadalignmentmuxlooksatthelow-orderaddressbitsandthe read-widthmasktomuxthecorrectdataontotheoutput.Thissplitsthe addressintoHI_ADDR_SIZEandLO_ADDR_SIZEfields.Thehighorderbitsgo directlytotheregisterfilecore；thelowaddressbitsarefedtothe alignmentmux.ThereadoutputisalwaysMAX_WIDTHinsizeandsmallerdata valuesareshiftedtotheLSBoftheoutputword. Asaconcreteexample，consideraregisterfileofsize1024bits(32x32)with readwidthsof32and128. NUM_BANK＝4 MIN_HEIGHT＝32 MIN_WIDTH＝32 MAX_HEIGHT＝8 MAX_WIDTH＝128 ADDR_SIZE＝5 ADDR_DECL＝[40] WORD_SIZE＝32 WORD_DECL＝[310] HI_ADDR_SIZE＝3 LO_ADDR_SIZE＝2 Thereadmaskis 11toreadwidth32 10toreadwidth64(notusedinthiscase) 00toreadwidth128 END_OF_DOCUMENTATION<dpn="d374"/> return$a； } subderive_constants{ my($rf)＝@_； my($read_port，$write_Port，$n，$w，@width)； #determineparametersforregisterfilebanks foreach$readport(@{$rf-＞{READ_PORT}}){ push(@width，@{$readport-＞{WIDTH}})； } foreach$write_port(@{$rf-＞{WRITE_PORT}}){ push(@width，@{$write_port-＞{WIDTH}})； } @width＝sort{$a＜＝＞$b}(&amp;uniq(@width))； $rf-＞{MIN_WIDTH}＝$width； $rf-＞{MAX_WIDTH}＝$width[$#width]； $rf-＞{MIN_HEIGHT}＝$rf-＞{SIZE}/$rf-＞{MAX_WIDTH}； $rf-＞{MAX_HEIGHT}＝$rf-＞{SIZE}/$rf-＞{MIN_WIDTH}； $rf-＞{NUM_BANK}＝$rf-＞{MAX_WIDTH}/$rf-＞{MIN_WIDTH}； foreach$w(@width){ $n＝$w/$rf-＞{MIN_WIDTH}； if($n！＝pow2(ceil_log2($n))){ die″width$wnotvalidmultipleof$rf-＞{MIN_WIDTH}\n″； } } #registerfilecoreparameters $rf-＞{ADDR_SIZE}＝ceil_log2($rf-＞{MIN_HEIGHT})； $rf-＞{ADDR_DECL}＝$rf-＞{ADDR_SIZE}＞0？″[″.($rf-＞{ADDR_SIZE}-1).″0]″″″； $rf-＞{WORD_SIZE}＝$rf-＞{MIN_WIDTH}； $rf-＞{WORD_DECL}＝$rf-＞{WORD_SIZE}＞0？″[″.($rf＞{WORD_SIZE}-1).″0]″″″； $rf-＞{HI_ADDR_SIZE}＝ceil_log2($rf-＞{MAX_HEIGHT})； $rf-＞{LO_ADDR_SIZE}＝$rf-＞{HI_ADDR_SIZE}-$rf-＞{ADDR_SIZE}； $rf-＞{FULL_WORD_SIZE}＝$rf-＞{MAX_WIDTH}； $rf-＞{FULL_WORD_DECL}＝$rf-＞{FULL_WORD_SIZE}＞0？″[″.($rf-＞{FULL_WORD_SIZE}-1).″0]″″″； $rf-＞{MAX_LATENCY}＝0； foreach$write_port(@{$rf-＞{WRITE_PORT}}){ my(@def)＝sort(&amp;uniq(@{$write_port-＞{DEF}}))； $write_port-＞{DEF}＝\@def； $write_port-＞{MAX_DEF}＝&amp;max(2，@{$write_port-＞{DEF}})； $write_port-＞{MAX_WIDTE}＝max(@{$write_port-＞{WIDTH}})； $rf-＞{MAX_LATENCY}＝max($rf-＞{MAX_LATENCY}，$write_port-＞{MAX_DEF})； } foreach$read_port(@{$rf-＞{READ_PORT}}){ my(@use)＝sort(&amp;uniq(@{$read_port-＞{USE}}))； $read_port-＞{USE}＝\@use； $read_port-＞{MIN_USE}＝min(@{$read_port-＞{USE}})；<dpn="d375"/> $read_port-＞{MAX_USE}＝max(@{$read_port-＞{USE}})； $read_port-＞{MAX_WIDTH}＝max(@{$read_port-＞{WIDTH}})； } $rf-＞{NUM_TEST_VECTOR}＝$rf-＞{NUM_TEST_VECTOR}||1000； $rf-＞{USE_LATCHES}＝$rf-＞{USE_LATCHES}||1； $rf-＞{TEST_TRANSPARENT_LATCHES}＝$rf-＞{TEST_TRANSPARENT_LATCHES}||0； if.($rf-＞{TRANSPARENT_LATCH_MODE}){#anoldnameforit $rf-＞{TEST_TRANSPARENT_LATCHES}＝1； } $rf-＞{DESIGN_PREFIX}＝$rf-＞{DESIGN_PREFIX}||″″； } subwrite_regfile{ my($rf)＝@_； my($lo_addrdecl，@io1ist，$s，$i，$j，$h，$l，$w)； my(@defer，$read_port，$write_port)； $lo_addr_decl＝$rf-＞{LO_ADDR_SIZE}＞0？″[″.($rf-＞{LO_ADDR_SIZE}-1).″0]″″″； init_print_break(2)； print_break(″module$rf-＞{DESIGN_PREFIX}$rf-＞{NAME}(″)； foreach$read_port(@{$rf-＞{READ_PORT}}){ foreach$s(@{$read_port-＞{USE}}){ my($data)＝rfield(″data″，$read_port，$s)； my($decl)＝″[″.($read_port-＞{MAX_WIDTH}-1).″0]″； print_break(″$data，″)； push(@iolist，″output$decl$data；\n″)； } #don′tneedanaddressforasinglewordregisterfile if($rf-＞{HI_ADDR_SIZE}＞0){ my($adar)＝rfield(″addr″，$read_port，0)； my($decl)＝″[″.($rf-＞{HI_ADDR_SIZE}-1).″0]″； print_break(″$addr，″)； push(@iolist，″input$decl$addr；\n″)； }else{ my($addr)＝rfield(″addr″，$read_port，0)； push(@defer，″wire$addr＝0；\n″)； } foreach$w(@{$read_port-＞{WIDTH}}){ my($width)＝rfield{″width$w″，$read_port，0)； print_break(″$width，″)； push(@iolist，″input$Width；\n″)； } foreach$s(@{$read_port-＞{USE}}){ my($use)＝rfield(″use$s″，$read_port，0)； print_break(″$use，″)； push(@iolist，″input$use；\n″)； } } foreach$write_port(@{$rf-＞{WRITE_PORT}}){ #don′tneedanaddressforasinglewordregisterfile if($rf-＞{HI_ADDR_SIZE}＞0){ my($addr)＝wfield(″addr″，$write_port，0)； my($decl)＝″[″.($rf-＞{HI_ADDR_SIZE}-1).″0]″；<dpn="d376"/> print_break(″$addr，″)； push(@iolist，″input$decl$addr；\n″)； }else{ my($addr)＝rfield(″addr″，$write_port，0)； push(@defer，″wire$addr＝0；\n″)； } foreach$w(@{$write_port-＞{WIDTH}}){ my($width)＝rfield(″width$w″，$write_port，0)； print_break(″$width，″)； push(@iolist，″input$width；\n″)； } foreach$s(@{$write_port-＞{DEF}}){ my($def)＝wfield(″def$s″，$write_port，0)； print_break(″$def，″)； push(@iolist，″input$def；\n″)； } foreach$w(@{$write_port-＞{WIDTH}}){ foreach$s(@{$write_port-＞{DEF}}){ my($data)＝wfield(″data$w″，$write_port，$s)； my($decl)＝″[″.($w-1).″0]″； print_break(″$data，″)； push(@iolist，″input$decl$data；\n″)； } } foreach$s(1..$write_port-＞{MAX_DEF}){ my($wen)＝wfield(″wen″，$write_port，$s)； if($s＞&amp;max(@{$write_port-＞{DEF}})){ push(@defer，″wire$wen＝1′d1；\n″)； }else{ print_break(″$wen，″)； push(@iolist，″input$wen；\n″)； } }}print_break(″Kill_E，″)；push(@iolist，″inputKill_E；\n″)；print_break(″KillPipe_W，″)；push(@iolist，″inputKillPipe_w；\n″)；print_break(″Stall_R，″)；push(@iolist，″outputStall_R；\n″)；if($rf-＞{USE_LATCHES}&amp;&amp;$rf-＞{TEST_TRANSPARENT_LATCHES}){ print_break(″TMode，″)； push(@iolist，″inputTMode；\n″)；}print_break(″clk)；\n″)；push(@iolist，″inputclk；\n″)；printjoin(′′，@iolist)；print″\n″；printjoin(′′，@defer)；print″\n″；foreach$read_port(@{$rf-＞{READ_PORT}}){<dpn="d377"/> print″/*″.(′*′x70).″\n″； print″READPORT$read_port-＞{NAME}\n″； print″*″.(′*′x70).″/\n″； if($rf-＞{LO_ADDR_SIZE}＞0){ my(@data，@sel)； foreach$w(@{$read_port-＞{WIDTH}}){ my($width)＝rfield(″width$w″，$read_port，0)； my($mask)＝-($w/$rf-＞{MIN_WIDTH}-1)&amp;((1＜＜$rf-＞{LO_ADDR_SIZE})-1)； push(@data，$rf-＞{LO_ADDR_SIZE}.″′d″.$mask)； push(@sel，$width)； } my($addr_mask)＝rfield(″addr_mask″，$read_port，0)； print″wire$lo_addr_decl$addr_mask；\n″； inline_mux(\@data，\@sel，$rf-＞{LO_ADDR_SIZE}，$addr_mask，″selector″)； }else{ my($addr_mask)＝rfield(″addr_mask″，$read_port，0)； print″wire$addr_mask＝0；\n″； } print″\n″； print″//maskedaddresspipeline\n″； if($rf-＞{LO_ADDR_SIZE}＞0){ my($addr)＝rfield(″addr″，$read_port，0)； my($maddr)＝rfield(″maddr″，$read_port，0)； my($addr_mask)＝rfield(″addr_mask″，$read_port，0)； print″wire$lo_addr_decl$maddr＝$addr&amp;$addr_mask；\n″； for($s＝1；$s＜＝$read_port-＞{MAX_USE}；$s++){ my($maddr)＝rfield(″maddr″，$read_port，$s)； print″wire$lo_addr_decl$maddr；\n″； } for($s＝1；$s＜＝$read_port-＞{MAX_USE}；$s++){ my($maddr)＝rfield(″maddr″，$read_port，$s-1)； my($maddrl)＝rfield(″maddr″，$read_port，$s)； print″xtdelay1#($rf-＞{LO_ADDR_SIZE})i$maddr1($maddrl，$maddr，clk)；\n″； } }else{ my($maddr)＝rfield(″maddr″，$read_port，0)； print″wire$maddr＝0；\n″； } print″\n″； print″//bank-qualifieduse\n″； foreach$s(@{$read_port-＞{USE}}){ foreach$i(0..$rf-＞{NUM_BANK}-1){ my($use)＝rfield(″use$s″，$read_port，0)； my($maddr)＝rfield(″maddr″，$read_port，0)； my($addr_mask)＝rfield(″addr_mask″，$read_port，0)； my($use_banki)＝rfield(″use$s″.″_bank$i″，$read_port，0)； print″wire$use_banki＝($use&amp;($maddr＝＝($i&amp;$addr_mask)))；\n″； } } print″\n″；<dpn="d378"/> #determinewhichbanksneedtobemuxedintowhichoutputports my(@align)； for($i＝0；$i＜$rf-＞{NUM_BANK}；$i++){ $align[$i]＝[]； } for($w＝1；$w＜＝$rf-＞{NUM_BANK}；$w*＝2){ #doesthisportneedthisread-width？ if(grep($_＝＝$w*$rf-＞{MIN_WIDTH}，@{$read_port-＞{WIDTH}})){ for($j＝0；$j＜$rf-＞{NUM_BANK}；$j+＝$w){ for($i＝0；$i＜$w；$i++){ push(@{$align[$i]}，$i+$j)； } } } } for($i＝0；$i＜$rf-＞{NUM_BANK}；$i++){ @{$align[$i]}＝sort{$a＜＝＞$b}(&amp;uniq(@{$align[$i]}))； } #printSTDOUT″Readtable\n″； #for($i＝0；$i＜$rf-＞{NUM_BANK}；$i++){ #printSTDOUT″set$i″.join(′′，@{$align[$i]}).″\n″； #} foreach$s(@{$read_port-＞{USE}}){ print″//alignmentmuxforuse$s\n″； for($i＝0；$i＜$rf-＞{NUM_BANK}；$i++){ my($data_banki)＝rfield(″data_bank$i″，$read_port，$s)； print″wire$rf-＞{WORD_DECL}$data_banki；\n″； } for($i＝0；$i＜$rf-＞{NUM_BANK}；$i++){ my(@data)；foreach$j(@{$align[$i]}){my($data_bankj)＝rfield(″data_bank$j″，$read_port，$s)；push(@data，$data_bankj)；}$h＝$rf-＞{LO_ADDR_SIZE}-1；$l＝$rf-＞{LO_ADDR_SIZE}-ceil_log2($#data+1)；my($sel)＝rfield(″maddr″，$read_port，$s).″[$h$l]″；$b＝$rf-＞{MIN_WIDTH}*($i+1)-1；$l＝$rf-＞{MIN_WIDTH}*$i；my($data)＝rfield(″data″，$read_port，$s).″[$h$l]″；my($prefix)＝rfield(″align$i″，$read_port，$s)；if(@data＞0){inline_mux(\@data，$sel，$rf-＞{WORD_SIZE}，$data,″encoded″)；}}print″\n″；}print″\n″；}<dpn="d379"/> foreach$write_port(@{$rf-＞{WRITE_PORT}}){ print″/*″.(′*′x70).″\n″； print″WRITEPORT$write_port-＞{NAME}\n″； print″*″.(′*′x70).″/\n″； if($rf-＞{LO_ADDR_SIZE}＞0).{ my(@data，@sel)； foreach$w(@{$write_port-＞{WIDTH}}){ my($width)＝wfield(″width$w″，$write_port，0)； my($mask)＝～($w/$rf-＞{MIN_WIDTH}-1)&amp;((1＜＜$rf-＞{LO_ADDR_SIZE})-1)； push(@data，$rf-＞{LO_ADDR_SIZE}.″′d″.$mask)； push(@sel，$width)； } my($addr_mask)＝wfield(″addr_mask″，$write_port，0)； print″wire$lo_addr_decl$addr_mask；\n″； inline_mux(\@data，\@sel，$rf-＞{LO_ADDR_SIZE}，$addr_mask，″selector″)； }else{ my($addr_mask)＝wfield(″addr_mask″，$write_port，0)； print″wire$addr_mask＝0；\n″； } print″\n″； if(@{$write_port-＞{WIDTH}}＞1){ print″//widthpipeline\n″； foreach$w(@{$write_port-＞{WIDTH}}){ for($s＝1；$s＜＝$write_port-＞{MAX_DEF}；$s++){ my($width)＝wfield(″width$w″，$write_port，$s)； print″wire$width；\n″； } for($s＝1；$s＜＝$write_port-＞{MAX_DEF}；$s++){ my($width)＝wfield(″width$w″，$write_port，$s-1)； my($width1)＝wfield(″width$w″，$write_port，$s)； print″xtdelay1#(1)i$width1($width1，$width，clk)；\n″； } } print″\n″； } print″//bank-qualifiedwritedefforport$write_port-＞{NAME}\n″； foreach$s(@{$write_port-＞{DEF}}){ foreach$i(0..$rf-＞{NUM_BANK}-1){ my($def)＝wfield(″def$s″，$write_port，0)； my($addr)＝wfield(″addr″，$write_port，0)； my($addr_mask)＝wfield(″addr_mask″，$write_port，0)； my($def_banki)＝wfield(″def$s″.″_bank$i″，$write_port，0)； print″wire$def_banki＝($def&amp;(($addr&amp;$addr_mask)＝＝($i&amp;$addr_mask)))；\n″； } } print″\n″； foreach$s(@{$write_port-＞{DEF}}){ my(@data，@sel)； print″//writemuxfordef$s\n″； my($wdata)＝wfield(″wdata″，$write_port，$s)； foreach$w(@{$write_port-＞{WIDTH}}){<dpn="d380"/> $i＝$rf-＞{MAX_WIDTH}/$w； my($width)＝wfield(″width$w″，$write_port，$s)； my($data)＝wfield(″data$w″，$write_port，$s)； $data＝″{″.$i.″{$data″.″[″.($w-1).″0]}}″； push(@data，$data)； push(@sel，$width)； } print″wire$rf-＞{FULL_WORD_DECL}$wdata；\n″； inline_mux(\@data，\@sel，$rf-＞{FULL_WORD_SIZE}，$wdata，″selector″)； print″\n″； } print″\n″； } #dropncopiesofthepipelinedregfile print″/*″.(′*′x70).″\n″； print″PIPELINEDBANK\n″； print″*″.(′*′x70).″/\n″； for($i＝0；$i＜$rf-＞{NUM_BANK}；$i++){ init_print_break(8)； print_break(″$rf-＞{DESIGN_PREFIX}$rf-＞{NAME}_bank$rf-＞{NAME}_bank$i(″)； foreach$read_port(@{$rf-＞{READ_PORT}}){ foreach$s(@{$read_port-＞{USE}}){ my($data_banki)＝rfield(″data_bank$i″，$read_port，$s)； print_break(″$data_banki，″)； } #don′tneedanaddressforasinglewordregisterfile if($rf-＞{ADDR_SIZE}＞0){ my($addr)＝rfield(″addr″，$read_port，0)； my($decl)＝″[″.($rf-＞{HI_ADDR_SIZE}-1).″$rf-＞{LO_ADDR_SIZE}]″； print_break(″$addr$decl，″)； } foreach$s(@{$read_port-＞{USE}}){ my($use_banki)＝rfield(″use$s″.″_bank$i″，$read_port，0)； print_break(″$use_banki，″)； } } foreach$write_port(@{$rf-＞{WRITE_PORT}}){ if($rf-＞{ADDR_SIZE}＞0){ my($addr)＝wfield(″addr″，$write_port，0)； my($decl)＝″[″.($rf-＞{HI_ADDR_SIZE}-1).″$rf-＞{LO_ADDR_SIZE}]″； print_break(″$addr$decl，″)； } foreach$s(@{$write_port-＞{DEF}}){ my($def_banki)＝wfield(″def$s″.″_barnk$i″，$write_port，0)； print_break(″$def_banki，″)； } foreach$s(@{$write_port-＞{DEF}}){ my($wdata)＝wfield(″wdata″，$write_port，$s)； $h＝$rf-＞{MIN_WIDTH}*($i+1)-1； $l＝$rf-＞{MIN_WIDTH}*$i； print_break(″$wdata″.″[$h$l]，″)；<dpn="d381"/> } foreach$s(1..$write_port-＞{MAX_DEF}){ my($wen)＝wfield(″wen″，$write_port，$s)； print_break(″$wen，″)； } } print_break(″Kill_E，″)； print_break(″KillPipe_W，″)； print_break(″Stall_R$i，″)； if($rf-＞{USE_LATCHES}&amp;&amp;$rf-＞{TEST_TRANSPARENT_LATCHES}){ print_break(″TMode，″)； } print_break(″clk)；\n″)； print″\n″； } print″assignStall_R＝″； for($i＝0；$i＜$rf-＞{NUM_BANK}；$i++){ print″Stall_R$i|″； } print″1′b0；\n″； print″\n″； print″endmodule\n″； } subwrite_regfile_bank{ my($rf)＝@_； my(@defer，@iolist，$s，$s1，$rs，$ws，$i，$j，$read_port，$writeport，$result)； init_print_break(2)； print_break(″module$rf-＞{DESIGN_PREFIX}$rf-＞{NAME}_bank(″)； #read_portI/Olist foreach$read_port(@{$rf-＞{READ_PORT}}){ foreach$s(@{$read_port-＞{USE}}){ my($data)＝rfield(″data″，$read_port，$s)； print_break(″$data，″)； push(@iolist，″output$rf-＞{WORD_DECL}$data；\n″)； } #don′tneedanaddressforasinglewotdregisterfile my($addr)＝rfield(″addr″，$read_port，0)； if($rf-＞{ADDR_SIZE}＞0){ print_break(″$addr，″)； push(@iolist，″input$rf-＞{ADDR_DECL}$addr；\n″)； }else{ push(@defer，″wire$rf-＞{ADDR_DECL}$addr＝0；\n″)； } foreach$s(1..$rf-＞{MAX_LATENCY}){ my($use)＝rfield(″use$s″，$read_port，0)； if(read_use($read_port，$s)){ print_break(″$use，″)； push(@iolist，″input$use；\n″)；<dpn="d382"/> }else{ push(@defer，″wire$use＝0；\n″)； } }}#writeportI/Olistforeach$write_port(@{$rf->{WRITE_PORT}}){my($addr)＝wfield(″addr″，$write_port，0)；if($rf->{ADDR_SIZE}>0){ print_break(″$addr，″) push(@iolist，″input$rf->{ADDR_DECL}$addr；\n″)；}else{ push(@defer，″wire$rf-＞{ADDR_DECL}$addr＝0；\n″)；}foreach$s(1..$write_port->{MAX_DEF}){ my($def)＝wfield(″def$s″，$write_port，0)； if(write_def($write_port，$s)){ print_break(″$data，″)； push(@iolist，″input$def；\n″)； }else{ push(@defer，″wire$def＝0；\n″)； }}foreach$s(1..$write_port->{MAX_DEF}){ my($data)＝wfield(″data″$write_port，$s)； if(write_def($write_port，$s)){ print_break(″$data，″) push(@iolist，″input$rf->{WORD_DECL}$date；\n″)； }else{ push(@defer，″wire$rf-＞{WORD_DECL}$data＝0；\n″)； }}foreach$s(1..$write_port->{MAX_DEF}){ my($wen)＝wfield(″wen″，$write_port，$s)； prin_break(″$wen，″)； push(@iolist″input$wen；\n″)；}}print_break(″Kill_E，″)；push(@iolist，″inputKill_E；\n″)；print_break(″KillPipe_W，″)；push(@iolist，″inputKillPipe_W；\n″)；print_break(″Stall_R，″)；push(@iolist，″outputStall_R；\n″)；if($rf->{USE_LATCHES}&amp;&amp;$rf->{TEST_TRANSPARENT_LATCHES}){print_break(″TMode，″)；push(@iolist，″inputTMode；\n″)；}print_break(″clk)；\n″)；push(@iolist，″inputclk；\n″)；<dpn="d383"/> printjoin(′′，@iolist)； print″\n″； printjoin(′′，@defer)； print″\n″； for($s＝0；$s＜＝$rf-＞{MAX_LATENCY}+1；$s++){ #can′tkillaftercommitpointwhichisC3 my($kill)＝″kill_C$s″； my($value)＝ $s＝＝1？″KillPipe_W|Kill_E″ $s＜＝3？″KillPipe_W″ ″1′b0″； print″wire$kill＝$value；\n″； } print″\n″；########################################################################### #Write-portinformation########################################################################### foreach$write_port(@{$rf-＞{WRITE_PORT}}){ #writedefinitionpipeline print″//writedefinitionpipeline\n″； for($s＝1；$s＜＝$write_port-＞{MAX_DEF}；$s++){ for($i＝$s；$i＜＝$write_port-＞{MAX_DEF}；$i++){ my($wen)＝$s＝＝1？″1″wfield(″wen″，$write_port，$s-1)； my($def)＝wfield(″def$i″，$write_port，$s-1)； my($ns_def)＝wfield(″ns_def$i″，$write_port，$s-1)； my($defl)＝wfield(″def$i″，$write_port，$s)； my($kill)＝″kill_C″.($s-1)； if(write_def($write_port，$i)){ print″wire$ns_def＝$def&amp;$wen&amp;-$kill；\n″； print″xtdelay1#(1)i$def1($def1，$ns_def，clk)；\n″； }else{ print″wire$ns_def＝0；\n″； print″wire$def1＝0；\n″； } } } print″\n″； #writeenablepipeline print″//writeenablepipeline\n″； for($s＝1；$s＜＝$write_port-＞{MAX_DEF}；$s++){ my$wel＝wfield(″we″，$write_port，$s+1)； print″wire$we1；\n″； } for($s＝1；$s＜＝$write_port-＞{MAX_DEF}+1；$s++){ my$first＝$s＝＝1； my$last＝$s＝＝$write_port-＞{MAX_DEF}+1； my$we＝$first？″1′d0″wfield(″we″，$write_port，$s)； my$def＝$last？″1′d0″wfield(″def$s″，$write_Port，$s)； my$wen＝$last？″1′d0″wfield(″wen″，$write_port，$s)；<dpn="d384"/> my$kill＝″kill_C$s″； my$ns_we＝wfield(″ns_we″，$write_port，$s)； print″wire$ns_we＝($we|($def&amp;$wen))&amp;-$kill；\n″； } for($s＝1；$s＜＝$write_port-＞{MAX_DEF}；$s++){ my$ns_we＝wfield(″ns_we″，$write_port，$s)； my$we1＝wfield(″we″，$write_port，$s+1)； print″xtdelay1#(1)i$we1($we1，$ns_we，clk)；\n″； } print″\n″； #Writeaddresspipeline print″//writeaddresspipeline\n″； for($s＝1；$s＜＝$write_port-＞{MAX_DEF}+1；$s++){ my$addr＝wfield(″addr″，$writeport，$s)； print″wire$rf-＞{ADDR_DECL}$addr；\n″； } for($s＝1；$s＜＝$write_port-＞{MAX_DEF}+1；$s++){ my$addr＝wfield(″addr″，$write_port，$s-1)； my$addr1＝wfield(″addr″，$write_port，$s)； if($rf-＞{ADDR_SIZE}＝＝0){ print″assign$addr1＝0；\n″； }else{ print″xtdelay1#($rf-＞{ADDR_SIZE})i$addr1($addr1，$addr，clk)；\n″； } } print″\n″； #Writedatapipeline print″//writedatapipeline\n″； for($s＝1；$s＜＝$write_port-＞{MAX_DEF}；$s++){ my$result1＝wfield(″result″，$write_port，$s+1)； print″wire$rf-＞{WORD_DECL}$result1；\n″； } for($s＝1；$s＜＝$write_port-＞{MAX_DEF}+1；$s++){ my$result＝wfield(″result″，$write_port，$s)； my$data＝wfield(″data″，$write_port，$s)； my$sel＝wfield(″def$s″，$write_port，$s)； my$mux＝wfield(″mux″，$write_port，$s)； if($s＝＝1){ print″wire$rf-＞{WORD_DECL}$mux＝$data；\n″； }elsif($s＝＝$write_port-＞{MAX_DEF}+1){ print″wire$rf-＞{WORD_DECL}$mux＝$result；\n″； }else{$result；\n″；print″wire$rf-＞{WORD_DECL}$mux＝$sel？$data #print″xtmux2e#($rf->{WORD_SIZE})i$mux($mux，$result，$data，$sel；\n″； } } for($s＝1；$s＜＝$write_port-＞{MAX_DEF}；$s++){ my$mux＝wfield(″mux″，$write_port，$s)； my$result1＝wfield(″result″，$write_port，$s+1)； print″xtdelay1#($rf-＞{WORD_SIZE})i$result1($result1，$mux，clk)\n″； } print″\n″；<dpn="d385"/> }########################################################################### #Read-portinformation########################################################################### foreach$read_port(@{$rf-＞{READ_PORT}}){ #needtodeclarereaddatawhicharen′tports for($s＝$read_port-＞{MIN_USE}-1；$s＜＝$read_port-＞{MAX_USE}；$s++){ if(！read_use($read_port，$s)){ my($data)＝rfield(″data″，$read_port，$s)； print″wire$rf-＞{WORD_DECL}$data；\n″； } } } print″\n″； foreach$read_port(@{$rf-＞{READ_PORT}}){ if($read_port-＞{MAX_USE}＞＝2){ print″//readaddresspipelineforport$read_port-＞{NAME}\n″； for($s＝1；$g＜＝$read_port-＞{MAX_USE}-1；$s++){ my$addr1＝rfield(″addr″，$read_port，$s)； print″wire$rf-＞{ADDR_DECL}$aadr1；\n″； } for($s＝1；$s＜＝$read_port-＞{MAX_USE}-1；$s++){ my$addr＝rfield(″addr″，$read_port，$s-1)； my$addr1＝rfield(″addr″，$read_port，$s)； if($rf-＞{ADDR_SIZE}＝＝0){ print″assign$addr1＝0；\n″； }else{ print″xtdelay1#($rf-＞{ADDR_SIZE}}i$addr1($addr1，$addr，clk)；\n″； } } print″\n″； } $rs＝＜＜DOCUMENTATION； Bypasslogicgenerationissomewhattricky.Forthefirstuse (typicallyuse1)thedatacomesfrom (a)writedatacomingfromthedatapath(wr0_data_Ci，i＝1..n) (b)datastoredinthewritepipeline(wr0_result_Cn，i＝2..n+1) (c)theregisterfile(rd0_data_C0) Forlateruses(e.g.，use2)thedatacomesfrom (a)writedatacomingfromthedatapath(wr0_data_Ci，i＝2..n) (b)thereadpipelinepreviousstage(rd0_data_C{i-1}) ToavoidWAWhazards，thereisadefinedpriorityonthisdata. Considerause1，2，3，4readpipeandadef1，2，3，4writepipe.<dpn="d386"/> Thepriorityorderforuse1is wr0_data_C1， wr0_data_C2， wr0_result_C2， wr0_data_C3， wr0_result_C3， wr0_data_C4， wr0_result_C4， wr0_result_C5， registerfile. Thepriorityorderforuse2issimilar，exceptforallplaceswhere thewritepipelinewouldbeused，weusethepreviousstageread pipelineinstead.Thisisbecausethedatastoredinthewrite pipelinehasalreadybeenbypassedintothereadpipelineea rlier. Hence，theuniquesourcesarewr0_data_C2，wr0_data_C3，wr0_data_C4， rd0_data_C1withapriorityorderof wr0_data_C1， wr0_data_C2， rd0_data_C1， wr0_data_C3， rd0_data_C1， wr0_data_C4， rd0_data_C1， rd0_data_C1， rd0_data_C1. Becauseofallofthewritepipelinedataisavailableveryearly，we buildaspecialmuxforthefirststagebypass.Wefirstmuxtogether allofthestoreddatainthewritepipewiththereaddatafromthe registerfile.Thenwemuxtogetherallofthedatacomingfromthe datapath.Finally，weselectbetweenthesetwo. DOCUMENTATION if($mainverify){ for($rs＝$read_port-＞{MIN_USE}-1；$rs＜＝$read_port-＞{MAX_USE}-1；$rs++){ my$rdata＝rfield(″data″，$read_port，$rs)； my$rdata1＝rfield(″data″，$read_port，$rs+1)； print″xtdelay1#($rf-＞{WORD_SIZE})i$rdata1($rdata1，$rdata，clk)；\n″； } print″\n″； }else{ print″//Readbypasscontrolsforport$read_port-＞{NAME}\n″； #bypassthedatabeingdefinedinstage$ws for($rs＝$read_port-＞{MIN_USE}-1；$rs＜＝$read_port-＞{MAX_USE}-1；$rs++){ for($ws＝$rs+1；$ws＜＝$rf-＞{MAX_LATENCY}+1；$ws++){<dpn="d387"/> foreach$write_port(@{$rf-＞{WRITE_PORT}}){ if(write_def($write_port，$ws)){ my$waddr＝wfield(″addr″，$write_port，$ws)； my$raddr＝rfield(″addr″，$read_port，$rs)； my$def＝wfield(″def$ws″，$write_port，$ws)； my$wen＝wfield(″wen″，$write_port，$ws)； my$kill＝″kill_C$ws″； my$bypass＝″bypass_data_$read_port-＞{NAME}_C$rs\_$write_port-＞{NAME}_C$ws″； print″wire$bypass＝($waddr＝＝$raddr)&amp;$def&amp;$wen&amp;-$kill；\n″； } } } } #bypasstheolddatainthewritepipelineinstage$ws for($rs＝$read_port-＞{MIN_USE}-1；$rs＜＝$read_port-＞{MAX_USE}-1；$rs++){ for($ws＝$rs+1；$ws＜＝$rf-＞{MAX_LATENCY}+1；$ws++){ foreach$write_port(@{$rf-＞{WRITE_PORT}}){ if($ws＞1&amp;&amp;$rs＜＝$write_port-＞{MAX_DEF}+1){ my$waddr＝wfield(″addr″，$write_port，$ws)； my$raddr＝rfield(″addr″，$read_port，$rs)； my$we＝wfield(″we″，$write_port，$ws)； my$kill＝″kill_C$ws″； my$bypass＝″bypass_result_$read_port-＞{NAME}_C$rs\_$write_port-＞{NAME}_C$ws″； print″wire$bypass＝($waddr＝＝$raddr)&amp;$we&amp;-$kill；\n″； } } } } print″\n″； for($rs＝$read_port-＞{MIN_USE}-1；$rs＜＝$read_port-＞{MAX_USE}-1；$rs++){ my$mux＝rfield(″mux″，$read_port，$rs)； my$mux_result＝rfield(″mux_result″，$read_port，$rs)； my$rdata＝rfield(″data″，$read_port，$rs)； my$rdata1＝rfield(″data″，$read_port，$rs+1)； print″//Readbypassforport$read_port-＞{NAME}use″.($rs+1).″\n″； if($rs＝＝$read_port-＞{MIN_USE}-1){ my(@data，@sel)； #bypasstheresultsfromthewritepipeline(s) for($ws＝$rs+1；$ws＜＝$rf-＞{MAX_LATENCY}+1；$ws++){foreach$write_port(@{$rf-＞{WRITE_PORT}}){ if($ws＞1&amp;&amp;$rs＜＝$write_port-＞{MAX_DEF}+1){ my$result＝wfield(″result″，$write_port，$ws)； my$bypass＝″bypass_result_$read_port-＞{NAME}_C$rs\_$write_port-＞{NAME)_C$ws″； push(@data，$result)； push(@sel，$bypass)； }<dpn="d388"/> } } #lowestpriorityisdatafromregisterfile push(@data，$rdata)； print″wire$rf-＞{WORD_DECL}$mux_result；\n″； inline_mux(\@data，\@sel，$rf-＞{WORD_SIZE}，$mux_result，″priority″)； $rdata＝$mux_result； } #choosebinaryencodingforthedatabypassmux #orderstage2last，readdatafirst my(@data，@sel，$ncode，％code)； $ncode＝0； $code{$rdata}＝$ncode++； for($ws＝$rs+1；$ws＜＝$rf-＞{MAX_LATENCY}+1；$ws++){ foreach$write_port(@{$rf-＞{WRITE_PORT}}){ if($rs＜＝$write_port-＞{MAX_DEF}+1){ if($ws！＝2&amp;&amp;write_def($write_port，$ws)){ my$wdata＝wfield(″data″，$write_port，$ws)； $code{$wdata}＝$ncode++； } } } } foreach$write_port(@{$rf-＞{WRITE_PORT}}){ if(w-rite_def($write_port，2)){ my$wdata＝wfield(″data″，$write_port，2)； $code{$wdata}＝$ncode++； } } #bui1dthepriority-encodedbypassmux for($ws＝$rs+1；$ws＜＝$rf-＞{MAX_LATENCY}+1；$ws++){ foreach$write_port(@{$rf-＞{WRITE_PORT}}){ if($rs＜＝$write_port-＞{MAX_DEF}+1){ if(write_def($write_port，$ws)){ my$wdata＝wfield(″data″，$write_port，$ws)； my$bypass＝″bypass_data_$read_port-＞{NAME}_C$rs\_$write_port-＞{NAME}_C$ws″； push(@data，$wdata)； push(@sel，$bypass)； } if($ws＞1){ my$bypass＝″bypass_result_$read_port-＞{NAME}_C$rs\_$write_port-＞{NAME}_C$ws″； push(@data，$rdata)； push(@sel，$bypass)； } } } } push(@data，$rdata)； print″wire$rf-＞{WORD_DECL}$mux；\n″； inline_mux(\@data，\@sel，$rf-＞{WORD_SIZE}，$mux，″priority″，\％code)；<dpn="d389"/> print″xtdelay1#($rf-＞{WORD_SIZE})i$rdata1($rdatal，$mux，clk)；\n″； print″\n″； } } } print″assignStall_R＝\n″； foreach$write_port(@{$rf-＞{WRITE_PORT}}){ foreach$read_port(@{$rf-＞{READ_PORT}}){ for($s＝1；$s＜＝$write_port-＞{MAX_DEF}-1；$s++){ my($waddr)＝wfield(″addr″，$write_port，$s)； my($raddr)＝rfield(″addr″，$read_port，0)； print″(($waddr＝＝$raddr)&amp;(\n″； for($i＝1；$i＜＝$write_port-＞{MAX_DEF}-$s；$i++){ my($use)＝rfield(″use$i″，$read_port，0)； print″($use&amp;(″； for($j＝$i+$s；$j＜＝$write_port-＞{MAX_DEF}；$j++){ my($ns_def)＝wfield(″ns_def$j″，$write_port，$s)； print″$ns_def″； if($j！＝$write_port-＞{MAX_DEF}){ print″|″； } } print″))″； if($i＝＝$write_port-＞{MAX_DEF}-$s){ print″))|\n″； }else{ print″|\n″； } } } } } print″1′bo；\n″； print″\n″；########################################################################### #Dropthecore-cell########################################################################### if($mainverify){ print″//verificationregisterfilecore--hack\n″； my$last； foreach$write_port(@{$rf-＞{WRITE_PORT}}){ my$data＝wfield(″result″，$write_port，$write_port-＞{MAX_DEF}+1)； my$we＝wfield(″ns_we″，$write_port，$write_port-＞{MAX_DEF}+1)； my$tmp＝wfield(″tmp″，$write_port，$write_port-＞{MAX_DEF}+1)； print″wire$rf-＞{WORD_DECL}$tmp；\n″； print″xtenflop#($rf-＞{WORD_SIZE})x$tmp($tmp，$data，$we，clk)；\n″； $last＝$tmp； } foreach$read_port(@{$rf-＞{READ_PORT}}){ my$data＝rfield(″data″，$read_port，$read_port-＞{MIN_USE}-1)；<dpn="d390"/> print″xtflop#($rf-＞{WORD_SIZE})x$data($data，$last，clk)；\n″； } }else{ print″//registerfilecore\n″； init_print_break(8)； my$r＝@{$rf-＞{READ_PORT}}； my$w＝@{$rf-＞{WRITE_PORT}}； my$n＝$rf-＞{MIN_HEIGHT}； my$module＝″xtregfile_${r}R${w}W_${n}″； if(！$rf-＞{USE_LATCHES}){ $module.＝″_FF″； } print_break(″$module#($rf-＞{WORD_SIZE})icore(″)； foreach$read_port(@{$rf-＞{READ_PORT}}){ my$data＝rfield(″data″，$read_port，$read_port-＞{MIN_USE}-1)； print_break(″$data，″)； if($rf-＞{ADDR_SIZE}＞0){ my$addr＝rfield(″addr″，$read_port，$read_port-＞{MIN_USE}-1)； print_break(″$addr，″)； } } foreach$write_port(@{$rf-＞{WRITE_PORT}}){ my$data＝wfield(″result″，$write_port，$write_port＞{MAX_DEF}+1)； print_break(″$data，″)； if($rf-＞{ADDR_SIZE}＞0){ my$addr＝wfield(″addr″，$write_port，$write_port-＞{MAX_DEF}+1)； print_break(″$addr，″)； } my$we＝wfield(″ns_we″，$write_port，$write_port-＞{MAX_DEF}+1)； print_break(″$we，″)； } if($rf-＞{USE_LATCHES}&amp;&amp;$rf-＞{TEST_TRANSPARENT_LATCHES}){ print_break(″TMode，″)； } print_break(″clk)；\n″)； } print″endmodule\n″； } subset_def{ my($rf)＝@_； my($def，$s，$w，$read_port，$write_port，$field，$width，$data_size，$addr_size)； $def-＞{Kill_E}＝{SIZE＝＞1，DIR＝＞″in″，DEFAULT＝＞″0″}； $def-＞{KillPipe_W}＝{SIZE＝＞1，DIR＝＞″in″，DEFAULT＝＞″0″}； $def-＞{Stall_R}＝{SIZE＝＞1，DIR＝＞″out″}； foreach$read_port(@{$rf-＞{READ_PORT}}){ $data_size＝$read_port-＞{MAX_WIDTH}； $addr_size＝$rf-＞{HI_ADDR_SIZE}；<dpn="d391"/> $field＝rfield(″addr″，$read_port，0)； $def-＞{$field}＝{SIZE＝＞$addr_size，DIR＝＞″in″，DEFAULT＝＞″x″}； foreach$s(@{$read_Port-＞{USE}}){ $field＝rfield(″use$s″，$read_port，0)； $def-＞{$field}＝{SIZE＝＞1，DIR＝＞″in″，DEFAULT＝＞″0″}； $field＝rfield(″data″，$read_port，$s)； $def-＞{$field}＝{SIZE＝＞$data_size，DIR＝＞″out″}； } foreach$width(@{$read_port-＞{WIDTH}}){ $field＝rfield(″width$width″，$read_port，0)； $def-＞{$field}＝{SIZE＝＞1，DIR＝＞″in″，DEFAULT＝＞″0″}； } } foreach$write_port(@{$rf-＞{WRITE_PORT}}){ $data_size＝$write_port-＞{MAX_WIDTH}； $addr_size＝$rf-＞{HI_ADDR_SIZE}； $field＝wfield(″addr″，$write_port，0)； $def-＞{$field}＝{SIZE＝＞$addr_size，DIR＝＞″in″，DEFAULT＝＞″x″}； foreach$s(@{$write_port-＞{DEF}}){ $field＝wfield(″def$s″，$write_port，0)； $def-＞{$field}＝{SIZE＝＞1，DIR＝＞″in″，DEFAULT＝＞″0″}； foreach$w(@{$write_port-＞{WIDTH}}){ $field＝wfield(″data$w″，$write_port，$s)； $def-＞{$field}＝{SIZE＝＞$data_size，DIR＝＞″in″，DEFAULT＝＞″x″}； } } foreach$s(1..$write_port-＞{MAX_DEF}){ if($s＜＝&amp;max(@{$write_port-＞{DEF}})){ $field＝wfield{″wen″，$write_port，$s)； $def-＞{$field}＝{SIZE＝＞1，DIR＝＞″in″，DEFAULT＝＞″x″}； } } foreach$width(@{$write_port-＞{WIDTH}}){ $field＝rfield(″width$width″，$write_port，0)； $def-＞{$field}＝{SIZE＝＞1，DIR＝＞″in″，DEFAULT＝＞″0″}； } } return$def； }； subregfile_stall_write{ my($rf，$time，$addr，$width)＝@_； my(si)；<dpn="d392"/> for($i＝0；$i＜$width/$rf-＞{MIN_WIDTH}；$i++){ $mainregfile_stall-＞{$time}-＞{$addr+$i}＝1； } } subregfile_stall_read{ my($rf，$time，$addr，$width)＝@_； my($i，$stall)； $stall＝0； for($i＝0；$i＜$width/$rf-＞{MIN_WIDTH}；$i++){ $stall|＝defined$mainregfile_stall-＞{$time}-＞{$addr+$i}； } return$stall； } subregfile_write{ my($rf，$time，$addr，$data，$width)＝@_； my($i)； for($i＝0；$i＜$width/$rf-＞{MIN_WIDTH}；$i++){ $mainregfile-＞{$time}-＞{$addr+$i}＝ ($data＞＞($i*$rf-＞{MIN_WIDTH}))&amp;((1＜＜$rf-＞{MIN_WIDTH})-1)； } } subregfile_read{ my($rf，$time，$addr，$width)＝@_； my($t，$out_value，$i)； $out_value＝0； for($i＝0；$i＜$width/$rf-＞{MIN_WIDTH}；$i++){ my($value)； for($t＝$time；$t＞＝0；$t--){ $value＝$mainregfile-＞{$t}-＞{$addr+$i}； if(defined$value){ last； } } if(！defined$value){ die″regfile_readtime＝$timeaddr＝$addrvalueundefined″； } $out_value|＝$value＜＜($i*$rf-＞{MIN_WIDTH})； } return$out_value； } subinit_field{ my($rf，$time)＝@_； my($field，$default，$size，$dir，$value)； foreach$field(keys(％{$rf-＞{SIGNALS}})){ my($info)＝$rf-＞{SIGNALS}-＞{$field}； $default＝$info-＞{DEFAULT}； $size＝$info-＞{SIZE}； $dir＝$info-＞{DIR}； if($direq″in″&amp;&amp;$size＞0){ if($defaulteq″0″){ $value＝0； }elsif($defaulteq″x″){ $value＝$size.″′b″.(′x′x$size)；<dpn="d393"/> }else{ die″Badinit.fieldin$field\n″； } add_field($rf，$time，$field，$value)； }elsif($fieldeq″Stall_R″){ add_field($rf，$time，$field，″10″)； } }}subadd_field{ my($rf，$time，$field，$value)＝@_； my($info)＝$rf-＞{SIGNALS}-＞{$field}； die″add_fieldfield\″$field\″notfound″if！defined$info； returnif$info-＞{SIZE}＝＝0； if(！defined$mainvector-＞{$time}){ $mainvector-＞{$time}＝{}； init_field($rf，$time)； } $mainvector-＞{$time}-＞{$field}＝$value；}submake_view_pipeline_register_cell{ my($rf)＝@_； my(@iolist，$read_port，$s，$w，$s，$write_port，$module)； foreach$read_port(@{$rf-＞{READ_PORT}}){ foreach$s(@{$read_port-＞{USE}}){ my($data)＝rfield(″data″，$read_port，$s)； my($decl)＝″[″.($read_port-＞{MAX_WIDTH}-1).″0]″； push(@iolist，″$data，″)； printTEST″wire$decl$data；\n″； } #don′tneedanaddressforasinglewordregisterfile if($rf-＞{HI_ADDR_SIZE}＞0){ my($addr)＝rfield(″addr″，$read_port，0)； my($decl)＝″[″.($rf-＞{HI_ADDR_SIZE}-1).″0]″； push(@iolist，″$addr，″)； printTEST″reg$decl$addr；\n″； } foreach$w(@{$read_port-＞{WIDTH}}){ my($width)＝rfield(′width$w″，$read_port，0)； push(@iolist，″$width，″)； printTEST″reg$width；\n″； } foreach$s(@{$read_port-＞{USE}}){ my($use)＝rfield(″use$s″，$read_port，0)； push(@iolist，″$use，″)； printTEST″reg$use；\n″； } } foreach$write_port(@{$rf-＞{WRITE_PORT}}){ #don′tneedanaddressforasinglewordregisterfile if($rf-＞{HI_ADDR_SIZE}＞0){ my($addr)＝wfield(″addr″，$write_port，0)； my($decl)＝″[″.($rf-＞{HI_ADDR_SIZE}-1).″0]″；<dpn="d394"/> push(@iolist，″$addr，″)； printTEST″reg$decl$addr；\n″； } foreach$w(@{$write_port-＞{WIDTH}}){ my($width)＝rfield(″width$w″，$write_port，0)； push(@iolist，″$width，″)； printTEST″reg$width；\n″； } foreach$s(@{$write_port-＞{DEF}}){ my($def)＝wfield(″def$s″，$writeport，0)； push(@iolist，″$def，″)； printTEST″reg$def；\n″； } foreach$w(@{$write_port-＞{WIDTH}}){ foreach$s(@{$write_port-＞{DEF}}){ my($data)＝wfield(″data$w″，$write_port，$s)； my($decl)＝″[″.($w-1).″0]″； push(@iolist，″$data，″)； printTEST″reg$decl$data；\n″； } } foreach$s(1..$write_port-＞{MAX_DEF}){ if($s＜＝&amp;max(@{$write_port-＞{DEF}})){ my($wen)＝wfield(″wen″，$write_port，$s)； push(@iolist，″$wen，″)； printTEST″reg$wen；\n″； } } } push(@iolist，″Kill_E，″)； printTEST″//regKill_E；\n″； push(@iolist，″KillPipe_W，″)； printTEST″regKillPipe_W；\n″； push(@iolist，″Stall_R，″)； printTEST″wireStall_R；\n″； push(@iolist，″clk)；\n″)； printTEST″regclk；\n″； printTEST″$rf-＞{NAME}io(″； printTESTjoin(″，@iolist)； printTEST″\n″； } subprint_vector{ my($rf)＝@_； my($time，$size，$value，$width，$last_value，$mask，$addr，$dir，$field)； my($max_time)＝max(keys(％$mainvector))； printTEST″moduledriver；\n″； make_view_pipeline_register_cell($rf)； printTEST″initialbegin\n″；<dpn="d395"/> printTEST″#2；\n″； for($time＝0；$time＜＝$max_time；$time++){ printTEST″\n″； printTEST″\n″； printTEST″//time$time\n″； foreach$field(sort(keys(％{$mainvector-＞{$time}}))){ $dir＝$rf-＞{SIGNALS}-＞{$field}-＞{DIR}； nextif$dirne″in″； $value＝$mainvector-＞{$time}-＞{$field}； $last_value＝$mainvector-＞{$time-1}-＞{$field}； if($time＝＝0||！defined$last_value||$valuene$last_value){ printTEST″$field＝$value；\n″； } } printTEST″#5；\n″； if(defined$mainprint_vector{$time}){ printTEST″\$display(\″$mainprint_vector{$time}\″)；\n″； } foreach$field(sort(keys(％{$mainvector-＞{$time}}))){ $dir＝$rf-＞{SIGNALS}-＞{$field}-＞{DIR}； nextif$dirne″out″； ($width，$value)＝split(′，$mainvector-＞{$time}-＞{$field})； if($fieldne″Stall_R″){ $field＝$field.″[″.($width-1).″0]″； } printTEST″if($field！＝$value)begin\n″； printTEST″\$display(\″FAIL！％d$field％d$value\″，\$time，$field)；\n″； printTEST″end\n″； } printTEST″#5；\n″； } printTEST″end\n″； printTEST′xtflop#(1)dummy(Kill_E，Stall_R，clk)；\n\n″； printTEST″initialbeginclk＝1；end\n″； printTEST″alwaysbegin#5clk＝～clk；end\n\n′； printTEST″alwaysbegin#(″.($max_time+10).″*10)\$finish；end\n″； printTEST″endmodule\n″； }<dpn="d396"/> $maintry_kill＝0； $maintime＝0； $mainnop_count＝0； subinst{ my($rf，$arg，$kill)＝@_； my($write_port，$read_port，$write_port_num，$read_port_num)； my($i，$arg_print，$op，$field，@operand，$stall，$port，$addr，$width，$data，$def，$use，$time)； $time＝$maintime++； @operand＝split(′′，$arg)； $arg_print＝″″； #checkforstallonanyreadport $stall＝0； foreach$op(@operand){ nextifsubstr($op，0，1)eq″＞″； ($port，$addr，$use，$width)＝split(′-′，$op)； $stall|＝regfile_stall_read($rf，$time+$use，$addr，$width)； } if($stall){ add_field($rf，$time，″Stall_R″，″11″)； } #ifthereisnostall，tryarandomkillpipewhenthis #instructionreachesW if($maintry_ki1l&amp;&amp;$kill&amp;&amp;$stall＝＝0&amp;&amp;int(rand(20))＝＝0){ $mainnop_count＝4； add_field($rf，$time+3，″KillPipe_W″，1)； $arg_print.＝sprintf(″％-10s″，″Kill！″)； } #processtheread(s) foreach$op(@operand){ nextifsubstr($op，0，1)eq″＞″； ($port，$addr，$use，$width)＝split(′-′，$op)； $read_port＝$rf-＞{READ_PORT}-＞[$port]； $field＝rfield(″addr″，$read_port，0)； add_field($rf，$time，$field，$addr)； $field=rfield(″use$use″，$read_port，0)； add_field($rf，$time，$field，1)； $field＝rfield(″width$width″，$read_port，0)； add_field($rf，$time，$field，1)； $data＝regfile_read($rf，$time，$addr，$width)； if(！$stall){ $field＝rfield(″data″，$read_port，$use)； add_field($rf，$time+$use，$field，″$width$data″)； } $arg_print.＝sprintf(″％-20s″，″$op＝$data″)； } #processthewrite(s)<dpn="d397"/> foreach$op(@operand){ nextifsubstr($op，0，1)ne″＞″； ($port，$addr，$def，$width)＝split(′-′，substr($op，1))； $write_port＝$rf-＞{WRITE_PORT}-＞[$port]； $field＝wfield(″addr″，$write_port，0)； add_field($rf，$time，$field，$addr)； $field＝wfield(″def$def″，$write_port，0)； add_field($rf，$time，$field，1)； $field＝wfield(″width$width″，$write_port，0)； add_field($rf，$time，$field，1)； $field＝wfield(″data$width″，$write_port，$def)； $data＝int(rand(pow2($width)))； add_field($rf，$time+$def，$field，$data)； if(！$stall){ for($i＝1；$i＜＝$def；$i++){ $field＝wfield(″wen″，$write_port，$i)； add_field($rf，$time+$i，$field，1)； regfile_stall_write($rf，$time+$i，$addr，$width)； } if($mainnop_count＝＝0){ regfile_write($rf，$time，$addr，$data，$width)； } } $arg_print.＝sprintf(″％-20s″，″$op＝$data″)； } if($mainnop_count＞0){ $mainnop_count--； } $mainprint_vector{$time}＝sprintf(″％4d％d％s″，$time，$stall，$arg_print)； #replaytheinstructiononastall if($stall){ inst($rf，$arg，$kill)； } }<dpn="d398"/> subtest_view_pipeline_regfile{ my($rf)＝@_； my($i，$num，$port，$addr，$use，$def，$width，$op，$read_port，$write_port)； #writeeachaddressusingmaxwrite-width，mindef，minport# $write_port＝$rf-＞{WRITE_PORT}-＞； $width＝$write_port-＞{WIDTH}-＞[$#{@{$write_port-＞{WIDTH}}}]； for($addr＝0；$addr＜$rf-＞{SIZE}/$width；$addr++){ $a＝$addr*$width/$rf-＞{MIN_WIDTH}； $def＝@{$write_port-＞{DEF}}； $op＝″＞0-$a-$def-$width″； inst($rf，$op，0)； } #flushthepipeline for($i＝0；$i＜10；$i++){ inst($rf，″″，0)； } #readeachaddressusingeachread-width，eachuse，eachport $port＝0； foreach$read_port(@{$rf-＞{READ_PORT}}){ foreach$use(@{$read_port-＞{USE}}){ foreach$width(@{$read_port-＞{WIDTH}}){ for($addr＝0；$addr＜$rf-＞{SIZE}/$width；$addr++){ $a＝$addr*$width/$rf-＞{MIN_WIDTH}； $op＝″$port-$a-$use-$width″； inst($rf，$op，0)； } } } $port++； } while($maintime＜$rf-＞{AUM_TEST_VECTOR}-10){ $op＝″″； for($port＝0；$port＜@{$rf-＞{READ_PORT}}；$port++){ if(int(rand(8))！＝0){ $read_port＝@{$rf-＞{READ_PORT}}[$port]； $num＝@{$read_port-＞{WIDTH}}； $width＝$read_port-＞{WIDTH}-＞[int(rand($num))]； $addr＝int(rand($rf-＞{SIZE}/$width))*$width/$rf-＞{MIN_WIDTH}； $num＝@{$read_port-＞{USE}}； $use＝$read_port-＞{USE}-＞[int(rand($num))]； $op.＝″$port-$addr-$use-$width″； } } for($port＝0；$port＜@{$rf-＞{WRITE_PORT}}；$port++){ if(int(rand(8))！＝0){ $write_port＝@{$rf-＞{WRITE_PORT}}[$port]； $num＝@{$write_port-＞{WIDTH}}； $width＝$write_port-＞{WIDTH}-＞[int(rand($num))]； $addr＝int(rand($rf-＞{SIZE}/$width))*$width/$rf-＞{MIN_WIDTH}； $num＝@{$write_port-＞{DEF}}； $def＝$write_port-＞{DEF}-＞[int(rand($num))]；<dpn="d399"/> $op.＝″＞$port-$addr-$def-$width″； } } inst($rf，$op，1)； } #flushthepipeline for($i＝0；$i＜10；$i++){ inst($rf，″″，0)； } print_yector($rf)； } my($rf，$rf_all，$i，$TEST，$usage，$ret}； srand1； #defaultvalues $mainverify＝0； $usage＝＜＜EOF； usage$0[options] EOF #parsethecommandline $ret＝GetOptions( ″verify″＝＞\$mainverify， )； if(！$ret){ print″$usage″； exit1 } $rf_all＝′$rf_all＝[′.join(′′，＜＞).，]；′； eval($rf_all)||die″Syntaxerrorininputdescription″； for($i＝o；$i＜@$rf_all；$i++){ $rf＝$rf_all-＞[$i]； derive_constants($rf)； $rf-＞{SIGNALS}＝set_def($rf)； write_regfile($rf)； print″\n\n″； write_regfile_bank($rf)； print″\n\n″； if(defined$rf-＞{TEST_FILENAME}){ $TEST＝$rf-＞{TEST_FILENAME}； open(TEST，″＞$TEST″)||die″Can′topen$TEST$！″； test_view_pipeline_regfile($rf)； closeTEST； }}附录C #！/usr/xtensa/tools/bin/perl-w #GenerateISAdocumentationfromTIEfiles. #$IdGenISAHTML，v1.62000/01/06005316earlExp$ #Copyright1999-2000TensilicaInc. #Thesecodedinstructions，statements，andcomputerprogramsare #ConfidentialProprietaryInformationofTensilicaInc.andmaynotbe #disclosedtothirdpartiesorcopiedinanyform，inwholeorinpart， #withoutthepriorwrittenconsentofTensilicaInc. packageXtensaGetISAHTML； #Imports #Usethistofindlibraryfiles uselib$ENV{′TENSILICA_TOOLS′}.′/lib′； #uselib′@xtools@/lib′； #perllibrarymodules usestrict； useGetoptLong； #Othermodules useHTML； useXtensaTargetISA； useXtensaGenISA； #program #preventusestricterrorsforourglobalvariables usevarsqw(％idiom)； { $myname＝′GetISAHTML′； #commandline my$htmldir＝undef； my$tpp＝undef； die(″Usageis$myname-htmldirdir[options...]file\n″) unless&amp;GetOptions(″htmldir＝s″＝＞\$htmldir， ″tpp＝s″＝＞\$tpp) &amp;&amp;defined($htmldir) &amp;&amp;@ARGV＝＝1；<dpn="d402"/> if(！-d$htmldir){ mkdir($htmldir，0777) ||die(″$myname$！，creating$htmldir.\n″)； } $htmldir.＝′/′unless$htmldir＝-m|/$|；#readyforcatenatingfilenames my($isafile)＝@ARGV； my$isa＝newXtensaTargetISA($tpp，$isafile)； GenISAHTML($htmldir，$isa)； } subGenISAHTML{ my($htmldir，$isa)＝@_； my$indexfh＝newFileHandle($htmldir.′index.html′，′＞′)； die(″$my-name$！，opening${htmldir}index.htmlforoutput.\n″) unless$indexfh； my$index＝newHTML($indexfh，2)； $index-＞hbegin(′Instructions′)； $index-＞block(′h1′，′Instructions′)； $index-＞block(′h2′，′Alphabeticbymnemonic′)； $index-＞bblock(′table′)； $index-＞bblock(′thead′)； $index-＞bblock(′tr′)； $index-＞block(′th′，′Mnemonic′，attribute(′align′，′left′))； $index-＞block(′th′，′Synopsis′，attribute(′align′，′left′))； $index-＞eblock(′tr′)； $index-＞eblock(′thead′)； $index-＞bblock(′tbody′)； my$inst； foreach$inst(sort{isort($a-＞mnemonic()，$b-＞mnemonic())} $isa-＞instruction()){ my$instname＝uc($inst-＞mnemonic())； my$synopsis＝$inst-＞synopsis()； if(！defined($synopsis)){ printSTDERR(″$mynameNosynopsisfor$instname\n″)； $synopsis＝″； } $＝$instname； s/\.//g； my$instfile＝$-.′.html′； $index-＞bblock(′tr′)；<dpn="d403"/> $index-＞bblock(′th′，attribute(′align′，′left′))； $index-＞link($instfile，$instname)； $index-＞eblock(′th′)； $index-＞block(′td′，$synopsis，attribute(′align′，′left′))； $index-＞eblock(′tr′)； my$instfh＝newFileHandle($htmldir.$instfile，′＞′)； die(″$myname$！，opening$htmldir$instfileforoutput.\n″) unless$instfh； my$html＝newHTML($instfh，2)； $html-＞hbegin(″$instname-$synopsis″)； instdoc($html，$isa，$inst)； $html-＞hend()； $html-＞close()； $instfh-＞close()； }#foreachinst $index-＞eblock(′tbody′)； $index-＞eblock(′table′)； $index-＞hend()； $index-＞close()； $indexfh-＞close()； } #Generatetheinstructionwordbox subinstbox{ my($html，$isa，$inst，$caption)＝@_； my$instname＝uc($inst-＞mnemonic())； my$maxinstlen＝$isa-＞maxsize()； my$cellwidth＝sprintf(″％.of″，720/$maxinstlen)-2； my$iv＝$inst-＞value()； my$im＝$inst-＞mask()； my$il＝$inst-＞size()； my$pad＝$maxinstlen-$il； my@fields＝(′′)x$il； push(@fields，″\n″)；#somethingtoforceamismatch my$oper； foreach$oper($inst-＞operands()){ my$field＝$oper-＞field()； my$fieldname＝$field-＞name()； my$b； foreach$b($field-＞bitlist()){ $fields[$b]＝$fieldname； } } $html-＞bblock(′table′，attribute(′frame′，′void′)， attribute(′rules′，′groups′)， attribute(′cellspacing′，0)， attribute(′cellpadding′，0))；<dpn="d404"/> if(defined($caption)&amp;&amp;$captionne′′){ $html-＞inline(′caption′，$caption) } #columngroups my$repeat； foreach$repeat(1..$pad){ $html-＞empty(′col′，attribute(′width′，$cellwidth))； } my$j＝$il-1； my$i； for($i＝$il-2；$i＞＝0；$i-＝1){ if($fields[$i]ne$fields[$i+1]){ $html-＞empty(′colgroup′，attribute(′colspan′，$j-$i))； foreach$repeat(1..($j-$i)){ $html-＞empty(′col′，attribute(′width′，$cellwidth))； } $j＝$i； } } $html-＞empty(′colgroup′，attribute(′colspan′，$j+1))； foreach$repeat(1..($j+1)){ $html-＞empty(′col′，attribute(′width′，$cellwidth))； } #bitnumbers $html-＞bblock(′thead′)； $html-＞bblock(′tr′)； foreach$repeat(1..$pad){. $html-＞block(′td′，′′，attribute(′width′，$cellwidth))； } for($i＝$il-1；$i＞＝0；$i-＝1){ if($fields[$i]ne$fields[$i+1] ||$i＝＝0 ||$fields[$i]ne$fields[$i-1]){ $html-＞bblock(′td′，′′，attribute(′width′，$cellwidth) attribute(′align′，′center′))； $html-＞inline(′small′，$i)； $html-＞eblock(′td′)； }else{ $html-＞block(′td′，′′，attribute(′width′，$cellwidth)， attribute(′align′，′center′))； } } $html-＞eblock(′tr′)； $html-＞eblock(′thead′)；<dpn="d405"/> #fields $html-＞bblock(′tbody′)； $html-＞bblock(′tr′)； if($pad！＝0){ $html-＞block(′td′，′′，attribute(′colspan′，$pad)， attribute(′width′，$pad*$cellwidth)}； } $j＝$il-1； for($i＝$il-1；$i＞＝0；$i-＝1){ if($i！＝$j&amp;&amp;$fields[$i]ne$fields[$i+1]){ $html-＞block(′td′，$fields[$i+1]，attribute(′colspan′，$j-$i)， attribute(′width′，($j-$i)*$cellwidth)， attribute(′align′，′center′)， attribute(′bgcolor′，′#FFE4E1′))； $j＝$i； } if($fields[$i]eq′′){ $b＝($iv＞＞$i)&amp;1； $html-＞block(′td′，$b，attribute(′width′，$cellwidth)， attribute(′align′，′center′)， attribute(′bgcolor′，′#FFF0F5′))； $j＝$i-1； } } if($j！＝-1){ $html-＞block(′td′，$fields，attribute(′colspan′，$j+1)， attribute(′width′，($j+1)*$cellwidth)， attribute(′align′，′center′))； } $html-＞eblock(′tr′)； $html-＞eblock(′tbody′)； #fieldwidths $html-＞bblock(′tfoot′)； $html-＞bblock(′tr′)； if($pad！＝0){ $html-＞block(′td′，′′，attribute(′colspan′，$pad)， attribute(′width′，$pad*$cellwidth))； } $j＝$il-1； for($i＝$il-2；$i＞＝0；$i-＝1){ if($fields[$i]ne$fields[$i+l]){ $html-＞bblock(′td′，attribute(′colspan′，$j-$i)，<dpn="d406"/> attribute(′width′，($j-$i)*$cellwidth)， attribute(′align′，′center′))； $html-＞inline(′small′，$j-$i)； $html-＞eblock(′td′)； $j＝$i； } } $html-＞bblock(′td′，attribute(′colspan′，$j+1)， attribute(′width′，($j+1)*$cellwidth)， attribute(′align′，′center′))； $html-＞inline(′small′，$j+1)； $html-＞eblock(′td′)； $html-＞eblock(′tr′)； $html-＞eblock(′tfoot′)； $html-＞eblock(′table′)； }#instbox #Generatedocumentationforinstrution$insttoHTMLobject$hmtl. subinstdoc{ my($html，$isa，$inst)＝@_； my$instname＝uc($inst-＞mnemonic())； my$synopsis＝$inst-＞synopsis()； if(！defined($synopsis)){ printSTDERR(″$mynameNosynopsisfor$instname\n″)； $synopsis＝″； } $html-＞block(′h1′，″$instname&amp;#8212；$synopsis″)； $html-＞block(′h2′，′InstructionWord′)； instbox($html，$isa，$inst)； $html-＞block(′h2′，′Package′)； if($idiom{$instname}){ $_＝′AssemblerMacro′； }else{ $_＝$inst-＞package()； s/.$//； my$pkglong＝$pkglong{$_}； if(defined($pkglong)){ $_＝$pkglong； }else{ tr/a-z/A-Z/； } } $html-＞block(′p′，$)； $html-＞block(′h2′，′AssemblerSyntax′)； $html-＞bblock(′p′)； my@iasm＝map($_-＞name，$inst-＞operands)；<dpn="d407"/> $html-＞inline(′code′，@iasm＝＝0？$instname ($instname.′′.join(′，′，@iasm)))； $html-＞eblock(′p′)； $html-＞block(′h2′，′Description′)； my$idesc＝$inst-＞description()； if(！defined($idesc)){ printSTDERR″$mynameNodescriptionfor$instname.\n″； }else{ $idesc＝～s|＜INSTREF＞([A-Z.]+？)＜/INSTREF＞|insthref($1)|gei； $html-＞iprint($idesc)； } my$iasmnote＝$inst-＞asmnote()； if(defined($iasmnote)){ $iasmnote＝～s|＜INSTREF＞([A-Z.]+？)＜/INSTREF＞|insthref($1)|gei； $html-＞block(，h2′，′AssemblerNote′)； $html-＞iprint($iasmnote)； } $html-＞block(′h2′，′Operation′)； my$tiesem＝$inst-＞tiesemantics()； if(defined($tiesem)){ $html-＞pre($tiesem)； }else{ $html-＞bblock(′p′)； $html-＞binline(′code′)； $html-＞iprint(′x&amp;#8592；y′)； $html-＞inline(′sub′，′7′)； $html-＞inline(′sup′，′8′)； $html-＞iprint(′||y′)； $html-＞einline(′code′)； $html-＞eblock(′p′)； } $html-＞block(′h2′，′Exceptions′)； { my@exceptions＝$inst-＞exceptions()； if(@exceptions！＝0){ $html-＞bblock(′ul′)； my$e； foreach$e(@exceptions){ my$ename＝$e-＞name()； my$elong＝$exclong{$ename}； $elong＝$enameunlessdefined($elong)； $html-＞block(′li′，$elong)； } $html-＞eblock(′ul′)； }else{ $html-＞block(′p′，′None′)；<dpn="d408"/> } } my$iimpnote＝$inst-＞impnote()； if(defined($iimpnote)){ $iimpnote＝～s|＜INSTREF＞([A-Z.]+？)＜/INSTREF＞|insthref($1)|gei； $html-＞block(′h2′，′ImplementationNote′)； $html-＞iprint($iimpnote)； } }#instdoc #ReturnHTMLfragmentforreferencinganotherinstruction subinsthref{ my($inst)＝@_； $＝$inst； s/\.//g； ′＜CODE＞＜AHREF＝″′.$_.′.html″＞′.$inst.′＜/A＞＜/CODE＞′； } #LocalVariables #modeperl #perl-indent-level2 #cperl-indent-level2 #End #StuffcommontoGenISAHTMLandGenISAMIF #$IdGenISA.pm，v1.71999/12/19081038earlExp$ #Copyright1999-2000TensilicaInc. #Thesecodedinstructions，statements，andcomputerprogramsare #ConfidentialProprietaryInformationofTensilicaInc.andmaynotbe #disclosedtothirdpartiesorcopiedinanyform，inwholeorinpart， #withoutthepriorwrittenconsentofTensilicaInc. packageXtensaGenISA； #Exports useExporter()； @XtensaGenISAISA＝qw(Exporter)； @XtensaGenISAEXPORT＝qw(％pkglong％pkgchapter％exclong&amp;isort&amp;generated)； @XtensaGenISAEXpORT_OK＝@XtensaGenISAEXPORT； ％XtensaGenISAEXPORT_TAGS＝()；<dpn="d409"/>#Imports#perllibrarymodulesusestrict；#Modulebodybeginshere#preventusestricterrorsforourglobalvariablesusevarsqw(％pkglong％pkgchapter％exclong)；％pkglong＝( ′32bitdiv′＝＞′32-bitIntegerDivide′， ′32bitmul′＝＞′32-bitIntegerMultiply′， ′athens′＝＞′XtensaV1′， ′booleans′＝＞′CoprocessorOption′， ′coprocessor′＝＞′CoprocessorOption′， ′core′＝＞′CoreArchitecture′， ′datacache′＝＞′DataCache′， ′debug′＝＞′DebugOption′， ′density′＝＞′CodeDensityOption′， ′exception′＝＞′ExceptionOption′， ′fp′＝＞′FloatinqPoint′， ′instcache′＝＞′InstructionCache′， ′interrupt′＝＞′InterruptOption′， ′mac16′＝＞′MAC16Option′， ′misc′＝＞′Miscellaneous′， ′mul16′＝＞′Mul16Option′， ′regwin′＝＞′WindowedRegistersOption′， ′spec′＝＞′SpeculationOption′， ′sync′＝＞′MultiprocessorSynchronizationOption′， ′timer′＝＞′TimerOption′， ′vectorinteger′＝＞′VectorIntegerCoprocessor′)；％pkgchapter＝( ′32bitdiv′＝＞′ch5′， ′32bitmul′＝＞′ch5′， ′athens′＝＞′ch5′， ′booleans′＝＞′ch7′， ′coprocessor′＝＞′ch7′， ′core′＝＞′ch5′， ′datacache′＝＞′ch5′， ′debug′＝＞′ch5′， ′density′＝＞′ch5′， ′exception′＝＞′ch5′， ′fp′＝＞′ch8′， ′instcache′＝＞′ch5′， ′interrupt′＝＞′ch5′， ′macl6′＝＞′ch6′， ′misc′＝＞′ch5′， ′mul16′＝＞′ch5′，<dpn="d410"/> ′regwin′＝＞′ch5′， ′spec′＝＞′ch5′， ′sync′＝＞′ch5′， ′timer′＝＞′ch5′， ′Vectorinteger′＝＞′vec′)； ％exclong＝( ′SystemCall′＝＞′SystemCall′， ′LoadStoreError′＝＞′LoadStoreError′， ′FloatingPoint′＝＞′FloatingPointException′， ′InstructionFetchError′＝＞′InstructionFetchError′， ′IntegerDivideByZero′＝＞′IntegerDividebyZero′)； #Instructionnamesort subisort{ my($am，$bm)＝@_； if($am＝～/＾([A-Za-z]+)(\d+)(.*)$/){ my($a1，$a2，$a3)＝($1，$2，$3)； if($bm＝～/＾([A-Za-z]+)(\d+)(.*)$/){ my($b1，$b2，$b3)＝($1，$2，$3)； return($a1cmp$b1)||($a2＜＝＞$b2)||($a3cmp$b3)； } } $amcmp$bm； } #Generatedoutputfilecomment subgenerated{ my($handle，$cstart，$cend，@files)＝@_； my$date； chomp($date＝`date`)； $handle-＞print($cstart，′Thisfileisautomaticallygenerated--DONOTEDIT′，$cend，″\n″)； $handle-＞print($cstart，′Generatedfrom′，join(′′，@files)，$cend，″\n″)； $handle-＞print($cstart，′by′，$myname，′on′，$date，$cend，″\n″)； } 1； #LocalVariables #modeperl #cperl-indent-level2 #perl-indent-level2 #End权利要求1.用于设计可配置处理器的系统，该系统包括硬件生成装置，用于根据包括预定部分和用户定义部分的配置规范，生成处理器硬件实现的描述；以及软件生成装置，用于根据配置规范，生成专门针对该硬件实现的软件开发工具；其中，硬件生成装置用于，根据配置规范的用户定义部分，在处理器硬件实现的描述中包括一个用户定义的注册文件；以及软件生成装置用于，根据用户定义部分，在软件开发工具中包括与用户定义的处理器寄存器文件相关的软件。2.根据权利要求1的系统，其特征在于，与用户定义的处理器寄存文件相关的软件包括一个指令，用于根据该指令的一个字段存取寄存器文件中的元素。3.根据权利要求2的系统，其特征在于，硬件生成装置用于生成寄存器级硬件描述语言中的至少一部分硬件实现描述。4.根据权利要求1的系统，其特征在于，配置规范使用指定寄存器文件中元素宽度的语句来定义寄存器文件。5.根据权利要求1的系统，其特征在于，配置规范使用指定寄存器文件中元素数目的语句来定义寄存器文件。6.根据权利要求1的系统，其特征在于，硬件生成装置用于确定与配置规范无关的至少若干个读端口和写端口之一。7.根据权利要求6的系统，其特征在于，硬件生成装置用于根据配置规范中的调度信息来确定若干个读端口。8.根据权利要求1的系统，其特征在于，硬件生成装置用于，作为处理器硬件实现描述的一部分，生成逻辑描述，以将用户定义的寄存器文件的写端口指派给指令操作数，从而最小化数据登台成本。9.根据权利要求1的系统，其特征在于，硬件生成装置用于生成存取寄存器文件的流水线逻辑。10.根据权利要求9的系统，其特征在于，用户定义的寄存器文件的写端口在任何使用这些端口作为源操作数的指令的最早阶段被读取。11.根据权利要求9的系统，其特征在于，用户定义的寄存文件的写端口在任何使用这些端口作为目标操作数的指令的最后阶段被读取，或者如果比较靠后，则在指令提交阶段被读取。12.根据权利要求1的系统，其特征在于，硬件生成装置用于，作为处理器硬件实现的一部分，在存取寄存器文件的一条指令内，生成用于从寄存器文件选择源操作数的逻辑，以为每个字段提供一个寄存器文件的读端口。13.根据权利要求1的系统，其特征在于，硬件生成装置用于，作为处理器硬件实现的一部分，生成用于存取寄存器文件的旁路逻辑。14.根据权利要求13的系统，其特征在于，硬件生成装置用于为给定的处理器流水线生成互锁逻辑，该处理器流水线由配置规范根据配置规范中的指令操作数和状态使用描述进行描述。15.根据权利要求1的系统，其特征在于，硬件生成装置用于，作为处理器硬件实现的一部分。生成用于存取寄存器文件的互锁逻辑。16.根据权利要求15的系统，其特征在于，硬件生成装置用于根据配置规范中的调度信息生成互锁逻辑。17.根据权利要求15的系统，其特征在于，硬件生成装置用于对给定的处理器流水线生成互锁逻辑，该处理器流水线由配置规范根据配置规范中的指令操作数和状态使用描述进行描述。18.根据权利要求1的系统，其特征在于，硬件生成装置用于生成处理器硬件实现描述，以使用配置规范预定部分所描述的处理器逻辑的至少一部分来支持用户定义寄存器文件的存取。19.根据权利要求18的系统，其特征在于，处理器逻辑的至少一部分包括地址计算逻辑。20.根据权利要求19的系统，其特征在于，地址计算逻辑包括地址加法器逻辑。21.根据权利要求19的系统，其特征在于，处理器逻辑的至少一部分包括在预定部分和用户定义部分之间共享的数据对准逻辑。22.根据权利要求19的系统，其特征在于，处理器逻辑的至少一部分是一个数据存储器。23.根据权利要求1的系统，其特征在于，配置规范的用户定义部分包括有条件地向用户定义的寄存器文件写入的指令的描述。24.根据权利要求1的系统，其特征在于，软件生成装置用于，作为与用户定义的寄存器文件相关的软件，生成设计验证的诊断测试，并基于配置规范加工处理器。25.根据权利要求1的系统，其特征在于配置规范包括处理器指令的参考语义和实现语义；以及参考语义可以用来验证实现语义的设计正确性。26.根据权利要求1的系统，其特征在于处理器指令集描述语言包括指令集测试情况；以及软件生成装置用于生成测试情况的诊断。27.根据权利要求1的系统，其特征在于，软件生成装置用于，通过在运行应用程序时采样处理器指令集描述语言中指令的操作数，自动生成测试向量。28.根据权利要求1的系统，其特征在于，软件生成装置用于生成操作系统的至少一部分，作为与用户定义状态和寄存器文件相关的软件。29.根据权利要求28的系统，其特征在于，所生成的操作系统部分包括处理器状态的保存和恢复序列。30.根据权利要求29的系统，其特征在于，保存和恢复序列针对组件状态的相互依赖性生成，并且对那些相互依赖性有效。31.根据权利要求28的系统，其特征在于，操作系统在任务切换过程中能够节省小于一个完整的处理器状态。32.根据权利要求28的系统，其特征在于，配置规范的用户定义部分定义一个在配置规范的预定部分中所没有的软件数据类型；并且编译程序支持该软件数据类型。33.根据权利要求1的系统，其特征在于，软件生成装置用于生成编译程序、链接程序、仿真程序和调试程序中的至少一个，作为与用户定义的寄存器文件相关的软件的一部分。34.根据权利要求1的系统，其特征在于软件生成装置用于生成一个编译程序，作为与用户定义的寄存器文件相关的软件的一部分；以及编译程序能够向用户指定的寄存器文件中的寄存器指派程序变量。35.根据权利要求34的系统，其特征在于，编译程序还能够将一个值从存储器中加载到用户定义的寄存器文件中的寄存器，并且将用户定义的寄存器文件的寄存器中的值存储到存储器中。36.根据权利要求34的系统，其特征在于，编译程序还能够将一个值从用户定义的寄存器文件中的一个寄存器移动到用户定义的寄存器文件中的另一个寄存器。37.根据权利要求34的系统，其特征在于，编译程序使用配置规范中的调度信息确定由存取用户定义的寄存器文件的软件生成装置所生成的软件中的指令延迟周期。38.根据权利要求1的系统，其特征在于，软件生成装置用于自动生成一个监视程序，以检查旁路路径的覆盖范围。39.用于设计可配置处理器的系统，该系统包括硬件生成装置，用于根据包括预定部分和用户定义部分的配置规范，生成处理器硬件实现的描述；以及软件生成装置，用于根据配置规范，生成针对该硬件实现的软件开发工具；其中，配置规范包括指定软件开发工具中使用的指令的调度信息的语句；硬件生成装置，用于根据配置规范生成流水线逻辑、流水线延迟逻辑和指令重新调度逻辑中至少一个的描述。40.根据权利要求39的系统，其特征在于，调度信息包括一条语句，该语句表明指令的一个操作数在给定阶段进入处理器流水线。41.根据权利要求39的系统，其特征在于，调度信息包括一条语句，该语句表明指令的一个操作在给定阶段存在一条处理器流水线。42.根据权利要求39的系统，其特征在于软件生成装置所生成的软件包括一个编译程序，该编译程序使用配置规范的用户定义部分中所描述的指令；以及该编译程序在指令调度期间使用调度信息，以调度配置规范的用户定义部分中所描述的指令。43.根据权利要求39的系统，其特征在于，配置规范包括一种指令的描述，该指令要求处理多个处理器周期。44.根据权利要求43的系统，其特征在于配置规范包括对与处理器的目标流水线无关的指令语义的描述。硬件生成装置用于，根据与指令语义分离的流水线描述，作为处理器硬件实现的一部分，生成一条流水线。45.用于设计可配置处理器的系统，该系统包括硬件生成装置，用于根据包括预定部分和用户定义部分的配置规范，生成处理器硬件实现的描述；软件生成装置，用于根据配置规范，生成针对硬件实现的软件开发工具；以及文档生成装置，用于根据配置规范，生成配置规范所描述的处理器指令集的文档。46.根据权利要求45的系统，其特征在于，文档生成装置使用配置规范中所定义的指令的参考语义来生成处理器指令集文档。47.根据权利要求45的系统，其特征在于配置规范的用户定义部分包括其中所定义的指令的参考语义，以及用户定义指令的摘要和文本描述至少其中之一的用户定义规范；以及文档生成装置使用摘要和文本描述至少其中之一生成处理器指令集的文档。48.用于设计可配置处理器的系统，该系统包括硬件生成装置，用于根据包括预定部分和用户定义部分的配置规范，生成处理器硬件实现的描述；以及软件生成装置，用于根据配置规范，生成针对该硬件实现的软件开发工具；其中，配置规范包括有关处理器异常以及处理器指令何时引发异常的规范；以及硬件生成是生成支持该异常的硬件，作为处理器硬件实现的一部分。49.处理器仿真系统，包括硬件仿真装置，用于执行对可扩充处理器的硬件描述；软件仿真装置，用于执行可扩充处理器的软件参考模型；以及联合仿真装置，用于使用硬件仿真装置和软件仿真装置，并比较所得到的仿真结果，从而建立可扩充处理器硬件描述和可扩充处理器软件参考模型之间的对应关系。全文摘要一种生成处理器硬件的系统，支持大幅扩展处理器指令集的语言，其中，设计器只指定新指令的语义，而由系统生成其他逻辑。扩展语言提供处理器状态的增加，包括寄存器文件，以及在该状态操作的指令。该语言还提供要添加到编译程序的新的数据类型，以表示所添加的状态。它允许将参考语义的说明部分与指令实现部分分离，并用此来实现设计验证过程的自动化。此外，该系统还从语言说明部分生成格式化的指令集文档。文档编号G06F9/455GK1436335SQ01805240公开日2003年8月13日申请日期2001年2月15日优先权日2000年2月17日发明者阿尔伯特·R·王,理查德·鲁德尔,戴维·W·古德汶申请人:坦斯利卡公司