CN1436335A - 用于设计可配置处理器的自动处理器生产系统及方法 - Google Patents
用于设计可配置处理器的自动处理器生产系统及方法 Download PDFInfo
- Publication number
- CN1436335A CN1436335A CN01805240A CN01805240A CN1436335A CN 1436335 A CN1436335 A CN 1436335A CN 01805240 A CN01805240 A CN 01805240A CN 01805240 A CN01805240 A CN 01805240A CN 1436335 A CN1436335 A CN 1436335A
- Authority
- CN
- China
- Prior art keywords
- instruction
- data
- processor
- tie
- register
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
- G06F9/30145—Instruction analysis, e.g. decoding, instruction word fields
- G06F9/3016—Decoding the operand specifier, e.g. specifier format
- G06F9/30167—Decoding the operand specifier, e.g. specifier format of immediate specifier, e.g. constants
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F30/00—Computer-aided design [CAD]
- G06F30/30—Circuit design
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
- G06F9/30145—Instruction analysis, e.g. decoding, instruction word fields
Abstract
一种生成处理器硬件的系统，支持大幅扩展处理器指令集的语言，其中，设计器只指定新指令的语义，而由系统生成其他逻辑。扩展语言提供处理器状态的增加，包括寄存器文件，以及在该状态操作的指令。该语言还提供要添加到编译程序的新的数据类型，以表示所添加的状态。它允许将参考语义的说明部分与指令实现部分分离，并用此来实现设计验证过程的自动化。此外，该系统还从语言说明部分生成格式化的指令集文档。
Description
技术领域
本发明涉及计算机处理器以及开发计算机处理器的系统及技术，更具体地讲涉及其功能可按用户的选择配置的处理器，以及相关的开发系统和技术。
背景技术
现有技术的处理器通常都是相当坚硬的物体，很难被修改或扩展。在现有技术的某些系统中已经具有对处理器及其支持软件的有限的扩展能力，包括增加寄存器对寄存器的计算指令以及简单状态(但是不是寄存器文件)的能力。这种有限的扩展能力是技术的重要进步，许多使用这种改进的应用可以提高其速度及效率达四倍甚至更多。
然而，这些现有技术系统在可扩展性上的有限性，意味着其它应用不能充分利用它。具体讲，要使用已有的核心寄存器文件，由于其固定的32位宽度的寄存器，一般就阻碍了将这些改进用于需要额外的精度或复制功能单元的应用中，其中数据操作数的组合宽度超过了32位。此外，核心处理器文件经常缺少执行某个指令的充足的读或写端口。由于这些原因，在该技术中需要支持增加新的宽度及读、写端口的数量可配置的寄存器文件。
由于寄存器文件的增加，带来了在这些文件和存储器之间传送数据的需求。核心指令集包括对核心寄存器文件的装入和存储指令，但是增加的寄存器文件需要额外的装入和存储指令。这是因为可扩展寄存器文件的有理数之一将允许按需要的数据类型和带宽确定寄存器文件的大小。具体地讲，寄存器文件数据的宽度可以比指令集的其它部分支持的宽度宽。因此，通过将数据传送给核心提供的寄存器来装入和存储数据是不合理的；应该从新的寄存器文件直接装入和存储值。
此外，虽然现有技术系统支持增加处理器状态，但是状态的数量一般是较小的。因此，在现有技术中需要增大便于添加到处理器体系结构中状态位的数量。这个状态经常需要被操作系统上下文切换。一旦状态的数量增加了，就需要有最小化上下文切换时间的新方法。这些方法已经在现有技术处理器(如MIP R2000协同处理器允许位)中使用了。但是，在该技术中需要通过从输入规范自动地生成代码序列和逻辑进一步扩展该方法，以支持实时操作系统(RTOSes)和其它需要了解并以一种及时的方式使用新状态的软件。
此外，现有技术不允许在核心处理器实现和指令扩展之间的逻辑共享。对于装入和存储指令扩展，在核心和扩展之间共享数据缓存是重要的。这样新配置的指令的存储能够被核心的装入所发现，反之亦然，从而保证缓存一致——分离的缓存需要特定的结构以保持它们的一致；这是一种可能的但不理想的方案。同样，数据缓存是核心处理器中较大的电路，那么共享它就可以减少核心处理器的尺寸。
增加寄存器文件还需要实现支持将高级语言变量分配给这些寄存器。现有技术处理器使用核心寄存器文件，现有技术编译程序已经支持对它的用户变量分配。因此，希望而且应该支持对于用户定义的寄存器文件编译程序分配。为了将变量分配给寄存器，支持用户定义的寄存器文件的编译程序需要有关于如何溢出、恢复和移动这些寄存器的知识，从而可以执行传统的编译程序功能。
一个有关的但是更为常见的现有技术处理器系统的限制是编译程序支持的水平。通常，将指令添加给处理器以支持适用于新的应用(如许多DSP应用需要处理器执行饱和运算以替代更为传统的通常为处理器所支持的二进制补码运算)的数据类型。现有技术系统允许指令支持要添加的新的数据类型，但是，在写使用了这些扩展的高级语言代码时，需要将这些新的指令变换(映射)为现有语言数据类型。在某些情况下，某个适当的内部数据类型可能并不存在。
例如，考虑饱和算法的例子。如上所述，许多DSP算法利用这样的算法，即所使用的位的数量在下溢状态的最小值或在溢出状态的最大值饱和，而不换行，比如在传统的二进制补码系统中。然而，没有具备这些语义的C数据类型——C语言需要的
int a；
int b；
int c＝a+b；
具有换行语义。可以写为：
int a；
int b；
int c＝SATADD(a，b)；
这用新的内部函数代替了使用内置类型，但是这是笨拙的并且使算法难以理解(编写人简单地将STADD函数视为+)。
另一方面，增加新的数据类型使得+运算符所起的作用不同于C语言已经用于整数加法和浮点加法运算的不同运算的类型所起的作用，所以扩展是自然的。因此，使用新的数据类型的饱和加法可以编码为：
dsp16 a；
dsp16 b；
dsp16 c＝a+b；
其中dsp16定义了一个饱和数据类型。因此，最后一行表示一饱和加，因为它的两个操作数都是饱和数据类型。
大多数编译程序都要调度指令以使流水线停止最小化。然而，现有技术系统没有办法将指令规范用于扩展编译程序的数据结构调度。例如，装入指令流水线为一个两周期执行时间。因此，如果参考的装入的结果是以装入后的下一个指令为基准的，则将会有一个一周期的停止，因为装入还没有完成。因此，序列
load r1，addr1
store r1，addr2
load r2，addr3
store r2，addr4
将有两个停止周期。如果编译程序将其重新安排为
load r1，addr1
load r2，addr3
store r1，addr2
store r2，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规范：
opcode GFADD8 op2＝4′b0000 CUST0
opcode GFMULX8 op2＝4′b0001 CUST0
opcode GFRWMOD8 op2＝4′b0010 CUST0
state gfmod 8
user_register 0{gfmod}
regfile gf 8 16 g
operand gr r{gf[r]}
operand gs s{gf[s]}
operand gt t{gf[t]}
iclass gfrrr{GFADD8}{out gr，in gs，in gt}{}{}
iclass gfrr{GFMULX8}{out gr，in gs}{in gfmod}{}
iclass gfr{GFRWMOD8}{inout gt}{inout gfmod}{}
semantic gf1{GFADD8}{
assign gr＝gs^gt；}
semantic gf2{GFMULX8}{
assign gr＝gs[7]？({gs[6：0]，1′b0} ^gfmod)：
{gs[6：0]，1 ′b0}；
}
semantic gf3{GFRWMOD8}{
wire[7：0]t1＝gt；
wire[7：0]t2＝gfmod；
assign gfmod＝t1；
assign gt＝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的多路复用，提供给写端口寄存器中几个对应的输入。这些输出信号被与寄存器文件xregfle RF的输出进行多路复用，并且馈送给读端口流水线的C0阶段多路复用器。
用于读和写端口中的多路复用器的控制信号是随着可以写xregfleRF而产生，并且对于本领域的技术人员来讲，在阅读了下面有关寄存器文件的编译程序生成的讨论后，使用如图2这样的电路的一个延迟信号stall_R是显而易见的。
为了便于理解，图3给出了一个结合图1和图2的电路的两阶段方案的一个两阶段寄存器文件。
生成寄存器文件
对于每个由refile语句声明的寄存器文件，编译程序必须产生：
—寄存器文件存储单元；
—读端口；
—写端口；
—源操作数互锁逻辑；
—源操作数旁路逻辑；
—目的操作数写逻辑。
读和写端口
生成一个寄存器文件的第一步就是确定读和写端口的数量、给端口分配流水线阶以及向端口分配操作数。有许多的算法可以用来进行这些操作，每种算法会导致不同的速度和区域折衷。下面的算法用于本优选实施例中。
对于每个用于从寄存器文件中选择源操作数的字段都生成了一个读端口。在某些情况下，这将会生成比需要的多的读端口，但是由于它允许寄存器读与指令译码并行开始，所以通常会产生更快的寄存器读。考虑到前面的伽罗瓦字段算术单元的例子，其中
iclass gfr{GFRWMOD8}{inout gt}{inout gfmod}{}
已经被变为
iclass gfr{GFRWMOD8}{inout gr}{inout gfmod}{}
上面算法的将产生三个寄存器读端口(分别为了指令字的的r、s和t字段)，即使没有指令会使用两个以上的GF寄存器文件来同时读。然而，如果只产生了两个读端口，则需要在其中一个读端口前面设置一个2∶1多路复用器，用以在r和s字段或r和t字段间进行选择。这个多路复用器必须由用于区分GFRWMOD和GFADD指令的的解码逻辑来控制。在一个复杂的例子中，该逻辑可能也比较复杂，从而使得寄存器文件读时间增加较多。在优选实施例中算法所需要的额外区域可以通过指令集设计者设置指令的寄存器文件访问区域而得以避免，这样用于读每个寄存器文件的，不同区域的数量就与任何指令使用的读的最大数量相等。这就是为什么在上述例子中使用操作数gt代替iclass gfr中的gr的原因。
对于上述算法的可能的改进是跟踪schedule语句(在下面的“TIE中的多周期指令”中进行详细解释)中规定的对于每个字段的最小的阶段数。如果最小阶段数比指令解码执行中的阶段数大，则可以使用字段多路复用以降低读端口的数量。对于所有最小阶段数出现在指令解码阶段的字段，则对每个用于读寄存器文件的字段使用分离端口。
考虑下面的例子：
regfile SR 32 4 r
operand sx x{SR[x]}
operand sy y{SR[y]}
operand sz z{SR[z]}
operand su u{SR[u]}
operand sv v{SR[v]}
iclass stu{inst1}{out sz，in sx，in sy，in su}
iclass stv{inst2}{out sz，in sx，in sy，in sv}
schedule stu{inst1}{
in sx 1；
in sy 1；
in su 2；
out sz 2；
}
schedule stv{inst2}{
in sx 1；
in sy 1；
in sv 2；
out sz 2；
}
其中有四个寄存器文件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？u：v；
写端口对时间要求的苛刻性要低些。即使非常短的流水线也要在周期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阶段。
所以
assign Stall_R＝ ((wr0_addr_C1＝＝rd0_addr_C0)&( (rd0_use1_C0&(wr0_def2_C1|wr0_ns_def3_C1|wr0_ns_def4_C1)) | (rd0_use2_C0&(wr0_def3_C1|wr0_ns_def4_C1))| (rd0_use3_C0&(wr0_def4_C1))))| ((wr0_addr_C2＝＝rd0_addr_C0)&( (rd0_use1_C0&(wr0_def3_C2|wr0_ns_def4_C2))| (rd0_use2_C0&(wr0_def4_C2))))| ((wr0_addr_C3＝＝rd0_addr_C0)&( (rd0_use1_C0&(wr0_def4_C3))))| ((wr0_addr_C1＝＝rd1_addr_C0)&( (rd1_use1_C0&(wr0_def2_C1|wr0_ns_def3_C1|wr0_ns_def4_C1)) | (rd1_use2_C0&(wr0_def3_C1|wr0_ns_def4_C1))| (rd1_use3_C0&(wr0_def4_C1))))| ((wr0_addr_C2＝＝rd1_addr_C0)&( (rd1_use1_C0&(wr0_def3_C2|wr0_ns_def4_C2))| (rd1_use2_C0&(wr0_def4_C2))))| ((wr0_addr_C3＝＝rd1_addr_C0)&( (rd1_use1_C0&(wr0_def4_C3))))；
下面的perl代码在本优选实施例中用于开发停止代码。Wfield()和rfield()是用于将简单信号名、端口名和阶段号构造为信号名的函数。表达式写为有效带因数的形式。
print＂ assign Stall_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)&(\n＂；
for($i＝1；$i＜＝$write_port-＞{MAX_DEF}-$s；$i++){
my($use)＝rfield(＂use$i＂，$read_port，0)；
print＂ ($use&(＂；
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＂；
写逻辑
因为在本优选实施例中写端口地址被多路复，用以降低与每个写端口有关的硬件成本，所以需要有一种算法来决定哪个操作数使用哪个端口。对于这种多路复用的一个标准就是，将所需的逻辑最少化。在目标流水线中主逻辑的消耗是将数据登台到写端口的消耗。如果所有的写都发生在同一流水线阶段，则在这一逻辑的消耗上就没有差别，但是，如果写发生在多个阶段，则可以通过将目的操作数与相似的写阶段进行组合而节省逻辑。
考虑下面的例子：
regfile SR 32 8 s
operand sx x{SR[x]}
operand sy y{SR[y]}
operand sz z{SR[z]}
<dp n="d15"/>
operand su u{SR[u]}
operand sv v{SR[v]}
iclass i1{inst1}{out sx，out sy，in su，in sv}
iclass i2{inst2}{out sz，in su，in sv}
schedule s1{inst1}{
out sx 8；
out sy 3；
}
schedule s2{inst2}{
out sz 9；
}
这里，inst1为SR产生两个结果，一个为3周期的，另一个为8周期的。Inst2为SR产生一个9周期的结果。因为inst1需要两个写端口，inst2需要一个写端口，所以寄存器文件SR只需要有两个写端口。设端口为wr0和wr1。对于inst1，操作数向写端口转换(映射)就是：
sx->wr0
sy->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个端口的第一个。
下面的例子用于说明写端口分配的过程。
regfile SR 32 8 s
operand sx x{SR[x]}
operand sy y{SR[y]}
operand sz z{SR[z]}
operand su u{SR[u]}
operand sv v{SR[v]}
operand sw w{SR[w]}
iclass i1{inst1}{out sx，out sy，in su，in sv}
iclass i2{inst2}{out sz，in su，in sv}
iclass i3{inst3}{out sw，in su，in sv}
schedule s1{inst1}{
out sx 8；
out sy 3；
}
schedule s2{inst2}{
out sz 9；
}
schedule s3{inst3}{
out sw 2；
}
分配过程将产生如下的分配：
对于inst1：
sx->wr0
sy->wr1
对于inst2
sz->wr0
对于inst3
sw->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装入/存储。
interface VaddrOffset 32 core out interface VaddrBase 32 core out interface VaddrIndex 32 core out interface LSIndexed 1 core out interface LSSize 5 core out interface MemDataOut＜n＞＜n＞ core out interface VaddrIn 32 core in interface MemDataIn＜n＞＜n＞ core in
大多数的这些信号说明于图4；图6说明LSSize 927，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所示的核心地址加法器的输入。该地址逻辑会支持下面的地址模式
I AR[s]+immediate
X AR[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的“更新”模式执行如下：
IU vAddr<-AR[s]+offset
AR[s]<-vAddr
XU vAddr<-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；
<dp n="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.I r＝4′b0000 LSCI
opcode SGF8.I r＝4′b0001 LSCI
opcode LGF8.IU r＝4′b0010 LSCI
opcode SGF8.IU r＝4′b0011 LSCI
opcode LGF8.X op2＝4′b0000 LSCX
opcode SGF8.X op2＝4′b0001 LSCX
opcode LGF8.XU op2＝4′b0010 LSCX
opcode SGF8.XU op2＝4′b0011 LSCX
interface VaddrOffset 32 core out
interface VaddrBase 32 core out
interface VaddrIndex 32 core out
interface LSIndexed 1 core out
interface LSSize 5 core out
interface MemDataIn8 8 core in
interface VaddrIn 32 core in
interface MemDataOut8 8 core out
iclass gfloadi{LGF8.I}{out gt，in ars，in imm8}{}{
out LSSize，out LSIndexed，out VAddrOffset，out VAddrBase，in
MemDataIn8}
iclass gfstorei{SGF8.I}{in gt，in ars，in imm8}{}{
out LSSize，out LSIndexed，out VAddrOffset，out VAddrBase，
out MemDataOut8}
iclass gfloadiu{LGF8.IU}{out gt，inout ars，in imm8}{}{
out LSSize，out LSIndexed，out VAddrOffset，out VAddrBase，in
MemDataIn8，in VAddrIn}
iclass gfstoreiu{SGF8.IU}{in gt，inout ars，in imm8}{}{
out LSSize，out LSIndexed，out VAddrOffset，out VAddrBase，
out MemDataOut8，in VAddrIn}
iclass gfloadx{LGF8.X}{out gr，in ars，in art}{}{
out LSSize，out LSIndexed，out VAddrIndex，out VAddrBase，in
MemDataIn8}
iclass gfstorex{SGF8.X}{in gr，in ars，in art}{}{
out LSSize，out LSIndexed，out VAddrIndex，out VAddrBase，
out MemDataOut8}
iclass gfloadxu{LGF8.XU}{out gr，inout ars，in art}{}{
<dp n="d22"/>
out LSSize，out LSIndexed，out VAddrIndex，out VAddrBase，in
MemDataIn8，in VAddrIn}
iclass gfstorexu{SGF8.XU}{in gr，inout ars，in art}{}{
out LSSize，out LSIndexed，out VAddrIndex，out VAddrBase，
out MemDataOut8，in VAddrIn}
semantic lgf{LGF8.I，LGF8.IU，LGF8.X，LGF8.XU}{
assign LSIndexed＝LGF8.X|LGF8.XU；
assign LSSize＝1；
assign VAddrBase＝ars；
assign VAddrIndex＝art；
assign VAddrOffset＝imm8；
assign gt＝MemDataIn8；
assign gr＝MemDataIn8；
assign ars＝VAddrIn；
}
semantic sgf{SGF8.I，SGF8.IU，SGF8.X，SGF8.XU}{
assign LSIndexed＝SGF8.X|SGF8.XU；
assign LSSize＝1；
assign VAddrBase＝ars；
assign VAddrIndex＝art；
assign VAddrOffset＝imm8；
assign MemDataOut8＝SGF8.X|SGF8.XU？gr：gt；
assign ars＝VAddrIn；
}
schedule gfload{LGF8.I}
{
use imm8 0；
use ars 1；
def gt 2；
}
schedule gfloadu{LGF8.IU}
{
use imm8 0；
use ars 1；
def ars 1；
def gt 2；
}
schedule gfloadx{LGF8.X}
{
use ars 1；
use art 1；
def gr 2；
}
schedule gfloadxu{LGF8.XU}
{
use ars 1；
use art 1；
def art 1；
def gr 2；
}
下面是一个用于为本发明产生调整程序的tpp输入：
module loadalign(out，in，va，vamask，TIEload，L16SI，L16UI，
L8UI)；
；use Utilities；
；my $bits＝$pr-＞dcache-＞accessBits；
；my $bytes＝$bits＞＞3；
；my $mux＝log2($bytes)；
output out[`$bits-1`：0]；
input in[`$bits-1`：0]；
input va[`$mux-1`：0]；
input vamask[`$mux-1`：0]；
input TIEload；
input L16SI；
input L16UI；
input L8UI；
wire L8or16＝L8UI|L16UI|L16SI；
wire vam[`$mux-1`：0]＝TIEload
？va & vamask
：{va[`$mux-1`：2]，va[1] &L8or16，va[0] &L8UI}；
；sub rot{
；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 & 1){
； # rotate is done with 4：1 muxes and one 2：1 mux
； # combine the last 2：1 mux with the sign extend
； 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`[7：0]，`$in`[`$bits-1`：40]}，
vam[0])；
； }
xtmux4e #16(output[31：16]，
`$in`[31：16]，
； if($bits＞32){
`$in`[39：24]}，
； }else{
{`$in`[7 ：0]，`$in`[31：24]}，
； }
<dp n="d24"/>
{16{`$in`[15] & L16SI}}，
16′b0， //should never happen because vam[0]
//is forced 0 if L8orls is 3et
{L8or16，vam[0]})；
xtmux4e #8(output[15：8]，
`$in`[15：8]，
`$in`[22：16]，
8′b0，
8′b0，
{L8UI，vam[0]})；
xtmux2e #8(output[7：0]，
`$in`[7：0]，
`$in`[15：8]，
vam[0])；
；} else{
； #rotate is all done in 4：1 muxes，
； #so sign extend must be done in separate 2：1
； 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；
； }
assign out＝{
； if($bits＞32){
`$in`[`$bits-1`：32]，
； }
L8or16？{16{`$in`[15]&L16SI}}：`$in`[16：32]，
`$in`[15：8]&～{8{L8UI}}，
`$in`[7：0]}；
；}
endmodule loadalign
下面是为128宽度的输出：
module loadalign(out，in，va，vamask，TIEload，L16SI，L16UI，
L8UI)；
output out[127：0]；
input in[127：0]；
input va[3：0]；
input vamask[3：0]；
input TIEload；
input L16SI；
input L16UI；
input L8UI；
wire L8or16＝L8UI|L16UI|L16SI；
wire vam[3：0]＝TIEload
？va & vamask
：{va[3：2]，va[1]&L8or16，va[0]&L8UI}；
wire[127：0]t0；
xtmux4e #128(t0，
<dp n="d25"/>
input，
{input[31：0]，input[127：32]}，
{input[63：0]，input[127：64]}，
{input[95：0]，input[127：96]}，
vam[3：2])；
wire[127：0]t1；
xtmux4e #128(t1，
t0，
{t0[7：0]，t0[127：8]}，
{t0[15：0]，t0[127：16]}，
{t0[23：0]，t0[127：24]}，
vam[1：0])；
assign out＝{
t1[127：32]，
L8or16？{16{t1[15] & L16SI}}：t1[16：32]，
t1[15：8]&-{8{L8UI}}，
t1[7：0]}；
endmodule loadalign
下面是为64宽度的输出：
module loadalign(out，in，va，vamask，TIEload，L16SI，L16UI，
L8UI)；
output out[63：0]；
input in[63：0]；
<dp n="d26"/>
input va[2：0]；
iuput vamask[2：0] ；
input TIEload；
input L16SI；
input L16UI；
input L8UI；
wire L8or16＝L8UI|L16UI|L16SI；
wire vam[2：0]＝TIEload
？va & vamask
：{va[2：2]，va [1]&L8or16，va[0]&L8UI}；
wire[63：0]t0；
xtmux4e #64(t0，
input，
{input[15：0]，input[63：16]}，
{input[31：0]，input[63：32]}，
{input[47：0]，input[63：48]}，
vam[2：1])；
xtmux2e #32(output[63：32]，
t0[63：32]，
{t0[7：0]，t0[63：40]}，
vam[0])；
xtmux4e #16(output[31：16]，
t0[31：16]，
t0[39：24]}，
{16{t0[15] & L16SI}}，
16′b0′ //should never happen because vam[0]
//is forced 0 if L8or16 is set
{L8or16，vam[0]})；
xtmux4e #8(output[15：8]，
t0[15：8]，
t0[23：16]，
8′b0，
8′b0 ，
{L8UI，vam[0]})；
xtmux2e #8(output[7：0]，
t0[7：0]，
t0[15：8]，
vam[0])；
endmodule loadalign
下面是为32宽度的输出：
module loadalign(out，in，va，vamask，TIEload，L16SI，L16UI，
L8UI)；
output out[31：0]；
input in{31：0]；
<dp n="d27"/>
input va[1：0]；
input vamask[1：0]；
input TIEload ；
input L16SI；
input L16UI；
input L8UI；
wire L8or16＝L8UI|L16UI|L16SI；
wire vam[1：0]＝TIEload
？va & vamask
：{va[1：2]，va[1]&L8or16，va[0]&L8UI}；
wire[31：0]t0；
xtmux4e #32(t0，
input，
{input[7：0]，input[31：8]}，
{input[15：0]，input[31：16]}，
{input[23：0]，input[31：24]}，
vam[1：0])；
assign out＝{
L8or16？{16{t0[15] & L16SI}}：t0[16：32]，
t0[15：8] &-{8{L8UI}}，
t0[7：0]}；
endmodule loadalign
对核心的接口
装入和存储典型地，在处理器流水线中使用一个数据缓存或一个小数据RAM进行处理。为了开销和正确性，新的装入和存储指令也必须使用这个数据缓存/RAM以保持被TIE及核心指令所处理的缓存/RAM数据的完整。在现有技术系统中，增加到核心的指令不与核心共享逻辑。本优选实施例提供了用于进行这种共享的结构。
TIE结构
interface<sname><width><mname>[in|out]
声明了一个对模块<mname>有接口的信号<sname>TIE。该信号为<width>字节宽，并且根据最后一个参数，要么是TIE码的输出要么输入给该TIE码。对于对核心的接口，<mname>是core。
TIE iclass结构被进行了扩展以列出指令使用的接口信号。其语法是：
iclass<classname>
{<iname>，...}
{<operandspec>，...}
{<statespee>，...]
{<interfacespec>，...}
这里，<interfacespec>要么是in<sname>，要么是out<sname>，其中<sname>要么是接口信号名，要么是异常语句中声明的异常信号名。异常信号名只可以用作输出，而不能用作输入。此外，schedule结构被进行了扩展以允许通过使用“in”(对于输入)或“out”(对于输出)将流水线阶段数给予接口信号名。
每个来自语义块的输出接口信号与指令的一热指令解码信号的“或”(OR)相“与”(AND)，这些指令的输出被列表在其iclass的接口部分的。然后来自所有的语义块的被“与”(AND)的接口信号被“或”(OR)在一起以形成对核心的输出信号。图7说明TIE编译程序的输出接口信号sname的实现。Sname senI代表由第i个语义块产生的sname的值。iN1和iN2是单字节指令解码信号，并且Sname senI sel是一个代表第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--for access to reg_touched and reg_back push_a--copies regfile_a register 0 into reg_back pop_a--copies regfile_a register 0 from reg_back <dp n="d30"/> s128b reg_a_register，reg_b_register-stores the register file regfile_b into the address specified by regfile_a＇s register l128b reg_a_register，reg_b_register-loads the register file regfile_b from the address specified by regfile_a′s register s32a reg_a_register，reg_a_register-stores the register file regfile_a into the address specified by regfile_a′s register l32a reg_a_register，reg_a_register-loads the register file regfile_a into the address specified by regfile_a＇s register
在这种情况下，对于这个保存状态独立性的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单元，表达式
ctype gf8 8 8 gf
声明了一个名为“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>序列应该由单个指令组成。一个可能的例子：
proto GFADD8{out gf8 r，in gf8 s，in gf8 t}{}{
GFADD8 r，s，t；
}
proto的另一个用途是定义多指令内部语句。这里<tspec>可以是非空。例如：
proto GFADDXSQ8{out gf8 r，in gf8 s}{gf8 tmp}{
GFMULX8 tmp，s；
GFMULX8 r，tmp；
}
proto的一个附加用途是指示编译程序如何装入和存储用ctypeTIE结构声明的编程语言类型的值。如上面讨论的，为了使编译程序执行寄存器分配，以及允许寄存器文件的内容在某个任务转移时被保存和恢复，需要能够向存储器和从存储器中装入和存储值。
对于每个ctype<tnamr>声明，必须有下面形式的proto声明。
proto＜tname＞_loadi
{out＜tname＞＜x＞，
in＜tname＞*＜y＞，
in immediate＜z＞}
{＜tspec＞，...}
{
＜inst＞... //sequence of instructions that loads
//register＜x＞from the address＜y＞+＜z＞
}
proto＜tname＞_storei
{in＜tname＞＜x＞，
in＜tname＞*＜y＞，
in immediate＜z＞}
{＜tspec＞，...}
{
＜inst＞... //sequence of instructions that stores
//register＜x＞from the address＜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＞... //sequence of instructions that moves
//register＜y＞to register＜x＞
}
例如，还是伽罗瓦算法GF单元，proto声明：
proto gf8_loadi{out gf8 t，in gf8* s，in immediate o}{}{
LGF8.I t，s，o；
}
proto gf8_storei{in gf8 t，in gf8* s，in immediate o}{}{
SGF8.I t，s，o；
}
proto gf8_move{out gf8 r，in gf8 s}{}{
GFADD8I r，s，o；
}
需要输入到本优选实施例中，以使编译程序执行gf8变量的寄存器分配；还需要输入它们，以来为gf寄存器文件生成任务状态转移序列。
最后一个proto的用途就是定义在内置的和增加的类型之间的，以及不同的新类型之间的允许的转换。转换原型不是必需的；如果，例如，没有规定一个在新类型A和新类型B之间的转换，则编译程序就不允许类型A的变量转换为类型B的变量。对于每对新的或内置的类型<t1name>和<t2name>(其中至多有一个内置类型；这个结构不允许两个内置类型之间的转换的规范，因为这个转换已经被编程语言定义了)，能够有三个如下形式的proto声明：
proto＜t1name＞_rtor_＜t2name＞
{out＜t2name＞＜x＞，
in＜t1name＞＜y＞}
{＜tspec＞，...}
{
＜inst＞... //sequence of instructions that converts
//type＜t1name＞in register＜y＞to type
//＜t2name＞in register＜x＞
}
proto＜t1name＞_rtom_＜t2name＞
{in＜t1name＞＜x＞，
in＜t2name＞*＜y＞，
in immediate＜z＞}
<dp n="d35"/>
{＜tspec＞，...}
{
＜inst＞... //sequence of instructions that stores
//type＜t1name＞in register＜x＞as
//type＜t2name＞at the address＜y＞+＜z＞
}
proto＜t1name＞_mtor_＜t2name＞
out＜t2name＞＜x＞，
in＜t1name＞*＜y＞，
in immediate＜z＞}
{＜tspec＞，...}
{
＜inst＞... //sequence of instructions that loads
//type＜t1name＞from the address ＜y＞+＜z＞
//as type＜t2name＞into register ＜x＞
}
例如，还是伽罗瓦字段算法GF单元，proto声明：
proto gf8_rtom_char{in gf8 t，in char* s，in immediate o}{}{
SGF8.It，s，o；
}
proto char_mtor_gf8{out gf8 t，in char* s，in immediate o}{}{
LGF8.It，s，o；
}
将允许存储器中的类型char和寄存器中的类型gf8之间的转换。对于这些proto，下面的例子说明了如何利用GFADD内部语句将chars的两个矢量相加。
void
gfadd_vector(char *char_vector0，char *char_vector1，int size)
{
for(int i＝0；i＜size；i++){
gf8 p0＝char_vector0[i]；
gf8 p1＝char_vector1[i]；
gf8 res＝GFADD(p0，p1)；
char vector0[i]＝res；
}
}
在现有技术系统(如GNU编译程序)中，编译程序保持每个程序变量和编译程序生成的临时变量的类型信息。这些内置变量类型与高级语言(如C语言中的cnar，short，int，float，double等)相对应。对于每个内置类型，编译程序必须知道类型需要的类型的名称，大小及对准，以及必须向哪个寄存器文件分配类型的值。对于新类型，这个信息是由ctype语言结构提供的。使用ctype信息，编译程序生成一个内部类型结构来代表该类型，并且将该类型用于程序变量和按与内置类型相同的方式由编译程序生成的临时变量。
现有技术的GUN C语言编译程序使用枚举类型machine_mode在内部表达类型。相关的类型按类分组在一起，由枚举类型machine_class进行描述。要支持新的类型，本领域的技术人员可以向machine_class增加一个枚举器来表示代表用户定义的类型的类，并且可以利用ctypeTIE语言结构为每个声明的新类型向machine_mode增加一个枚举器。例如，假定代表新类型的类称作MODE_USER，在machmode.h文件中的mode_class的定义为：
enum mode_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)
本领域的技术人员可以更改GUN C编译程序使用的分析和优化逻辑，以使其正确执行于MODE_USER类的类型。
在现有技术编译程序中，代码选择器(或代码生成器)负责为每个内部表达的低级指令替换一低级指令序列(有些相当于汇编指令)。代码选择器通过检查由内部指令及指令操作数的类型执行的操作，决定以哪个指令序列替换。例如，代表add的一个内部指令可以有两个int类型的值作为输入，一个int类型的值作为输出；或者可以有两个float类型的值作为输入，有一个float类型的值作为输出。在输入和输出值类型的基础之上，代码选择器要么选择执行整数加的指令的序列，要么选择执行浮点加的指令的序列。对于用户定义的类型，装入、存储、移动和转换proto定义，描述了用于替换具有一个或多个用户定义类型的操作数的内部指令的指令序列。还是伽罗瓦算法GF单元的例子，如果内部指令代表一个gf8值的装入，则代码选择器询问gf8_loadi proto以决定要为该指令的指令序列。
在现有技术GNU C编译程序中，在目标处理器中可用的指令是利用指令模式进行描述的；请见，例如Stallman，“Using andPorting GNU CC”(1995)获得更多信息。这些指令模式描述指令，包括操作数的个数及类型。要在编译程序中支持用户定义的类型，要将装入、存储、移动及转换proto转换为编译程序支持的指令模式。例如，gf8_load proto可按下面的模式表示(假定gf8类型已经被变换为machine_mode枚举器U0mode)：
(define_insn＂＂
[(set(match_operand：U0 0＂register_operand＂＂v＂)
(match_operand：U0 1＂memory_operand＂＂U＂))]
＂＂
＂LGF8.I\t％0，％1＂)
规定一个临时寄存器的proto被转变为一个覆盖了或“打破(clobber)”了某类型的操作数的指令模式。编译程序将保证被“打破”的操作数在该指令的存储单元不可用，以便于指令可以将其用作一个临时的操作数。例如，下面的对于用户定义类型的tt的装入proto生成了一个包含一个“打破”的指令模式。
proto tt_loadi{out tt x，in tt* y，in immediate z}{char t}
{
L8UIt，y，z；
MVTTx，t；
}
(define_insn＂＂
[(parallel[(set(match_operand：U0 0＂register_operand＂＂v＂)
(match_operand：U0 1＂memory operand＂＂U＂))
(clobber(match_operand：U0 2＂register operand＂＂a＂))])]
＂＂
＂L8UI\t％2，％1\nMVTT\t％0，％2＂)
内部函数声明
在Killian等人的申请中，生成了一个内部函数声明文件，该文件中包含所有类似使用GUN asm语句的功能的TIE指令的定义。特别的，每个指令功能具有C volatile的特性，以限制可能发生的优化。这个方法，尽管安全，但是阻碍了某些将TIE指令进行安全地重排序的编译程序优化。本发明通过两种方式改进了现有技术系统。第一，只有装入和存储指令被声明为易失的，因此给予了编译程序在代码优化期间的最大的记录指令的自由度。在第二项改进中，使用特殊的和用户声明的状态的指令，通过一个显式的状态变量进行声明，因此给编译程序更精确的有关指令的副作用的信息。下面的头文件是TIE编译程序生成的，用以将所有在GF例子中的指令声明为内部函数：
/* Do not modify.This is automatically generated.*/
typedef int gf8_attribute_((user(＂gf8＂)))；
#define GFADD8_ASM(gr，gs，gt){\
_asm_(＂gfadd8 ％0，％1，％2＂：＂＝v＂(gr)：＂v＂(gs)，＂v＂(gt))；\
}
#define GFADD8I_ASM(gr，gs，imm4){\
_asm_(＂gfadd8i ％0，％1，％2＂：＂＝v＂(gr)：＂v＂(gs)，＂i＂(imm4))；\
}
<dp n="d39"/>
#define GFMULX8_ASM(gr，gs){\
register iht_xt_state asm(＂state＂)；\
__asm__(＂gfmulx8
％1，％2＂：＂+t＂(_xt_state)，＂＝v＂(gr)：＂v＂(gs))；\
}
#define GFRWMOD8_ASM(gt){\
register int _xt_state asm (＂state＂)；\
__asm__(＂gfrwmod8 ％1＂：＂+t＂(_xt_state)，＂＝v＂(gt)：＂1＂(gt))；\
}
#define LGF8_I_ASM(gt，ars，imm8){\
__asm__\
volatile(＂lgf8_i ％0，％1，％2＂：＂＝v＂(gt)：＂a＂(ars)，＂i＂(imm8))；\
}
#define SGF8_I_ASM(gt，ars，imm8){\
__asm__\
volatile(＂sgf8_i％ 0，％1，％2＂：：＂v＂(gt)，＂a＂(ars)，＂i＂(imm8))；\
}
#define LGF8_IU_ASM(gt，ars，imm8){\
__asm__volatile(＂lgf8_iu ％0，％1，％3＂：\
＂＝v＂(gt)，＂＝a＂(ars)：＂1＂(ars)，＂i＂(imm8))；\
}
#define SGF8_IU_ASM(gt，ars，imm8){\
__asm__volatile(＂sgf8_iu ％1，％0，％3＂：\
＂＝a＂(ars)：＂v＂(gt)，＂0＂(ars)，＂i＂(imm8))；\
}
#define LGF8_X_ASM(gr，ars，art){\
__asm__volatile(＂lgf8_x ％0，％1，％2＂：\
＂＝v＂(gr)：＂a＂(ars)，＂a＂(art))；\
}
#define SGF8_X_ASM(gr，ars，art){\
__asm__ volatile(＂sgf8_x ％0，％1，％2＂：：\
＂v＂(gr)，＂a＂(ars)，＂a＂(art)}；\
}
#define LGF8_XU_ASM(gr，ars，art){\
__asm__volatile(＂lgf8_xu ％0，％1，％3＂：\
＂＝v＂(gr)，＂＝a＂(ars)：＂1＂(ars)，＂a＂(art))；\
}
#define SGF8_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传送有关这些指令有副作用的信号给编译程序。
寄存器分配
现有技术系统(如GNU C编译程序)包括为移植性设计的寄存器分配算法。移植性要求编译程序支持多种ISA。即使这些ISA本身不是可配置或可扩展的，一个要满足所有这些的编译程序必须具有普遍的寄存器分配功能。因此，现有技术系统允许多寄存器分配，并且某些系统可能限制对于某个寄存器文件的程序语言类型。
现有技术的GNU C编译程序允许通过更改目标的机器描述来支持可以规定任何数量的寄存器文件。本领域的技术人员可以通过“Using and Porting GNU CC”中说明的，为实现某目标而更改机器描述以向GCC增加对一个或多个寄存器文件的支持。
对于每个TIE regfile结构，编译程序被自动配置以向寄存器文件中的寄存器分配值。regfile结构指明了在寄存器文件中的寄存器数量。如上所述，当要分配每个具有用户定义类型的程序值时，TIE ctype结构规定了要将某种类型的值分配去的寄存器文件。编译程序就利用这个信息以及寄存器文件中的寄存器数量。还是还是伽罗瓦算法GF单元例子，gf寄存器的regfile结构是：
regfile gf 8 16 g
这表示有16个gf寄存器，每个为8字段。
Gf8类型的ctype结构是：
ctype gf8 8 8 gf，
这表示类型gf8的值必须分配给寄存器文件。因此，编译程序要将所有的类型gf8的值分配给寄存器文件，该寄存器文件有16个寄存器。
指令调度
现有技术(如GNU C编译程序)包括重新对指令排序以通过降低流水线停止来提高性能的指令调度算法。当满足了其它流水线的约束，如发送宽度、功能单元可利用性后，这些算法的运行通过模拟目标处理器的流水线来决定能够产生最少数量的停止周期的指令排序来实现。
现有技术的GNU C编译程序，对于任何一对指令来讲，通过确定在一个指令紧跟另一个指令被调度时就会产生的停止周期的数量，来模拟处理器的流水线。在每对指令的停止信息的基础上，编译程序要发现可以使总的停止周期最小化的指令排序。对于新的TIE指令，编译程序通过利用TIE语言调度结构提供的信息来确定停止周期。要确定如果指令B紧跟指令A被调度就会发生的停止周期，编译程序将每个A中的输出操作数的写的流水线阶段与每个相应的B中的输入操作数的读流水线阶段相比较。对于每个操作数，将这些值的差加1(因为定义的操作数流水线阶段值的调度结构的语义)，就表是必须将A与B分开以避免停止的最小周期数。值1表示B可以紧跟A后被调度而不会发生停止，值2表示紧跟A后调度B将产生一个停止周期，等等。有关由A写的所有操作数的最大停止值，是B紧跟A被调度时的停止周期数。
考虑以下调度结构的例子：
schedule aload{ALD}}
{
use imm8 0；
use ars 1；
def xt 2；
}
}
schedule aadd{AADD}
{
use xa 1；
use xb 2；
def xc 2；
}
在下面的代码序列中，在ALD指令中的操作数xt，x3，与AADD指令中的xa操作数相同。因此，AADD指令必须在ALD之后的(defxt)-(use xa)+1＝2-1+1＝2个周期才被调度，以避免停止。如果AADD在ALD之后立即被调度，则就会有一个周期的停止。
ALD x3，a0，0
AADD x0，x3，x1
在下面的代码序列中，在ALD指令中的xt操作数，x3，与AADD指令中的xb操作数相同。因此，AADD指令必须在ALD之后的(def xt)-(use xb)+1＝2-2+1＝1个周期才被调度，以避免停止。这种情况下，如果AADD在ALD之后立即被调度，就没有停止。
ALD x3，a0，0
AADD x0，x1，x3
延迟状态切换
向处理器增加寄存器文件会增加状态的数量，这些状态必须被保存和恢复为多数实时操作系统使用的多任务环境中的任务切换的一部分。因为增加的状态经常对应某个在一个任务子集中被执行的计算，不应该对每个任务切换保存和恢复这些增加的状态，因为这样作会不必要地增加了任务切换周期的数量。在不可扩展处理器中这也是一个问题，但是在现有技术中有对这一问题的解决方案。例如，MIPS R2000CPENABLE位允许协处理器寄存器从一个任务到另一个任务的“延迟”切换。本优选实施例允许将延迟切换用于由处理器扩展(TIE state和regfile声明)所创建的状态。
这是最复杂的保存和恢复操作之一。它因几个原因而复杂：它在比上下文切换延迟的点发生；
运行时间必须管理每个处理器文件的有效性；当异常出现时，核心自身就在改变协处理器的有效性。
为了说明这是如何被处理的，假定有一个有两个任务A和B的系统。还有两个协处理器寄存器，cp_0和cp_1。系统的状态由核心保持的有效位和由运行时间所保持寄存器文件所有者记录所组成。考虑表I中的事件序列。在本例中，协处理器状态假定被存储在每个任务的堆栈的底部。
表I
| 0有效 | 1有效 | 0所有者 | 1所有者 | 事件 | 注释 |
| X1 | X1 | X无 | X无 | 初始化 | 核心启动，状态不明。首先系统将所有的寄存器 |
| 0001 | 0001 | 无无无A | 无无无无 | 任务A创建任务B创建任务A使用cp_0任务B调入 | 文件设为有效。然后调用init程序为每个文件建立状态。在初始化的最后，系统声明所有的寄存器文件对使用无效，并且寄存器文件还没有所有者。在任务A创建期间，操作系统确保使用init_mem调用以使任务A的堆栈的底初始化为“安全”值，作为起始存储。任务A的堆栈指针在这个保存区域后设为开始。协处理器的状态未受影响。任务B的创建与A类似寄存器文件的使用引起了异常。异常建立了有效位。因为没有cp_0的先前所有者，所以没有执行数据的保存。由于任务A访问了协处理器，所以任务A的数据被装入cp_0.cp_0的所有关系分配给A。 |
| 0011 | 0100 | AAAA | 无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_0 |
| 100 | 111 | AAA | AAB | 任务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中的多周期指令
在现有技术中，需要多周期计算的指令需要附加逻辑将结合的计算逻辑放入流水线，并防止依赖于尚未计算出的结果的指令流出。此外，对于这种处理器的编译程序应该包括记录指令以最小化流水线停止的算法。
第一项内容一般是通过处理器设计者使流水线寄存器在小心选择的位置插入的协逻辑实现的。第二项内容一般是这样实现的，比较流水中的一个将要发出给所有尚未计算的目的操作数的指令的源操作数，并且如果有一个匹配的则保持该指令。
第三项内容必须是协同的。如果计算逻辑的流水线操作与发出逻辑的变化不匹配，则处理器可能会产生错误的结果。如果为了最小化流水线停止的重新排序与计算逻辑的流水线操作不一致，则就会导致次优化性能。(如在一个结果准备好之前调度它的使用将导致流水线停止)。
看下面的例子：
MUL a3，a4，a5 /*a3＝a4*a5，a 2-cycle instruction */
ADD a6，a3，a7 /*a6＝a3+a7，a single cycle instruction */
SUB a2，a0，a1 /*a2＝a0-a1，a single cycle instruction */
如果MUL逻辑在两个周期中实现，但是控制逻辑在每个周期发出一条指令，由于在ADD指令需要的时间a3还没有正确的值，所以a6将会出现错误的结果。为了正确，发出逻辑必须知道MUL被流水线达两个周期，并且在发出ADD指令前要停止一个中期。即使通过停止ADD指令一个周期导致了正确的逻辑，但是它没有提供优化的性能。通过切换ADD指令和SUB指令的次序，在本例子中就不需要停止任何指令，并且因此可以产生优化的性能。这只能通过在MUL逻辑的执行、指令发出逻辑的执以及指令重排序(调度)之间的协同来实现。
在现有技术系统中，这三项内容(流水线逻辑、流水线停止及指令调度)经常是分别实现的，这就使得协同更为困难并且增加了设计验证的要求。本发明的优选实施例提供一种方法用以规定被这些特征要求的信息的，并且实现规范中处理器生成程序中的这三项内容。
此外，本优选实施例的指令集仿真程序使用同样的时间模型中的调度信息的规范。这允许应用开发者使用所有的本优选实施例的特性，在硬件制造前就获得好的性能预期，而不需要在一个运行很慢的HDL仿真程序上运行他们的应用。
这里参考了由Killian和Warthman所著的《Xtensa指令集结构参考手册(Xtensa Instruction Set Architecture(ISA) ReferenceManual)的第十章，它公开了一种描述流水线硬件的方法，该方法已经用于处理器流水线性能建模，并且已经在现有技术中被用于最小化流水线停止。在本优选实施例中，只是将这个描述辅助用于上述三项内容种的前两项。
具体地，TIE语言目前包括声明
schedule＜schedulename＞{＜iname＞，...}
in＜oname＞＜stage＞；
.
.
.
out＜oname＞＜stage＞；
.
.
.
}
其中<iname>是指令名；
<oname>是一个操作数或状态名；
<stage>是一个表示流水线阶段的序号。
TIE使用的缺省阶段号比由Killian和Warthman所著的《Xtensa指令集结构参考手册(Xtensa Instruction Set Architecture(ISA)Reference Manual)的第十章中说明的值小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个流水线寄存器。
通过下例说明这一过程：
state s1 1
state s2 32
state s3 32
iclass complex{example}{out arr，in ars，in art}{in s1，in
in s3}
semantic complex{example}{
wire[31：0]temp1＝s1？ars：art；
wire[31：0]temp2＝s2-temp1；
assign arr＝s3+temp2；
}
schedule complex{example}{
in ars 1； /* using operand ars in stage 1 */
in art 1； /* using operand art in stage 1 */
in s1 2； /* using state s1 in stage 2 */
in s2 2 ； /* using state s2 in stage 2 */
in s3 1； /* using state s3 in stage 1 */
out arr 3； /* defining operand arr in stage 3 */
}
这个例子规定指令“example”使用操作数ars、art且在阶段1使用状态s3，在阶段2使用状态s1和s2。它在阶段3产生结果操作数arr。对于这个描述，上面的寄存器插入程序将产生图8(a)中的电路。因为最大输入阶段是2，所以节点“？”的NS是2。因为ars和art的IS是1，所以在节点“？”的各个输入中插入一个寄存器。类似地，在节点“+”，s3输入被延迟了一个阶段以与其它输入相匹配。最后，节点“+”的输出在被分配给arr前被延迟了一个周期。如果在上述例子的调度描述中声明arr为“out arr 1”，则流水线插入程序将产生图8(b)中的电路。既然节点“？”的NS是2且arr的OS是1，由于不满足输入调度要求，所以程序将发出一个错误信息。
上述算法可以根据需要正确地插入了流水线寄存器，但是这些寄存器的排列离优化还较远。在初始插入以生成用于合成的可接受的逻辑之后，有必要使用一个流水线寄存器优化算法，如在《Synopsys’DesignCompiler》建立的算法。这一般是通过在组合逻辑中移动寄存器，以平衡寄存器两侧的逻辑延迟实现的。使用上述例子，寄存器优化将产生一个如图8(c)中的电路，其中在节点“+”的输出处的寄存器被移动到输入处以平衡延迟和降低周期时间。
在某些情况下，可能需要有一个为一个指令在一流水线阶段使用或定义一个寄存器操作数语义块，而在另一个阶段为一个不同的指令使用或定义一个寄存器操作数语义块，这是因为两个指令可能共享一些共同的逻辑。规定指令在两个分离的语义块会需要不必的逻辑复制。
这是在有关本实施例的一个变型中的可能的扩展。通过在为两个操作数，如<operand>@<stage>而不只是<operand>，的语义块中使用分离信号名，就可以支持这个能力。一旦这个更改实现了，上述算法即使在多系统环境中也能正确运行。
例如，如果要实现下面的两条指令：
inst1：arr＝ars+art
inst2：arr＝ars+art+s1
而由于某些原因，s1必须为阶段1输入，且周期时间要求只能在一个周期中执行一个加法。使用上述扩展，语义描述将如下：
semantic two{inst1，inst2}{
wire[31：0]temp＝ars+(inst1？art：s1)；
assign arr＝temp；
assign arr@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描述的逻辑。
iclass i1 {inst1}{...}{...} {out exc1}
iclass i2 {inst2}{...}{...} {out exc2}
iclass i3 {inst3}{...}{...} {out exc3}
iclass i4 {inst4}{...}{...} {out exc1}
exception＜exc1＞＜exccode1＞{}“Low level exception
condition”
exception＜exc2＞＜exccode2＞{}“Medium level exception
condition”
exception＜exc3＞＜exccode3＞{}“High level exception
condition”
schedule s1{inst1}{def exc1 1；}
schedule s2{inst2}{def exc1 3；}
schedule s3{inst3}{def exc1 2；}
schedule s4{inst4}{def exc1 3；}
在这种情况下，异常exc1可以在C1中由inst1和在C3中由inst4引发，exc2可以在C3中由inst2引发，exc3可以在C2中由inst3引发。在本具体实施例中，所有的异常信号都是在它们的声明阶段生成的，并且继续流水线至提交阶段，在该阶段，通过按在上述TIE说明中规定的异常信号的优先权选择异常代码，来计算异常引发值。该异常信号Exception及引发信号ExcCause被馈送给核心。一旦一个异常开始被处理了，核心将发回一个信号给TIE逻辑以消除所有在流水线中的指令，并有效地清除剩余的未处理的异常。
另一个例子，图10表示由代码描述的电路，该代码将有两个异常及一些产生一个异常的指令和一个产生两个异常的指令。在本例中，“溢出”的优先权比“被零除”的优先权低(实际上在一个除法中两者可能同时发生，因此相对优先权是不相关的)。
在图中，注意到每个描述的语义块都会产生一些全部的TIE异常集的子集；因此，精确的布线是有赖于输入的。此外，在语义块中，异常输出被通过TIE调度结构流水线到分解阶段。
exception Overflow 40{}＂Integer Overflow＂
exception DivZero 41{Overflow}＂Integer Divide by Zero＂
iclass ov{ADDO，SUBO，MULO，DIVO}{out arr，ars，art}
{out Overflow}
reference ADDO{
wire[32：0]t＝{ars[31]，ars}+{art[31]，art}；
assign Overflow＝t[32]！＝t[31]；
assign arr＝t[31：0]；
}
reference SUBO{
wire[32：0]t＝{ars[31]，ars}-{art[31]，art}；
assign Overflow＝t[32]！＝t[31]；
assign arr＝t[31：0]；
}
reference MULO{
wire[63：0] t＝{{32{ars[31]}，ars} * {{32{art[31]}，art}；
assign Overflow＝t[63：32]！＝{32{t[31]}}；
assign arr＝t[31：0]；
}
semantic{ADDO，SUBO}{
wire[32：0]t＝{ars[31]，ars}+({ars[31]，art}^
{{33}SUBO})+SUBO；
assign Overflow＝t[32] ！＝t[31]；
assign arr＝t[31：0]；
}
semantic {DIVO}{
assign DivZero＝art＝＝32′b0；
assign Overflow＝(ars＝＝32′h80000000) & (art＝＝
32′hffffffff)；
assign arr＝...；
}
图10表示一个排列，其中所有的TIE异常都具有一个单一的固定的相对于所有核心异常的优先权。一个直接扩展允许TIE异常语句显式地引用各种核心异常。这样TIE编译程序将能够产生一个优先权解码，而不是将TIE异常与核心异常相结合。
参考语义
类似那些在Killian等人和Wilson等人的申请中描述的系统，每个指令具有一个单一的语义定义。这个语义定义用于生成代表指令的硬件和软件。这些系统允许将多个指令定义在一起，由一热指令解码输入信号进行区分(如“加”及“减”指令能够共享一个加法器)。使用这些特性对于生成高效的硬件是必要的。随着本优选实施例定义的指令复杂性的提高，一套有效率的实现语义就变得越来越难以读、写、检验和理解。它们也变得更多为流水线调整，且缺少抽象性。这是因为描述必须考虑流水线效果，并创建流水线寄存器在其中能够被移动的信号。
例如，给定一个TIE中的浮点实现，为了实现相对于3周期或4周期的一个2周期的浮点加操作，可能写出不同的代码。因为程序员经常以牺牲清晰性为代价来优化代码，以便产生更少的门，这就缺乏抽象性。例如，一个人可能用参考语义清楚地写出：
assign x＝y * 3；
但是以实现语义写出则是：
assign x＝y+{y[30：0]，1′b0}；
因为软件开发工具不处理常数相乘的情况，以及类似的能够手工处理的情况。
另一个例子说明一个参考语义的乘法累加指令，该例如下：
acc＝a * b+acc；
但是在语义描述中，必须考虑到这条指令必须通过两个流水线阶段执行。一个熟练的硬件设计人员会知道a*b的部分结果需要在第一阶段使用一个进位保留加法器树进行计算，并且将两个部分结果与acc相加的最终结果是在第二阶段计算出的。
最后，实现语义在被翻译为仿真软件时会变慢，这是因为失去了与本地机器指令的对应。使用先前的指令，参考描述能够使用两条指令进行仿真。在这种情况下要仿真语义描述将使用成百条的指令。
由于上述原因，本优选实施例允许两套语义的规范。一套被称为参考语义。每条指令有一个参考语义，而且在指令间没有语义的共享。写这样的语义定义通常是为了清晰地定义期望的指令的操作。第二套语义是实现语义，它用于硬件执行。这些指令保持了现有技术系统的特性，从而允许硬件被多个指令所共享，并且通常通过在头脑中的门级合成，以更低的级别写出。
这可以通过一个定义两个指令“ADD”和“SUB”的简单的TIE例子说明如下：
iclass rrr{ADD，SUB}{out arr，in ars，in art}
iclass rr{NEG}{out arr，in ars}
reference ADD{
assign arr＝ars+art；
}
reference SUB{
assign arr＝ars-art；
}
reference NEG{
assign arr＝-ars；
}
semantic alu{ADD，SUB，NEG}{
wire[31：0]l，r；
assign l＝SUB？-art：NEG？-ars：art；
assign c＝(SUB|NEG)？1：0；
assign r＝NEG？0：ars；
assign arr＝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*b：c+a*b |
| TIEadd(a，b，cin) | 与输入相加 | a+b+cin |
| TIEcsa(a，b，c) | 进位保留加法器 | {a&b|a&c|b&c，a^b^c} |
作为一个例子，下面的描述在ADD和SUB指令间共享一个加法器。
assign arr＝TIEadd(ars，SUB？ -art：art，SUB)；
下面的语义描述使用一个后面跟有全加器的进位保留加法器(CSA)阵列将四个数相加。
wire[31：0]s1，c1，s2，c2；
assign{s1，c1}＝TIEcsa(d1，d2，d3)；
assign{s2，c2}＝TIEcsa(c1<<1，s1，d4)；
assign sum＝(c2<<1)+s2；
使用象这些内置模块的优点是，TIE编译程序能够识别内置模块并且用一个模块生成器来为模块产身更高效率的执行。
文档
参考语义也是指令集文档的一个重要元素。一个典型的指令集参考手册(图12为其一示例页)可以包括每条指令的机器代码格式、包、汇编语法、摘要(指令的一行文本描述)、指令的全文本描述、指令的更精确的操作定义、以及如汇编注释和与指令有关的异常等附加信息。由于TIE规范包含操作码位和操作数字节，因此所有的对于生成机器代码格式所需的信息都已经在其中。类似地，汇编语法可以从助记符号和操作数名得出。TIE参考语义就成为精确定义。只是没有摘要和文本描述。本优选实施例因此向TIE增加了结构以允许指令集设计者规定摘要和文本描述。
TIE package规范具有格式：
package<pname><string>
endpackage<pname>
包名<pname>与所有的在package和endpackage之间定义的指令有关。包具有除对文档以外的其它更多用途，下面将说明。参数<string>给出用于文档的package的名称(它可以有空格)。
TIE synopsis规范具有格式：
synopsis<iname><string>
其中<string>是指令的一个短(大约半行)的描述。在文本中没有格式控制。这个文本一般用于书中的标题以及指令列表中的附加材料。
TIE description规范具有格式：
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”)中的固定名称引入各个部分。第一部分，标为“Instruction Word”，给出了由每“位”一列的HTML表格表示的机器码格式。操作码“位”(’0’或’1’)被插入相应的表元中。操作数字段以字段名填写。跨越多个相临位的字段使用HTML表格的COLSPAN特性来避免重复。使用上面的表的行对机器码逻辑框的位进行编码，而字段的宽度在下面一行给出。
第二部分，标为“Assemble Syntax”，给出用于定义指令的TIE包名。使用一个简单的散列将包名从一个识别符转换为文档串。包名自身在HTML段落块元素(“p”)内给出。
第三部分，标为“Assembler Syntax”，给出用于对指令编码的汇编语言格式。这由指令助记、空格以及由逗号隔开的操作数名组成。寄存器操作数名通过将寄存器文件的短名与字段名连接而形成。立即操作数名就是TIE中的立即数名。汇编程序语法在一使用HTML代码直接插入元素(“CODE”)的HTML段落块级元素(“p”)内给出。代码直接插入元素以一种与编程语言被修饰的方式类似的固定宽度字体来修饰文本。
第四部分，标为“Description”，包含被从TIE转换为HTML的文本描述。因为TIE格式的代码与HTML格式的相似，因此这个转换非常简单。主要需要将INSTREF元素转换为连向指定的指令的HTML链接。
可选择的第五部分，标为“Assemble”，包含从TIE转换为HTML的文本。
第六部分，标为“Exceptions”，包含一列指令可能引起的异常。Load和Store指令自动地通过TIE编译程序将LoadStoreError异常增加到列表中。如果其它的相应的异常信号被列在指令的iclass的信号列表部分，则这些异常就被列出。异常是按优先权次序被列出的(拓扑排序的结果上面已经描述)。
可选择的第七部分，标为“Implementation Notes”，包含从TIE转换为HTML的文本。
可以将检测实例列表从下面描述的TIE规范拷贝到文档中，因为有时这对读者是有用的。
下面给出处理器指令文档的一个例子。
＜html＞ ＜head＞ ＜title＞ GFADD8-Galois Field 8-bit Add ＜/title＞ ＜/head＞ ＜body＞ ＜h1＞ GFADD8 &#8212；Galois Field 8-bit Add ＜/h1＞ ＜h2＞ Instruction Word ＜/h2＞ ＜table frame＝＂void＂rules＝＂groups＂cellspacing＝0 cellpadding＝0＞ ＜colgroup colspan＝8＞＜col width＝28＞＜col width＝28＞＜col width＝28＞＜col width＝28＞＜col width＝28＞＜col width＝28＞＜col width＝28＞＜col width＝28＞＜colgroup colspan＝4＞＜col width＝28＞＜col width＝28＞＜col width＝28＞＜col width＝28＞＜colgroup colspan＝4＞＜col width＝28＞＜col width＝28＞＜col width＝28＞＜col width＝28＞＜colgroup colspan＝4＞＜col width＝28＞＜col width＝28＞＜col width＝28＞＜col width＝28＞＜colgroup colspan＝4＞＜col width＝28＞＜col width＝28＞＜col width＝28＞＜col width＝28＞ ＜thead＞ ＜tr＞ ＜td width＝28 align＝＂center＂＞ ＜small＞23＜/small＞ ＜/td＞ ＜td width＝28 align＝＂center＂＞ ＜/td＞ ＜td width＝28 align＝＂center＂＞ ＜/td＞. ＜td width＝28 align＝＂center＂＞ ＜/td＞ ＜td width＝28 align＝＂center＂＞ ＜/td＞ ＜td width＝28 align＝＂center＂＞ ＜/td＞ ＜td width＝28 align＝＂center＂＞ ＜/td＞ ＜td width＝28 align＝＂center＂＞ ＜small＞16＜/small＞ ＜/td＞ ＜td width＝28 align＝＂center＂＞ ＜small＞15＜/small＞ ＜/td＞ ＜td width＝28 align＝＂center＂＞ ＜/td＞ <dp n="d62"/> ＜td width＝28 align＝＂center＂＞ ＜/td＞ ＜td width＝28 align＝＂center＂＞ ＜small＞12＜/small＞ ＜/td＞ ＜td width＝28 align＝＂center＂> ＜small＞11＜/small＞ ＜/td＞ ＜td width＝28 align＝＂center＂＞ ＜/td＞ ＜td width＝28 align＝＂center＂＞ ＜/td＞ ＜td width＝28 align＝＂center＂＞ ＜small＞8＜/small＞ ＜/td＞ ＜td width＝28 align＝＂center＂＞ ＜small＞7＜/small＞ ＜/td＞ ＜td width＝28 align＝＂center＂＞ ＜/td＞ ＜td width＝28 align＝＂center＂＞ ＜/td＞ ＜td width＝28 align＝＂center＂＞ ＜small＞4＜/small＞ ＜/td＞ ＜td width＝28 align＝＂center＂＞ ＜small＞3＜/small＞ ＜/td＞ ＜td width＝28 align＝＂center＂＞ ＜/td＞ ＜td width＝28 align＝＂center＂＞ ＜/td＞ ＜td width＝28 align＝＂center＂＞ ＜small＞0＜/small＞ ＜/td＞ ＜/tr＞ ＜/thead＞ ＜tbody＞ ＜tr＞ ＜td width＝28 align＝＂center＂ bgcolor＝＂#FFF0F5＂＞ 0 ＜/td＞ ＜td width＝28 align＝＂center＂ bgcolor＝＂#FFF0F5＂＞ 0 ＜/td＞ ＜td width＝28 align＝＂center＂ bgcolor＝＂#FFF0F5＂＞ 0 ＜/td＞ ＜td width＝28 align＝＂center＂ bgcolor＝＂#FFF0F5＂＞ 0 ＜/td＞ ＜td width＝28 align＝＂center＂ bgcolor＝＂#FFF0F5＂＞ 0 ＜/td＞ <dp n="d63"/> ＜td width＝28 align＝＂center＂bgcolor＝＂#FFF0F5＂＞ 1 ＜/td＞ ＜td width＝28 align＝＂center＂bgcolor＝＂#FFF0F5＂＞ 1 ＜/td＞ ＜td width＝28 align＝＂center＂bgcolor＝＂#FFF0F5＂＞ 0 ＜/td＞ ＜td colspan＝4 width＝112 align＝＂center＂bgcolor＝＂#FFE4E1＂＞ r ＜/td＞ ＜td colspan＝4 width＝112 align＝＂center＂bgcolor＝＂#FFE4E1＂＞ s ＜/td＞ ＜td colspan＝4 width＝112 align＝＂center＂bgcolor＝＂#FFE4E1＂＞ t ＜/td＞ ＜td width＝28 align＝＂center＂bgcolor＝＂#FFF0F5＂＞ 0 ＜/td＞ ＜td width＝28 align＝＂center＂bgcolor＝＂#FFF0F5＂＞ 0 ＜/td＞ ＜td width＝28 align＝＂center＂bgcolor＝＂#FFF0F5＂＞ 0 ＜/td＞ ＜td width＝28 align＝＂center＂bgcolor＝＂#FFF0F5＂＞ 0 ＜/td＞ ＜/tr＞ ＜/tbody＞ ＜tfoot＞ ＜tr＞ ＜td colspan＝8 width＝224 align＝＂center＂＞ ＜small＞8＜/small＞ ＜/td＞ ＜td colspan＝4 width＝112 align＝＂center＂＞ ＜small＞4＜/small＞ ＜/td＞ ＜td colspan＝4 width＝112 align＝＂center＂＞ ＜small＞4＜/small＞ ＜/td＞ ＜td colspan＝4 width＝112 align＝＂center＂＞ ＜small＞4＜/small＞ ＜/td＞ ＜td colspan＝4 width＝i12 align＝＂center＂＞ ＜small＞4＜/small ＞ ＜/td＞ ＜/tr＞ ＜/tfoot＞ ＜/table＞ ＜h2＞ Package <dp n="d64"/> ＜/h2＞ ＜P＞ ＜/P＞ ＜h2＞ Assembler Syntax ＜/h2＞ ＜P＞ ＜code＞GFADD8 gr，gs，gt＜/code＞ ＜/P＞ ＜h2＞ Description ＜/h2＞ ＜P＞＜CODE＞GFADD8＜/CODE＞ performs a 8-bit Galois Field addition of the contents of GF registers＜CODE＞gs＜/CODE＞and＜CODE＞gt＜/CODE＞ and writes the result to GF register ＜CODE＞gr＜/CODE＞.＜/P＞ ＜h2＞ Operation ＜/h2＞ ＜pre＞ gr＝gs^gt； ＜/pre＞ ＜h2＞ Exceptions ＜/h2＞ ＜P＞ None ＜/P＞ ＜/body＞ ＜/html＞
尽管在本优选实施例中使用HTML用作文档格式语言，但是本领域的技术人员可以发现其它同等规范的语言，如Adobe公司的FrameMaker MIF格式也是可以用的。
子字段
在本发明的具体实施例中，一个使得对改变程序执行特性的处理器结构的配置选项的敏感性降低的进步就是，将一个字段定义为另一个字段的子字段的能力。这与现有的可配置处理器系统形成对比，现有的系统限制对指令字的规定部分的字段的定义，并且不允许将它们定义为其它字段的一部分。将字段定义为其它字段的子字段的能力允许软件部分地独立于可配置处理器的endianess。
例如，在现有技术系统中，一个对应于t字段的前两位的新字段t10只能被定义为下面两中TIE语句之一：
field t10 inet[5：4} /* for field memory order */
或
field t10 inst[15；14] /* for big endian memory order */
在这种排列下，不可能独立于存储器次序定义t10。通过允许使用子字段，本发明允许t10定义如下：
field t10 t[1：0]
因为t被处理器核心定义为短endian的inst[7：4]，定义为长endian的inst[17：14]，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等人的申请中描述的TIE user_register结构声明。然后它使用由用于装入寄存器的proto声明规定的内部指令建立in和inout寄存器文件操作数。在核心寄存器文件(如本优选实施例中的AR的)中的操作数使用内置语言类型。然后，TIE编译程序调用具有按iclass规定的次序排列的操作数的内部语句。然后，读在测试中的out列表中规定的out和inout操作数，并且与给定的预期值比较。最后，使用RUR内部指令及user_register结构的寄存器数，读在测试中的out列表中的处理器寄存器，并且将这些值被与给定的值进行比较。
这个自动生成的程序设计语言诊断程序可以运行在指令集仿真程序上，或在硬件RTL模型上，或本机使用由TIE编译程序通过转换为目标程序设计语言产生的内部仿真函数。
作为一个例子，规范
test GFADD8{
in{gs＝＞8′xFF，gt＝＞8′xA5}
out{gr＝＞8′x5A}
}
test GFMULX8{
in{gs＝＞8′xFF，gfmod＝＞8′xA5}
out{gr＝＞8′x5B}
}
产生C诊断程序
unsigned char GFADD8_0[1]＝{255}；
unsigned char GFADD8_1[1]＝{165}；
unsigned char GFADD8_2[1]＝{90}；
unsigned char GFMULX8_0[1]＝{255}；
unsigned char GFMULX8_1{1]＝{91}；
unsigned char GFMULX8_2[1]＝{165}；
int
main(int argc，char *argv[1]
{
for(i＝0；i＜1；i+＝1){
gf gr；
gf gs；
gf gt；
unsigned char t0；
LGF8_I(gs，&GFADD8_0[i]，0)；
LGF8_I(gt，&GFADD8_1[i]，0)；
GFADD8(gr，gs，gt)；
SGF8_I(gr，&t0，0)；
if(t0 ！＝GFADD8_2[i])
fail()；
}
for(i＝0；i＜1；i+＝1){
gf gr；
gf gs；
unsigned char t0；
LGF8_I(gs，&GFMULX8_0[i]，0}；
WUR(GFMULX8_1[i]，0)；
GFMULX8(gr，gs)；
SGF8_I(gr，&t0，0)；
if(t0 ！＝GFMULX8_2[i])
fail()；
}
return 0；
}
产生检测实例的测试向量的自动例子
在运行的应用对于测试输入指令语义正确性已经充分的情况下，还需要有在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描述开始，
opcode acc op2＝0 CUST0
state accum 32
user_register 100 accum
iclass acc{acc}{in ars，in art}{inout accum}
reference acc{
assign accum＝accum+ars+art；
}
TIE编译程序产生如下关于TIE用户状态的信息以及使用它的指令的语义。
State accum mapped to user register：100，bits 31：0 opcode：acc，package：UserDefined，size：20， Register Operands： Name：as：input， regfile：AR，shortname：a，size：32 bits，entries：64 Name：at：input， regfile：AR，shortname：a，size：32 bits，entries：64
从上述信息中可以产生TIE指令acc的汇编代码。众所周知，该指令有两个寄存器操作数，都是AR类型，在此基础上可以进行一些随机的寄存器分配，或者更好地，既然输出和输入字节已知，可以进行一些智能的寄存器分配。因此可以自动地生成这个指令的汇编代码，如：
acc $a7，$a13
其中，a7和a13是由一有关AR的regfiIe的定义的寄存器分配算法产生的acc指令的s和t字段。更多的TIE指令的ISA描述的例子：
opcode：i128l，package：UserDefined，size：24，load Register Operands： Name：i128t：output， regfile：i128，shortname：i128，size：128 bits，entries：16 Name：as：input， regfile：AR，shortname：a，size：32 bits，entries：64 Immediate Operands： Name：offset128：bits 8，Table：[0 16 32 48....] opcode：wur0，package：UserDefined，size：24， Register Operands： Name：at：input， regfile：AR，shortname：a，size：32 bits，entries：64 opcode：i128s，package：UserDefined，size：24，store Register Operands： Name：i128t：input regfile：i128，shortname：i128，size：128 bits，entries：16 Name：as：input regfile：AR，shortname：a，size：32 bits，entries：64 Immediate Operands： Name：offset128：bits 8，shift 0，Table：[0 16 32....]
既然不可能得到有关指令的预期结果的足够信息，也就不可能检查TIE指令的正确性。例如，如果acc指令的结果在测试中是正确的，则就不可能检查。然而，如果硬件在状态累加器中产生了错误结果，这可以通过比较所有位于所有指令的边界的RTL和ISS之间的用户状态和寄存器文件的共同仿真结构而检查出(后面将详述)。下面的部分使用一些类似PERL的伪代码来解释算法。诊断程序生成器大部分是PERL程序。
用于产生正确的TIE指令的诊断生成器使用的算法如下：
subroutine gen_tie instr
{tie_opcode，address_reg，index_reg}
{
// address_reg is a core register
// containing a valid addressin case
// the TIE instruction does a load/store，
// same for the index register，if the
// load/store is a indexed load
<dp n="d71"/>
foreach operand(tie_inst-＞regoperands()){
fld＝operand-＞field()；
reg＝&register_allocate(tie_inst，operand)；
if((isLoad(tie_inst)||isStore(tie_inst))
&& operand-＞name()eq′as′){
override with valid address
reg＝address_reg；
}
if((isLoad(tie_inst)||isStore(tie_inst))
&& operand-＞name()eq ′at′){
reg＝index_reg；
}
push(operand_list，reg)；
}
foreach operand (tie_inst-＞immoperands()){
// specification of immediate operand
// as a table of values or a range
range＝operand-＞range()；
table＝operand-＞table()；
legal＝tie_inst-＞legals(operand-＞field()-＞name)；
if(legal){
imm＝legal[random index]；
}elsif(range){
imm＝random value between range.lo and range.hi；
}elsif(table){
imm＝table[random index]；
}
push{operand_list，imm)；
}
}
subroutine register_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[random index]；
}else{
register_num＝random(0，numentries-1)；
}
return concatenate(name，register_num)；
}
此外，在可以开始执行TIE指令之前，需要初始化TIE状态几寄存器文件。这是通过下面的方式完成的：
subroutine initTieState(address_reg，data_reg){
// Iterate over all state and get the vaue
// for each user register that
// the states are mapped to
states＝(tie-＞states()，
map($_-＞states()，tie-＞coprocessors()))；
foreach state(states){
UserRegMask{state-＞userReg}＝getMask；
}
foreach ureg(keys of the hashtable UserRegMask)
mask the data register with the mask value
do a WUR to the ureg
}
// Initialize register files by loading from a
// valid memory location
regfiles＝(tie-＞regfiles()，
map($_-＞regfiles()，tie-＞coprocessors())＞
foreach regf(regfiles){
for(i＝0；i＜regf-＞entries()；i++){
generate the load instruction or instruction sequence
using the addr_reg that has the valid address to load
index i of register file regf.
}
}
TIE的流水线信息
为了生成测试TIE中的测试旁路和互锁逻辑的微结构诊断程序，需要TIE指令的流水线信息。这提供了一个有关阶段的知识，在这个阶段TIE指令读和写寄存器和状态等这些资源。再一次，TIE编译程序提供这个信息，并且这个信息表达为PERL对象，且被验证工具所利用。下面的例子包含一用户定义的寄存器文件以及简单地在流水线的不同阶段移动数据的指令集，注意约定：1代表E阶段，2代表M阶段，3代表W阶段：
regfile i128 128 16 i128
operand i128s s {i128[s]}
operand i128t t {i128[t]}
operand i128r r {i128[r]}
opcode I128L r＝0 LSCI
opcode I128S r＝1 LSCI
opcode I128AND op2＝0 CUST0
schedule load{I128L}{
def i128t 2；
}
这转换为下面的PERL数据库中内容：
Regfile i128 width 128 entries 16 instructions： Writes： stage 2：Inst i128and：Field r stage 3：Inst i128l：Field t Reads： stage 1：Inst i128s：Field t Inst i128and：Field s Inst i128and：Field t
在下面的部分可以看出这个信息是如何用于生成诊断程序的。
TIE的微结构测试
本部分的目的是在TIE与核心的接口的实现知识以及TIE状态和寄存器文件基础上，生成TIE逻辑的微结构诊断程序。使用了ISA及TIE自身的流水线描述，然而，如上所述，TIE指令的实现的“正确性”不是在测试中直接验证的。
生成了一套MVP诊断程序用以测试下面的实现的各个特征。
—在核心和TIE接口中的控制逻辑；
—用户状态和寄存器文件的实现，包括装入/存储以及旁
路和互锁逻辑。
在核心和TIE之间的控制信号
测试异常，中断和中继信号的测试程序是这样生成的，即通过核心(如一分支)、异常和中继信号中的控制流的变化来删除每个用户指令。指令应该在其执行的所有阶段被删除，一直到完成阶段。
产生这些测试程序的算法就是将所有的TIE操作码在TIE编译程序产生的ISA描述中进行迭代，并构成了如下的实例：
情况a)被流的改变所删除的TIE指令：
foreach tie_opcode(tie_opcode_list)
branch instr(branch taken)
tie_opcode
end //foreach
情况b)被一个异常所删除的TIE指令
foreach tie_opcode(tie_opcode_list) for(stage＝0； stage＜completion stage of tie_opcode； stage++) syscall or break instr(that generates an exception) ＜stage＞number of nops tie_opcode end//for end//foreach
可以看出，产生异常的指令间无操作的数量以及TIE指令控制TIE控制执行的删除阶段。
情况c)在流水线中中继的TIE指令：
foreach tie_opcode(tie_opcode_list)
isync instr
tie opcode
end
用户状态和寄存器文件的旁路逻辑
这些测试程序将通过对读/写TIE状态和寄存器文件的指令进行“配对”检查其旁路逻辑。测试将保证没有因为取指令和数据导致的停止，然后(如果配置许)检查指令序列前后的周期计算寄存器，以寻找任何被视为错误的不必要的停止和标志。该算法如下：
生成对特定的寄存器文件或状态的所有读/写阶段一个[指令，字段]的列表。检查对于这个状态/寄存器文件的最大的完成阶段。对写和读指令进行配对，改变无操作的阶段的数值，直到最大的完成阶段。
foreach regf(tie-＞regfiles()){
// list of the stages at which regf is read
// possibly(1，2)
readstages＝getReadStages(regf)；，
// list of stages at which regf is written
// possibly(2，3)
writestages＝getDefStages(regf)；
foreach wstage(writestages){
writelist＝Generate list of[instr，field]pairs
that write regf in stage wstage
max_nops＝
maximum_completion_stage for regf-wstage；
foreach rstage(readstages){
readlist＝Generate list of[instr，field]
pairs that read regf in stage rstage
}
foreach write_instr(writelist){
foreach read_instr(readlist){
for(i＝0；i＜max_nops；i++){
stalls＝
(wstage-rstage-1)if(wstage＞rstage)else 0；
ccount_before＝read cycle count
write_instr
I-nops
read_instr
ccount_after＝read cycle count
if((ccount_after-ccount_before)
！＝(stalls+nops+3))
ERROR！！
}
}
}
}
需要通过执行这些指令序列两次，以保证没有I$和D$漏失。在第二次重复中，要检查周期计数。周期的预期值依赖于读/写的阶段和无操作阶段。上述例子的一些实例如下：
#(i128l field t stage 3)-＞(i128and Field s Stage 1)， #nops＝0，stall 1 cycles Test_11： <dp n="d76"/> rsr $a3，234＜--read cycle count before i128l $i1280，$a10，0 | -＞ | i128and $i1285，$i1280，$i12811 rsr $a4，234 ＜---cycle count after addi $a3，$a3，4 beq a4，a3，PASS_11 j FAIL PASS_11： #(i128and field r stage 2)-＞(i128and Field s Stage 1)， #nops＝0，stall 0 cycles， Test_12： rsr $a3，234 i128and $i1280，$i1288，$i1284 | -＞ | i128and $i1286，$i1280，$i1285 rsr $a4，234 addi $a3，$a3，3 beg a4，a3，PASS_12 jFAIL PASS_12： #(i128and field r stage 2)-＞(i128and Field s Stage 1)， #nops＝1，stall 0 cycles， Test_13： rsr$a3，234 i128and $i1280，$i1288，$i1284 nop.n i128and $i1286，$i1280，$i1285 rsr $a4，234 addi $a3，$a3，4 beg a4，a3，PASS_13 j FAIL PASS_13：
互锁和冒险
这个测试用于“写后读”、“写后写”和(可能有)“读后写”的冒险情况中的停止的正确性。
得出对于冒险情况的算法类似于得出上述旁路情况的算法。有两条在阶段2和3写同一文件的指令，且跟随着一条在阶段1读该文件的指令。第三条指令因第二个写的结果而停止。
#(Inst i128and r 2)-＞ #(Inst i128l t 3)-＞ #(Inst i128and s 1) Test_1： rsr $a3，234 i128and $i1280，$i1289，$i1281 i128l $i1280，$a5，0 i128and $i12815，$i1280，$i12813 rsr $a4，234 addi $a3，$a3，5 beq a4，a3，PASS_1 j FAIL PASS_1：
装入/存储
对所有寄存器文件的装入和存储是使用下面的算法对所有对准和未对准的地址进行全面地测试的。
foreach regf(tie-＞regfiles()){
PIFbytes＝PIFWidth＞＞3；// bytes
PIFwords＝PIFbytes＞＞2；// words(eg 4 for 128 bit)
regfw＝regf-＞size()＞＞5；
for(k＝0；k＜PIFbytes；k++){
load_address＝PIFWidth-aligned address+k；
store_address＝PIFWidth-aligned address+k；
* initialize memory
* store known data into load address
* store a default value to the store address
for(i＝0；i＜PIFwords；i++){
* store data word to load address+i
* store default word to store address+i
}
* do the load from load address
* do the store to store address
expected_result＝
expected_tie_load_result(load_address，data)；
for(i＝0；i＜PIFw；i++){
result＝load a word from store address+i
if(i＜regfw ){
check result＝＝expected_result
}else{
check result＝＝default_word
}
}
}
}
装入的预期的结果依赖于装入算法，尽管在大多数下它是可以确定的，但是不可能对所有可能的语义做到，在这些情况下需要将检查留给状态与存储器的比较。
对于配置支持数据断点的情况，也要对TIE装入/存储指令得数据断点进行测试。有关数据断点是如何对TIE指令起作用的细节见装入/存储结构部分。生成的诊断，对数据中断地址寄存器、控制掩码寄存起以及装入/存储的虚拟地址的所有可能的组合测试数据断点。
foreach regf(tie-＞regfiles()){
regfw＝regf-＞size()＞＞5；
write dbreak register with an address aligned to regfw
foreach mask(set of masks for regfw){
* write dbreak con trol mask
* set address regis ter based
on mask and dbreak address
* do a load/store to regf that
takes a da ta breakpoint exception
* check if exception was taken
end
end
匹配的数据断点将引起调试异常。上述测试的调试异常处理器将更新一个计数器，该计数器将被检查以验证异常真的发生了。此外，构建了更为复杂的情况，其中带有数据断点的读/写与溢出/下溢异常相符合(对于寄存器开窗口)以确保这些异常的优先权正确。
TIE指令的随机诊断生成器
随机诊断在核心ISA及执行的微结构的验证中起着主要作用。指令的随机序列可能碰到边界情况及其它不可能被直接测试覆盖的情况。为了设计验证，还将随机测试添加到了覆盖标准中。通过增加一些属性，已经向这些随机测试生成器增加了额外的智能。例如，可以为特定的目标情况创建指令序列模板。这样的一个例子可以是填满写缓存器的背对背存储，或具有单一指令的零开销环路。属于每个指令类型或指令序列的相对概率判断人们想要生成特定种类指令的频率，例如，如果一个分支指令具有高的相对概率(或权重)，生成的测试将具有更多的分支。用户控制的参数能够调整生成的测试的特性。例如，命令行自变量能够控制某个指令的相对权重，测试的长度，嵌套函数调用的次数等等。随机诊断生成器也能够生成用户定义的TIE指令。
下面的结构与微结构测试的结构类似。随机生成器读包括TIE指令及核心ISA的ISA描述。有效TIE指令通过检查特定TIE指令的ISA描述并使用一些寄存器分配结构而构成。
foreach operand(tie_instr-＞operands()){
if(operand is TIE register file){
do a random register allocation
random(0，#entries in register file)
}elsif(operand is a core register file){
if(this is a load/store instr){
this is the address register
for the load/store operation.
Find a core register that can be written，
and write a valid address
}else{
random core register
}
}elsif immediate field{
generate a random immediate value based on the
instruction′s immediate table or range
}
}
随机生成器优选情况下是不能够被配置系统的最终用户访问的，但是可用于内部验证以及用于象上述的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_port：mux：多路复用器的输出，
data：通往TIE的数据通路单元的触发器的输出
write_port：mux：一个多路复用器的输出
data：数据通路单元的输出
result：触发器的输出
stage_name：这表示流水线的阶段。
如前面的部分所述，这里约定：
C0：R阶段，C1：E阶段，C2：M阶段，C3：W阶段
为了简化的原因，下面的讨论限制所有的指令要在M阶段结束前写寄存器文件。
框图表示这些阶段的不同的旁路路径。对于被数据通路在阶段1和2读的读端口Rd0(这在前面的部分表现为寄存器文件的使用)，下面跟踪或解释框图：阶段C0：Rdo_mux_C0＝select from(
Wd_data_C2 ：由instr在流水线中最后产生的结果Wd_data_C1：由instr在流水线最后之前产生的结果Rd0_data_C0：在流水线中的当前数据
)阶段C1：Rd0_data_Cl<＝Rd0_mux_C0其中<＝表示在一个时钟周期之后
Rdo_mux_C1＝select from(Wd_data_C2：阶段C2：由inster在流水线的最后产生的结果Rd0_data_C1：前一阶段的结果)阶段C2Rd0_data_C2<＝Rd0_mux_Cl在阶段2和3被写的写端口Wd具有类似的旁路路径：阶段C2：Wd_result_C2<＝Wd_mux_C1＝Wd_data _C1(在E阶段的指令的输出是C1阶段的写端口的唯一源)Wd_mux_C2＝select from(Wd_result_c2Wd_data_C2：M阶段的当前instr的结果)阶段C3：
Wd_result_C3<＝Wd_mux_C2
Wd_result_C3被写入寄存器文件。
旁路路径的覆盖
本优选实施例的一个目的是，如果所有的上面框图中的旁路路径已经被检查了，生成一个检查用的监控器。在图13中用虚线描绘了一个旁路路径的例子。监控器通过路径跟踪数据，因此需要进行一个重要的假设，即在TIE的数据通路单元中的数据保持不变。这意味着能够执行下面的检查：
Wd_data_C1＝＝Rd0_data_C1
按照该假设，一个在E阶段(C1)读数据，而在E阶段输出数据的TIE指令保持数据不变。这对任何实际的TIE指令当然是不真实的。但是，为了测试，引入了一些用户TIE中的“恒等”指令(在生成真实的硬件时将消除)。这些指令，只用于测试，基本上是拷贝数据。在这个例子中，得到了两个恒等指令。
恒等1：use C1，def C1：读E阶段的寄存器文件，并在E阶段产生同样的数据；
恒等2：use C1，def C2：在一个周期延迟后产生数据。
已经描述了监控器生成的前提，现在描述生成在所有的旁路路径都被测试后进行测试的Vera模块的算法。再次，使用了由TIE编译程序产生的信息，并且上述信号名约定如下：
foreach regf(寄存器文件列表){
foreach writeport(regf的写端口){
foreach writestage(
阶段写端口列表被写){
foreach readport(regf的读端口){
foreach readstage(
阶段读端口列表被读){
skdp if writestage＜readstage
generate_the_signal_list(regf-＞name，
<dp n="d83"/>
writeport-＞name，writestage，
readport-＞name，readstage，
list_of_write_stages_for_writeport
}//读阶段
}//读端口
}//写阶段
}//写端口
}//regf
为了简化，生成信号列表的子程序的工作被省略了，但是对本领域的技术人员是显而易见的。重要的一点是要注意，在信号的列表中数据通路是如何表达的。如果数据通路的写阶段大于读阶段(如上面的Identity 2指令)，则就将消耗于数据通路单元的周期数(与本公开中我们对于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＝0
foreach state(FSM中的状态){
if(list中的最后状态){
*从新设状态
*设标志为1用于转换}else{
if(在这个状态的信号){如果表示进行到下一状态则生成}else{
进行到下一阶段}}}
为举示例的旁路路径生成的这个状态机为：
case(state)
{
<dp n="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；//waitcycles 1
}
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实现这个，以生成如在《VeraSystem Verifier by Synopsys，Inc.of Mountain View，CA》实现的Vera共同仿真语言的代码。
下面的部分包含共同仿真预处理器的例子，以及生成的共同仿真源代码。这些源代码与前面出现的伽罗瓦字段TIE的例子有关。
CosimInfo.pm
# -------------------------------------------------------- #
# CosimInfo.pm creates arrays which contains state and #
# register files information for TIE and the core. #
# -------------------------------------------------------- #
@CosimInfo：：EXPORT＝qw(
<dp n="d88"/>
@RegisterFiles
@SpecialRegister
@IntrType
@TieState
@TieRegister
@AllRegFiles
@AllSpecialRegs)；
# -------------------------------------------------------- #
# For a given configuration： #
# SpecialRegister contains all the core #
# special registers′names #
# Regis terFiles contains all the core #
# register files names #
# -------------------------------------------------------- #
@SpecialRegister＝map(CoreState($_，1)，
grep($_-＞name ne′MEM′，$isa-＞state))；
@RegisterFiles＝map(CoreState($，0)，
grep($_-＞name ne ′MEM′，$isa-＞state))；
# -------------------------------------------------------- #
# For a given tie description： #
# TieState contains all the TIE states names #
# TieRegister contains all the TIE register files names #
# -------------------------------------------------------- #
@TieState ＝map(TieState($_，1)，
$pr-＞tie()-＞allStates())；
@TieRegister＝map(TieState($_，0)，
$pr-＞tie()-＞allStates())；
@AllRegFiles＝(@RegisterFiles，@TieRegister)；
@AllSpecialRegs＝(@SpecialRegister，@TieState)；
# -------------------------------------------------------- #
# TieState subroutine reads the TIE state and register #
# information from the configuration data base. #
# -------------------------------------------------------- #
sub TieState{
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){
return if($regfile)；
[$name，$width＝＝1 ？1：$width，$undefonreset]；
}else{
return if(！$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％0d PC％h：\n\tRTL ！＝ISS TIE Reg
File `$tn` ％h ％h\n\n＂，current cycle，rtl spreg pc[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 ％0d PC ％h：\n\tRTL ！＝ISS TIE Reg
File gf0 ％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 ％0d PC ％h：\n\tRTL ！＝ISS TIE Reg
File gf15 ％h ％h\n\n＂，current_cycle，rtl_spreg_pc[index]，
rtl_gf0[index]，iss_gf15)；
共同仿真源代码(TIE状态比较)
；foreach(@TieState){
；($sreg)＝@$_；
// Checking Special Register `$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 ％0d PC ％h：\n\tRTL ！＝ISS at TIE
State`$sreg` ％0h ％0h\n\n＂，current_cycle，rtl_spreg_pc[index]，
rtl_spreg_`$sreg`[index]，iss_`$sreg`)；
}
；}
共同仿真源代码(TIE状态比较)
//Checking Special Register gfmod 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 ％0d PC ％h：\n\tRTL ！＝ISS at TIE State 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·Verification files | ·支持不需要写复杂的语义描述的指令的高效硬件执行 |
| ·寄存器操作数 | ·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·Verification files | ·在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 | ·将寄存器文件和状态分组为协处理器以支持延迟文本切换 |
上面说明的本发明与其中的一个优选实施例相关，然而这只是为了说明的目的，本发明并不局限于此。实际上，对本领域的技术人员来说，本发明的各种变型都是显而易见的，并且都在本发明的范围之内。附录A
README.gf
Notation：＜dir＞-path to this directory
This is a brief list of the files in this directory.
Miscellaneous：
README.gf this file
gf.tie a copy of the source tie file
default-params default param file to configure software
tools
gf-params param file to configure software tools for gf.tie
Native C Support：
cstub-gf.c functions for the new instructions
cstub-gf-ref.c functions generated from ＂reference＂
BR.h support for BR register file
Design Compiler Synthesis：
gf.v Verilog source file
gf_check.dcsh Syntax check generated verilog
gf.dcsh Top-level Design Compiler synthesis script
Xtensa_cons_generic.dc supporting script
Xtensa_prim.dc supporting script
TIE_opt.dc supporting script
xmTIE_cons.dc supporting script
prim.v supporting Verilog source file
Verysys Verification：
verysys subdirectory supporting Verysys verification
verysys/verify_sem.v Verilog source generated from semantics
verysys/verify_ref.v Verilog source generated from reference
Xtensa tool support：
libisa-gf.so dynamically linked library for xt-gcc
libiss-gf.so dynamically linked library for xt-run
xtensa-gf.h macro definitions of new instructions
Unknown：
gf_test.v
To compile your application in native mode：
- include cstub-gf.c in your application
- compile your application using your native c compiler (e.g.，gcc)
The new TIE instructions are replaced with equivalent C code.
If you define add ＂-DTIE_DEBUG＂ to the C compile，the function names
for
the translated TIE instructions will be prefixed with＂TIE_＂Using
this
method，you can check the TIE description against hand-written C
functions
for the new instructions. Refer for the application note for more
details.
To compile your application for Xtensa：
- add ＂--xtensa-params＝＜dir＞＂to the command line or add the
environment
<dp n="d95"/>
variable ′XTENSA_PARAMS＝＜dir＞；export XTENSA_PARAMS＂
- compile your application using xt-gcc
To estimate the impact of your TIE description on Xtensa speed：
- Setup your shell environment to run Synopsys Design Compiler
- Modify gf.dcsh to fill in your technology information
- Run dc_shell with script gf.dcsh，e.g.，
＂dc_shell -f gf.dcsh ＞& dc.out &＂
- Inspect the synthesis results. Look in report section of
the output file＂dc.out＂. If there is any timing violation，the
Xtensa
speed will be impacted，roughly by the violation amount.The areareport
section will give you the area of your tie instruction block.
To compare reference designs against semantic designs using Verysys：
- ＂cd＜dir＞/verysys；make＂
Notes for vl.5 user：
- cstub-gf.c can be included for xt-gcc compiles；it will be ignored
Note for vl.1 user：
- no need to regenerate this development kits from the Web.
- no need to include ＜machine/Customer.h＞ anymore
gf.tie
opcode GFADD8 op2＝4′b0000 CUST0
opcode GFMULX8 op2＝4′b0001 CUST0
opcode GFRWMOD8 op2＝4′b0010 CUST0
opcode GFADD8I op2＝4′b0100 CUST0
opcode LGF8.I r＝4′b0000 LSCI
opcode SGF8.I r＝4′b0001 LSCI
opcode LGF8.IU r＝4′b0010 LSCI
opcode SGF8.IU r＝4′b0011 LSCI
opcode LGF8.X op2＝4′b0000 LSCX
opcode SGF8.X op2＝4′b0001 LSCX
opcode LGF8.XU op2＝4′b0010 LSCX
opcode SGF8.XU op2＝4′b0011 LSCX
state gfmod 8
user_register 0{gfmod}
regfile gf 8 16 g
operand gr r{gf[r]}
operand gs s{gf[s]}
operand gt t{gf[t]}
operand imm4 t{t}{imm4}
interface VAddr 32 core out
interface LSSize 5 core out
interface MemDataIn8 8 core in
interface MemDataOut8 8 core out
iclass gfrrr{GFADD8}{out gr，in gs，in gt}{}{}
iclass gfrri{GFADD8I}{out gr，in gs，in imm4}{}{}
iclass gfrr{GFMULX8}{out gr，in gs}{in gfmod}{}
iclass gfr{GFRWMOD8}{inout gt}{inout gfmod}{}
<dp n="d96"/>
iclass gfloadi{LGF8.I}{out gt，in ars，in imm8}{}{
out LSSize，out VAddr，
in MemDataIn8 }
iclass gfstorei{SGF8.I}{in gt，in ars，in imm8}{}{
out LSSize，out VAddr，
out MemDataOut8}
iclass gfloadiu{LGF8.IU}{out gt，inout ars，in imm8}{}{
out LSSize，out VAddr，
in MemDataIn8}
iclass gfstoreiu{SGF8.IU}{in gt，inout ars，in imm8}{}{
out LSSize，out VAddr，
out MemDataOut8}
iclass gfloadx{LGF8.X}{out gr，in ars，in art}{}{
out LSSize，out VAddr，
in MemDataIn8}
iclass gfstorex{SGF8.X}{in gr，in ars，in art}{}{
out LSSize，out VAddr，
out MemDataOut8}
iclass gfloadxu{LGF8.XU}{out gr，inout ars，in art}{}{
out LSSize，out VAddr，
in MemDataIn8}
iclass gfstorexu{SGF8.XU}{in gr，inout ars，in art}{}{
out LSSize，out VAddr，
out MemDataOut8}
semantic gf1{GFADD8}{
assign gr＝gs^gt；
}
semantic gf4{GFADD8I}{
assign gr＝gs^imm4；
}
semantic gf2{GFMULX8}{
assign gr＝gs[7]？({gs[6：0]，1′b0}^gfmod)：{gs[6：0]，1′b0)；
}
semantic gf3{GFRWMOD8}{
wire[7：0]t1＝gt；
wire[7：0]t2＝gfmod；
assign gfmod＝t1；
assign gt＝t2；
}
semantic lgf{LGF8.I，LGF8.IU，LGF8.X，LGF8.XU}{
wire indexed＝LGF8.X|LGF8.XU；
assign LSSize＝1；
assign VAddr＝ars+(indexed？art ：imm8)；
assign gt＝MemDataIn8；
assign gr＝MemDataIn8；
assign ars＝VAddr；
}
semantic sgf{SGF8.I，SGF8.IU，SGF8.X，SGF8.XU}{
wire indexed＝SGF8.X|SGF8.XU；
assign LSSize＝1；
assign VAddr＝ars+(indexed？art：imm8)；
assign MemDataOut8＝SGF8.X|SGF8.XU？gr：gt；
assign ars＝VAddr；
}
reference GFADD8{
assign gr＝gs^gt；
}
reference GFADD8I{
assign gr＝gs^imm4；
<dp n="d97"/>
}
reference GFMULX8{
assign gr＝gs[7]？({gs[6：0]，1′b0}^gfmod)：{gs[6：0]，1′b0}；
}
reference GFRWMOD8{
wire[7：0]t1＝gt；
wire[7：0]t2＝gfmod；
assign gfmod＝t1；
assign gt＝t2；
}
reference LGF8.I{
assign LSSize＝1；
assign VAddr＝ars+imm8；
assign gt＝MemDataIn8；
}
reference LGF8.IU{
assign LSSize＝1；
assign VAddr＝ars+imm8；
assign gt＝MemDataIn8；
assign ars＝VAddr；
}
reference LGF8.X{
assign LSSize＝1；
assign VAddr＝ars+art；
assign gr＝MemDataIn8；
assign ars＝VAddr；
}
reference LGF8.XU{
assign LSSize＝1；
assign VAddr＝ars+art；
assign gr＝MemDataIn8；
assign ars＝VAddr；
}
reference SGF8.I{
assign LSSize＝1；
assign VAddr＝ars+imm8；
assign MemDataOut8＝gt；
}
reference SGF8.IU{
assign LSSize＝1；
assign VAddr＝ars+imm8；
assign MemDataOut8＝gt；
assign ars＝VAddr；
}
reference SGF8.X{
assign LSSize＝1；
assign VAddr＝ars+art；
assign MemDataOut8＝gr；
}
reference SGF8.XU{
assign LSSize＝1；
assign VAddr＝ars+art；
assign MemDataOut8＝gr；
assign ars＝VAddr；
}
ctype gf8 8 8 gf
proto gf8_loadi{out gf8 t，in gf8* s，in immediate o}{}{
LGF8.I t，s，o；
}
<dp n="d98"/>
proto gf8_storei{in gf8 t，in gf8* s，in immediate o}{}{
SGF8.I t，s，o；
}
proto gf8_move{in gf8 r，in gf8 s}{}{
GFADD8 r，s，0；
}
schedule gfload{LGF8.I}
{
use imm8 0；
use ars 1；
def gt 2；
}
schedule gfloadu{LGF8.IU}
{
use imm8 0；
use ars 1；
def ars 1；
def gt 2；
}
schedule gfloadx{LGF8.X}
{
use ars 1；
use art 1；
def gr 2；
}
schedule gfloadxu{LGF8.XU}
{
use ars 1；
use art 1；
def art 1；
def gr 2；
}
synopsis GFADD8＂Galois Field 8-bit Add＂
synopsis GFADD8I＂Galois Field 8-bit Add Immediate＂
synopsis GFMUIX8＂Galois Field 8-bit Multiply by X＂
synopsis GFRWMOD8＂Read/Write Galois Field Polynomial＂
synopsis LGF8.I＂Load Galois Field Register Immediate＂
synopsis LGF8.IU＂Load Galois Field Register Immediate Update＂
synopsis LGF8.X＂Load Galois Field Register Indexed＂
synopsis LGF8.XU＂Load Galois Field Register Indexed Update＂
synopsis SGF8.I＂Store Galois Field Register Immediate＂
synopsis SGF8.IU＂Store Galois Field Register Immediate Update＂
synopsis SGF8.X＂Store Galois Field Register Indexed＂
synopsis SGF8.XU＂Store Galois Field Register Indexed Update＂
description GFADD8
＂＜P＞＜CODE＞GFADD8＜/CODE＞ performs a 8-bit Galois Field addition of the
contents of GF registers ＜CODE＞gs＜/CODE＞and＜CODE＞gt＜/CODE＞and
writes the result to GF register＜CODE＞gr＜/CODE＞.＜/P＞＂
description GFADD8I
＂＜P＞＜CODE＞GFADD8I＜/CODE＞performs a 8-bit Galois Field addition of the
contents of GF register＜CODE＞gs＜/CODE＞and a 4-bit immediate from
the＜CODE＞t＜/CODE＞field and writes the result to GF register
＜CODE＞gr＜/CODE＞.＜/P＞＂
<dp n="d99"/>
description GFMULX8
＂＜P＞＜CODE＞GFMULX8＜/CODE＞ performs a 8-bit Galois Field multiplication
of the contents of GF register ＜CODE＞gs＜/CODE＞by＜I＞x＜/I＞modulo
the polynomial in＜CODE＞gfmod＜/CODE＞.It writes the result to GF register
＜CODE＞gr＜/CODE＞.＜/P＞＂
description GFRWMOD
＂＜P＞＜CODE＞GFRWMOD＜/CODE＞reads and writes the＜CODE＞gfmod＜/CODE＞
polynomial register.GF register＜CODE＞gt＜/CODE＞and＜CODE＞gfmod＜/CODE＞
are read these are written to＜CODE＞gfmod＜/CODE＞and＜CODE＞gt＜/CODE＞.＜/P＞＂
description LGF8.I
＂＜P＞
＜/P＞＂
description LGF8.IU
＂＜P＞
＜/P＞＂
description LGF8.X
＂＜P＞
＜/P＞＂
description LGF8.XU
＂＜P＞
＜/P＞＂
description SGF8.I
＂＜P＞
＜/P＞＂
description SGF8.IU
＂＜P＞
＜/P＞＂
description SGF8.X
＂＜P＞
＜/P＞＂
description SGF8.XU
＂＜P＞
＜/P＞＂
default-params
isa-tie-dll＝lib-i686-Linux/libisa-gf.so
iss-tie-dll＝lib-i686-Linux/libiss-gf.so
cc-tie-dll＝lib-i686-Linux/libcc-gf.so
xtensa-tie-header＝xtensa-gf.h
gf-params
isa-tie-dll＝lib-i686-Linux/libisa-gf.so
iss-tie-dll＝lib-i686-Linux/libiss-gf.so
cc-tie-dll＝lib-i686-Linux/libcc-gf.so
xtensa-tie-header＝xtensa-gf.h
<dp n="d100"/>
cstub-gf.c
#ifndef_XTENSA_
#ifdef TIE_DEBUG
#define gf8_loadi TIE_gf8_loadi
#define gf8_storei TIE_gf8_storei
#define gf8_move TIE_gf8_move
#define GFADD8 TIE_GFADD8
#define GFADD8I TIE_GFADD8I
#define GFMULX8 TIE_GFMULX8
#define GFRWMOD8 TIE_GFRWMOD8
#define LGF8_I TIE_LGF8_I
#define SGF8_I TIE_SGF8_I
#define LGF8_IU TIE_LGF8_IU
#define SGF8_IU TIE_SGF8_IU
#define LGF8_X TIE_LGF8_X
#define SGF8_X TIE_SGF8_X
#define LGF8_XU TIE_LGF8_XU
#define SGF8_XU TIE_SGF8_XU
#define RUR0 TIE_RUR0
#define WUR0 TIE_WUR0
#endif
#include ＜stdio.h＞
#define LittleEndian 0
#define BigEndian 1
#define PIFReadDataBits 128
#define PIFWriteDataBits 128
#define IsaMemoryOrder LittleEndian
#include ＂BR.h＂
#include ＂LS.h＂
#define BPW 32
#define WINDEX(_n)((_n)/BPW)
#define BINDEX(_n)((_n)％BPW)
typedef unsigned char Vb_t；
typedef unsigned short Vs_t；
typedef struct V1_s{unsigned data[1]；}V1_t；
typedef struct V2_s{unsigned data[2]；}V2_t；
typedef struct V4_s{unsigned data[4]；}V4_t；
typedef Vb_t gf8；
static int tie_load_instruction＝0；
void
TieMemRead(unsigned *data，unsigned addr)
{
unsigned char *mem；
unsigned modulus，bytes，offset；
intt，b0，b1，b2，b3；
bytes＝PIFReadDataBits / 8；
modulus＝bytes-1；
mem＝(unsigned char *)(addr &-modulus)；
offset＝(unsigned char*)addr-mem；
if(IsaMemoryOrder＝＝LittleEndian){
<dp n="d101"/>
for(t＝0；t＜bytes/sizeof(int)；t++){
b0＝mem[(offset++) & modulus]；
b1＝mem[(offset++) & modulus]；
b2＝mem[(offset++) & modulus]；
b3＝mem[(offset++) & modulus]；
data[t]＝(b3＜＜24)|(b2＜＜16)|(b1＜＜8)|b0；
}
}else{
for(t＝bytes/sizeof(int)-1；t＞＝0；t--){
b3＝mem[(offset++) & modulus]；
b2＝mem[(offset++) & modulus]；
b1＝mem[(offset++) & modulus]；
b0＝mem[(offset++) & modulus]；
data[t]＝(b3＜＜24)|(b2＜＜16)|(b1＜＜8)|b0；
}
}
}
void
TieMemWrite(unsigned addr，unsigned bytes，unsigned *data)
{
unsigned char *mem；
unsigned modulus，offset，w；
int t；
if(PIFWriteDataBits＜bytes * 8){
fprintf(stderr，＂Error：not configured to write ％d bytes\n＂，
bytes)；
exit(1)；
}
modulus＝bytes-1；
mem＝(unsigned char *)(addr & -modulus)；
if(IsaMemoryOrder＝＝LittleEndian){
if(bytes＝＝1){
mem[0]＝data[0] & 0xff；
}else if(bytes＝＝2){
mem[0]＝data[0] & 0xff；
mem[1]＝(data[0]＞＞8) & 0xff；
}else{
offset＝0；
for(t＝0；t＜bytes/sizeof(int)；t++){
w＝data[t]；
mem[offset++]＝w & 255；
mem[offset++]＝(w＞＞8) & 255；
mem[offset++]＝(w＞＞16) & 255；
mem[offset++]＝(w＞＞24) & 255；
}
}
}else{
if(bytes＝＝1){
mem[0]＝data[0] & 0xff；
}else if(bytes＝＝2){
mem[1]＝data[0] & 0xff；
mem[0]＝(data[0]＞＞8) & 0xff；
}else{
offset＝0；
for(t＝bytes/sizeof(int)-1；t＞＝0；t--){
w＝data[t]；
<dp n="d102"/>
mem[offset++]＝(w＞＞24) & 255；
mem[offset++]＝(w＞＞16) & 255；
mem[offset++]＝(w＞＞8) & 255；
mem[offset++]＝w & 255；
}
}
}
}
#define GetState(_s，_n)_s＝_n
#define SetState(_n，_s)_n＝_s
V1_t STATE_gfmod；
V1_t VAddr＝{{0}}；
V1_t VAddrBase＝{{0}}；
V1_t VAddrOffset＝{{0}}；
V1_t VAddrIndex＝{{0}}；
V1_t VAddrIn＝{{0}}；
V1_t Lssize＝{{0}}；
V1_t LSIndexed＝{{0}}；
V4_t MemDataIn128＝{{0，0，0，0}}；
V2_t MemDataIn64＝{{0，0}}；
V1_t MemDstaIn32＝{{0}}；
V1_t MemDataIn16＝{{0}}；
V1_t MemDataIn8＝{{0}}；
V4_t MemDataOut128＝{{0，0，0，0}}；
V2_t MemDataOut64＝{{0，0}}；
V1_t MemDataOut32＝{{0}}；
V1_t MemDataOut16＝{{0}}；
V1_t MemDataOut8＝{{0}}；
V1_t Exception＝{{0}}；
V1_t ExcCause＝{{0}}；
V1_t CPEnable＝{{0}}；
void
VAddrIn_get(void)
{
if(LSIndexed.data[0] ！＝0){
VAddrIn.data[0]＝VAddrBase.data[0]+VAddrIndex.data[0]；
}else{
VAddrIn.data[0]＝VAddrBase.data[0]+VAddrOffset.data[0]；
}
}
void
MemDataIn128_get(void)
{
unsigned data[4]；
if((！tie_load_instruction)||(LSSize.data[0] ！＝16)){
return；
}
if(PIFReadDataBits＜128){
fprintf(stderr，＂Error：not configured to read 16 bytes\n＂)；
exit(-1)；
}
<dp n="d103"/>
VAddrIn_get()；
TieMemRead(&data[0]，VAddrIn.data[0])；
MemDataIn128.data[0]＝data[0]；
MemDataIn128.data[1]＝data[1]；
MemDataIn128.data[2]＝data[2]；
MemDataIn128.data[3]＝data[3]；
}
void
MemDataIn64_get(void)
{
unsigned data[4]；
if((！tie_load_instruction)||(LSSize.data[0]！＝8)){
return；
}
if(PIFReadDataBits＜64){
fprintf(stderr，＂Error：not configured to read 8 bytes\n＂)；
exit(-1)；
}
VAddrIn_get()；
TieMemRead(&data[0]，VAddrIn. data[0])；
if(IsaMemoryOrder＝＝LittleEndian){
MemDataIn64.data[0]＝data[0]；
MemDataIn64.data[1]＝data[1]；
}else if(PIFReadDataBits＝＝64){
MemDataIn64.data[0]＝data[0]；
MemDataIn64.data[1]＝data[1]；
}else{
MemDataIn64.data[0]＝data[2]；
MemDataIn64.data[1]＝data[3]；
}
}
void
MemDataIn32_get(void)
{
unsigned data[4]；
if((！tie_load_instruction)||(LSSize.data[0]！＝4)){
return；
}
if(PIFReadDataBits＜32){
fprintf(stderr，＂Error：not configured to read 4 bytes\n＂)；
exit(-1)；
}
VAddrIn_get()；
TieMemRead(&data[0]，VAddrIn.data[0])；
if(IsaMemoryOrder＝＝LittleEndian){
MemDataIn32.data [0]＝data[0]；
}else if(PIFReadDataBits＝＝32){
MemDataIn32.data[0]＝data[0]；
}else if(PIFReadDataBits＝＝64){
MemDataIn32.data[0]＝data[1]；
<dp n="d104"/>
}else{
MemDataIn32.data[0]＝data[3]；
}
}
void
MemDataIn16_get(void)
{
unsigned data[4]；
if((！tie_load_instruction)||(LSSize.data[0]！＝2)){
return；
}
if(PIFReadDataBits＜16){
fprintf(stderr，＂Error：not configured to read 2 bytes\n＂)；
exit(-1)；
}
VAddrIn_get()；
TieMemRead(&data[0]，VAddrIn.data[0])；
if(IsaMemoryOrder＝＝LittleEndian){
MemDataIn16.data[0]＝data[0] & 0xffff；
}else if(PIFReadDataBits＝＝32){
MemDataIn16.data[0]＝data[0]＞＞16；
}else if(PIFReadDataBits＝＝64){
MemDataIn16.data[0]＝data[1]＞＞16；
}else{
MemDataIn16.data[0]＝data[3]＞＞16；
}
}
void
MemDataIn8_get(void)
{
unsigned data[4]；
if((！tie_load_instruction)||(LSSize.data[0]！＝1)){
return；
}
if(PIFReadDataBits＜8){
fprintf(stderr，＂Error：not configured to read 1 byte\n＂)；
exit(-1)；
}
VAddrIn_get()；
TieMemRead(&data[0]，VAddrIn.data[0])；
if(IsaMemoryOrder＝＝LittleEndian){
MemDataIn8.data[0]＝data[0] & 0xff；
} else if(PIFReadDataBits＝＝32){
MemDataIn8.data[0]＝data[0]＞＞24；
} else if(PIFReadDataBits＝＝64){
MemDataIn8.data[0]＝data[1]＞＞24；
} else{
MemDataIn8.data[0]＝data[3]＞＞24；
}
}
<dp n="d105"/>
void
MemDataOut128_set(void)
{
if(LSSize.data[0]！＝16){
return；
}
VAddrIn_get()；
TieMemWrite(VAddrIn.data[0]&-0xf，16，&MemDataOut128.data[0])；
}
void
MemDataOut64_set(void)
{
if(LSSize.data[0]！＝8){
return；
}
VAddrIn_get()；
TieMemWrite(VAddrIn.data[0] & -0x7，8，&MemDataOut64.data[0])；
}
void
MemDataOut32 set(void)
{
if(LSSize.data[0] ！＝4){
return；
}
VAddrIn_get()；
TieMemWrite(VAddrIn.data[0] &-0x3，4，&MemDataOut32.data[0]
}
void
MemDataOut16_set(void)
{
if(LSSize.data[0] ！＝2){
return；
}
VAddrIn_get()；
TieMemWrite(VAddrIn.data[0] & -0x1，2，&MemDataOut16.data[0]
}
void
MemDataOut8_set(void)
{
if(LSSize.data[0] ！＝1){
return；
}
VAddrIn_get()；
TieMemWrite(VAddrIn.data[0]，1，&MemDataOut8.data[0])；
}
<dp n="d106"/>
void
Exception_set(void)
{
/* Exception handling is not supported in native mode */
}
void
CPEnable_get(void)
{
CPEnable.data[0]＝0xff；/* always enabled in native C mode */
}
#define RUR(n)({\
int v；\
switch(n){\
case 0：\
v＝RUR0()；break；\
default：\
fprintf(stderr，＂Error：invalid rur number ％d\n＂，n)；\
exit(-1)；\
}\
v；\
})
#define WUR(v，n)\
switch (n){\
case 0：\
WUR0(v)；break；\
default：\
fprintf(stderr，＂Error：invalid wur number ％d\n＂，n)；\
exit(-1)；\
}
gf8
GFADD8(gf8 gs_，gf8 gt_)
{
/* operand variables */
V1_t gr_o；
V1_t gs_i；
V1_t gt_i；
/* unused operand variables */
/* operand kill variables */
V1_t gr_kill_o＝{{0}}；
/* one-hot instruction signals */
V1_t GFADD8＝{{1}}；
/* state variables */
/* local wire variables */
/* initialize in/inout operands */
gs_i.data[0]＝gs_；
gt_i.data[0]＝gt_；
tie_load_instruction＝0；
/* semantic statements */
gr_o.data[0]＝(gs_i.data[0]^gt_i.data[0]) & 0xff；
gr_kill_o.data[0]＝(0 & GFADD8.data[0]) & 0x1；
/* write-back inout operands */
/* return the output operand */
return gr_o.data [0]；
<dp n="d107"/>
}
gf8
GFADD8I(gf8 gs_，nt imm4_)
{
/* operand variables */
V1_t gr_o；
V1_t gs_i；
V1_t imm4；
/* unused operand variables */
/* operand kill variables */
V1_t gr_kill_o＝{{0}}；
/* one-hot instruction signals */
V1_t GFADD8I＝{{1}}；
/* state variables */
/* local wire variables */
/* initialize in/inout operands */
gs_i.data[0]＝gs_；
imm4.data[0]＝imm4_；
tie_load_instruction＝0；
/* semantic statements */
gr_o.data[0]＝(gs_i.data[0]^imm4.data[0]) & 0xff；
gr_kill_o.data[0]＝(0 & GFADD8I.data[0]) & 0x1；
/* write-back inout operands */
/* return the output operand */
return gr_o.data[0]；
}
gf8
GFMULX8(gf8 gs_)
{
/* operand variables */
V1_t gr_o；
V1_t gs_i；
/*unused operand variables */
/* operand kill variables */
V1_t gr_kill_o＝{{0}}；
/* one-hot instruction signals */
V1_t GFMULX8＝{{1}}；
/* state variables */
V1_t gfmod_ps；
/* local wirevariables */
V1_t tmp5；
V1_t tmp4；
V1_t tmp3；
V1_t tmp2；
V1_t tmp1；
V1_t tmp0；
/*get input state values */
GetState(gfmod_ps，STATE_gfmod)；
/* initialize in/inout operands */
gs_i.data[0] ＝ gs_；
tie load instruction ＝ 0；
/* semantic statements */
tmp0.data[0]＝(((gs_i.data[0]＜＜24)＞＞31)) & 0x1；
tmp1.data[0]＝((gs_i.data[0]&0x7f)) & 0x7f；
tmp2.data[0]＝((tmp1.data[0]＜＜1)|0} & 0xff；
tmp3.data[0]＝(tmp2 .data[0]^gfmod_ps.data[0]) & 0xff；
tmp4.data[0]＝((gs_i.data[0]&0x7f)) & 0x7f；
tmp5.data[0]＝((tmp4.data[0]＜＜1)|0) & 0xff；
<dp n="d108"/>
gr_o.data[0]＝((tmp0.data[0])？tmp3.data[0]：tmp5.data[0]) & 0xff；
gr_kill_o.data[0]＝(0&GFMULX8.data[0]) & 0x1；
/* write-back inout operands */
/* return the output operand */
return gr_o.data[0]；
#define GFRWMOD8(gt)\
GFRWMOD8_func(&(gt))
void
GFRWMOD8_func(gf8 *gt_)
{
/* operand variables */
V1_t gt_o；
V1_t gt_i；
/* unused operand variables */
/* operand kill variables */
V1_t gt_kill_o＝{{0}}；
/* one-hot instruction signals */
V1_t GFRWMOD8＝{{1}}；
/* state variables */
V1_t gfmod_ps；
V1_t gfmod_ns；
V1_t gfmod_kill_ns；
/* local wire variables */
V1_t t1；
V1_t t2；
/* get input state values */
GetState(gfmod_ps，STATE_gfmod)；
/* initialize in/inout operands */
gt_i.data[0]＝*gt_；
tie_load instruction＝0；
/* semantic statements */
ti.data[0]＝gt_i.data[0] & 0xff；
t2.data[0]＝gfmod_ps.data[0] & 0xff；
gfmod_ns.data[0]＝t1.data[0] & 0xff；
gt_o.data[0]＝t2.data[0] & 0xff；
gfmod_kill_ns.data[0]＝(0 & GFRWMOD8.data[0]) & 0x1；
gt_kill_o.data[0]＝(0 & GFRWMOD8.data[0]) & 0x1；
/* write-back inout operands */
if(！gt_kill_o.data[0]) *gt_＝gt_o.data[0]；
/* update out/inout states */
if(！gfmod_kill_ns.data[0])SetState(STATE_gfmod，gfmod_ns)；
}
gf8
LGF8_I(unsigned ars_，int imm8_)
{
/* operand variables */
V1_t gt_o；
V1_t ars_i；
V1_t imm8；
/* unused operand variables */
V1_t ars_o；
V1_t gr_o；
V1_t art_i＝{{0}}；
/* operand kill variables */
V1_t gt_kill_o＝{{0}}；
V1_t ars_kill_o＝{{0}}；
<dp n="d109"/>
V1_t gr_kill_o＝{{0}}；
/* one-hot instruction signals */
V1_t LGF8_I＝{{1}}；
V1_t LGF8_IU＝{{0}}；
V1_t LGF8_X＝{{0}}；
v1_t LGF8_U＝{{0}}；
/* state variables */
/* local wire variables */
V1_t tmp2；
V1_t tmp1；
V1_t tmp0；
V1_t indexed；
/* initialize in/inout operands */
ars_i＝*((V1_t *) &ars_)；
imm8.data[0]＝imm8_；
tie_load_instruction＝1；
/* semitic statements */
indexed.data[0]＝(LGF8_X.data[0] | LGF8_XU.data[0]) & 0x1；
LSSize.data[0]＝0x1 & 0x1f；
VAddrBase.data[0]＝ars_i.data[0]；
LSIndexed.data[0]＝indexed.data[0] & 0x1；
VAddrOffset.data[0]＝imm8.data[0]；
VAddrIndex.data[0]＝art_i.data[0]；
MemDataIn8_get()；
gt_o.data[0]＝MemDataIn8.data[0] & 0xff；
MemDataIn8_get()；
gr_o.data[0]＝MemDataIn8.data[0] & 0xff；
VAddrIn_get()；
ars_o.data[0]＝VAddrIn.data[0]；
tmp0.data[0]＝(LGF8_I.data[0] | LGF8_IU.data[0]) & 0x1；
gt_kill_o.data[0]＝(0 & tmp0.data[0]) & 0x1；
tmp1.data[0]＝(LGF8_IU.data[0] | LGF8_XU.data[0]) & 0x1；
ars_kill_o.data[0]＝(0 & tmp1.data[0]) & 0x1；
tmp2.data[0]＝(LGF8_X.data[0] | LGF8_XU.data[0]) & 0x1；
gr_kill_o.data[0]＝(0 & tmp2.data[0]) & 0x1；
/* write-back inout operands */
/* update output interface signals */
/* return the output operand */
return gt_o.data[0]；
}
#define LGF8_IU(ars，imm8)\
LGF8 IU func(&(ars)，imm8)
gf8
LGF8_IU_func(unsigned *ars_，int imm8_)
{
/* operand variables */
V1_t gt_o；
V1_t ars_o；
V1_t ars_i；
V1_t imm8；
/* unused operand variables */
V1_t gr_o；
V1_t art_i＝{{0}}；
/* operand kill variables */
V1_t gt_kill_o＝{{0}}；
V1_t ars_kill_o＝{{0}}；
V1_t gr_kill_o＝{{0}}；
/* one-hot instruction signals */
<dp n="d110"/>
V1_t LGF8_I＝{{0}}；
V1_t LGF8_IU＝{{1}}；
V1_t LGF8_X＝{{0}}；
V1_t LGF8_XU＝{{0}}；
/* state variablles */
/* local wire variables */
V1_t tmp2；
V1_t tmp1；
V1_t tmp0；
V1_t indexed；
/* initialize in/inout operands */
ars_i＝ *((V1_t *)ars_)；
imm8.data[0]＝imm8_；
tie_load_instruction＝1；
/* semantic statements */
indexed.data[0]＝(LGF8_X.data[0] | LGF8_XU.data[0]) & 0x1；
LSSize.data[0]＝ 0x1 & 0x1f；
VAddrBase.data[0]＝ars_i.data[0]；
LSIndexed.data[0]＝indexed.data[0] & 0x1；
VAddrOffset.data[0]＝imm8.data[0]；
VAddrIndex.data[0]＝art_i.data[0]；
MemDataIn8_get()；
gt_o.data[0]＝MemDataIn8.data[0] & 0xff；
MemDataIn8_get()；
gr_o.data[0]＝MemDataIn8.data[0] & 0xff；
VAddrIn_get()；
ars_o.data[0]＝VAddrIn.data[0]；
tmp0.data[0]＝(LGF8_I.data[0] | LGF8_IU.data[0]) & 0x1；
gt_kill_o.data[0]＝(0 & tmp0.data[0]) & 0x1；
tmpl.data[0]＝(LGF8_IU.data[0] | LGF8_XU.data[0]) & 0x1；
ars_kill_o.data[0]＝(0 & tmp1.data[0]) & 0x1；
tmp2.data[0]＝(LGF8_X.data[0] | LGF8_XU.data[0]) & 0x1；
gr_kill_o.data[0]＝(0 & tmp2.data[0]) & 0x1；
/* write-back inout operands */
if(！ars_kill_o.data[0]) *ars_＝ *((unsigned *)&ars_o)；
/* update output interface signals */
/* return the output operand */
return gt_o.data[0]；
}
gf8
LGF8_X(unsigned ars_，unsigned art_)
{
/* operand variables */
V1_t gr_o；
V1_t ars_i；
V1_t art_i；
/* unused operand variables */
V1_t gt_o；
V1_t ars_o；
V1_t imm8＝{{0}}；
/* operand kill variables */
V1_t gt_kill_o＝{{0}}；
V1_t ars_kill_o＝{{0}}；
V1_t gr_kill_o＝{{0}}；
/*one-hotinstruction signals */
V1_t LGF8_I＝{{0}}；
V1_t LGF8_IU＝{{0}}；
V1_t LGF8_X＝{{1}}；
V1_t LGF8_XU＝{{0}}；
<dp n="d111"/>
/* state variables */
/* local wire variables */
V1_t tmp2；
V1_t tmp1；
V1_t tmp0；
V1_t indexed；
/* initialize in/inout operands */
ars_i＝*((V1_t*) &ars_)；
art_i＝*((V1_t*) &art_)；
tie_load instruction＝1；
/* semantic statements */
indexed.data[0]＝(LGF8_X.data[0] | LGF8_XU.data[0]) & 0x1；
LSSize.data[0]＝0x1 & 0x1f；
VAddrBase.data[0]＝ars_i.data[0]；
LSIndexed.data[0]＝indexed.data[0] & 0x1；
VAddrOffset.data[0]＝imm8.data[0]；
VAddrIndex.data[0]＝art_i.data[0]；
MemDataIn8_get()；
gt_o.data[0]＝MemDataIn8.data[0] & 0xff；
MemDataIn8_get()；
gr_o.data[0]＝MemDataIn8.data[0] & 0xff；
VAddrIn_get()；
ars_o.data[0]＝VAddrIn.data[0]；
tmp0.data[0]＝(LGF8_I.data[0] | LGF8_IU.data[0]) & 0x1；
gt_kill_o.data[0]＝(0 & tmp0.data[0]) & 0x1；
tmp1.data[0]＝(LGF8_IU.data[0] | LGF8_XU.data[0]) & 0x1；
ars_kill_o.data[0]＝(0 & tmp1.data[0]) & 0x1；
tmp2.data[0]＝(LGF8_X.data[0] | LGF8_XU.data[0]) & 0x1；
gr_kill_o.data[0]＝(0 & tmp2.data[0]) & 0x1；
/* write-back inout operands */
/* update output interface signals */
/* return the output operand */
return gr_o.data[0]；
}
#define LGF8_XU(ars，art)\
LGF8_XU_func(&(ars)，art)
gf8
LGF8_XU_func(unsigned *ars_，unsigned art_)
{
/* operand variables */
V1_t gr_o；
V1_t ars_o；
V1_t ars_i；
V1_t art_i；
/* unused operand variables */
V1_t gt_o；
V1_t imm8＝{{0}}；
/* operand kill variables */
V1_t gt_kill_o＝{{0}}；
V1_t ars_kill_o＝{{0}}；
V1_t gr_kill_o＝{{0}}；
/* one-hot instruction signals */
V1_t LGF8_I＝{{0}}；
V1_t LGF8_IU＝{{0}}；
V1_t LGF8_X＝{{0}}；
V1_t LGF8_XU＝{{1}}；
/* state variables */
/* local wire variables */
<dp n="d112"/>
V1_t tmp2；
V1_t tmp1；
V1_t tmp0；
V1_t indexed；
/* initialize in/inout operands */
ars_i＝*((V1_t*) ars_)；
art_i＝*((V1_t*) &art_)；
tie_load_instruction＝1；
/* semantic statements */
indexed.data[0]＝(LGF8_X.data[0]|LGF8_XU.data[0]) & 0x1；
LSSize.data[0]＝0x1 & 0x1f；
VAddrBase.data[0]＝ars_i.data[0]；
LSIndexed.data[0]＝indexed.data[0] & 0x1；
VAddrOffset.data[0]＝imm8.data[0]；
VAddrIndex.data[0]＝art_i.data[0]；
MemDataIn8_get()；
gt_o.data[0]＝MemDataIn8.data[0] & 0xff；
MemDataIn8_get()；
gr_o.data[0]＝MemDataIn8.data[0] & 0xff；
VAddrIn_get()；
ars_o.data[0]＝VAddrIn.data[0]；
tmp0.data[0]＝(LGF8_I.data[0] | LGF8_IU.data[0]) & 0x1；
gt_kill_o.data[0]＝(0 & tmp0.data[0]) & 0x1；
tmp1.data[0]＝(LGF8_IU.data[0] | LGF8_XU.data[0]) & 0x1；
ars_kill_o.data[0]＝(0 & tmp1.data[0]) & 0x1；
tmp2.data[0]＝(LGF8_X.data[0] | LGF8_XU.data[0]) & 0x1；
gr_kill_o.data[0]＝(0 & tmp2.data[0]) & 0x1；
/* write-back inout operands */
if(！ars_kill_o.data[0]) *ars_＝*((unsigned*) &ars_o)；
/* update output interface signals */
/* return the output operand */
return gr_o.data[0]；
}
void
SGF8_I(gf8 gt_，unsigned ars_，int imm8_).
{
/* operand variables */
V1_t gt_i；
V1_t ars_i；
V1_t imm8；
/* unused operand variables */
V1_t ars_o；
V1_t gr_i＝{{0}}；
V1_t art_i＝{{0}}；
/* operand kill variables */
V1_t ars_kill_o＝{{0}}；
/* one-hot instruction signals */
V1_t SGF8_IU＝{{0}}；
V1_t SGF8_X＝{{0}}；
V1_t SGF8_XU＝{{0}}；
/* state variables */
/* local wire variables */
V1_t tmp1；
V1_t tmp0；
V1_t indexed；
/* initialize in/inout operands */
gt_i.data[0]＝gt_；
ars_i＝*((V1_t*) &ars_)；
imm8.data[0]＝imm8_；
<dp n="d113"/>
tie_load_instruction＝0；
/* semantic statements */
indexed.data[0]＝(SGF8_X.data[0]|SGF8_XU.data[0]) & 0x1；
LSSize.data[0]＝0x1 & 0x1f；
VAddrBase.data[0]＝ars_i.data[0]；
LSIndexed.data[0]＝indexed.data[0] & 0x1；
VAddrOffset.data[0]＝imm8.data[0]；
VAddrIndex.data[0]＝art_i.data[0]；
tmp0.data[0]＝(SGF8_X.data[0] | SGF8_XU.data[0]) & 0x1；
MemDataOut8.data[0]＝((tmp0.data[0])？gr_i.data[0]：gt_i.data[0]) &
0xff；
VAddrIn_get()；
ars_o.data[0]＝VAddrIn.data[0]；
tmpl.data[0]＝(SGF8_IU.data[0] | SGF8_XU.data[0]) & 0x1；
ars_kill_o.data[0]＝(0 & tmp1.data[0]) & 0x1；
/* write-back inout operands */
/* update output interface signals */
MemDataOut8_set()；
#define SGF8_IU(gt，ars，imm8)\
SGF8_IU_func(gt，&(ars)，imm8)
void
SGF8_IU_func(gf8 gt_，unsigned *ars_，int imm8_)
{
/* operand variables */
V1_t gt_i；
V1_t ars_o；
V1_t ars_i；
V1_t imm8；
/* unused operand variables */
V1_t gr_i＝{{0}}；
V1_t art_i＝{{0}}；
/* operand kill variables */
V1_t ars_kill_o＝{{0}}；
/* one-hot instruction signals */
V1_t SGF8_IU＝{{1}}；
V1_t SGF8_X＝{{0}}；
V1_t SGF8_XU＝{{0}}；
/* state variables */
/* local wire variables */
V1_t tmp1；
V1_t tmp0；
V1_t indexed；
/* initialize in/inout operands */
gt_i.data[0]＝gt_；
ars_i＝ *((V1_t *)ars_)；
imm8.data[0]＝imm8_；
tie_load_instruction＝0；
/* semantic statements */
indexed.data[0]＝(SGF8_X.data[0] | SGF8_XU.data[0]) & 0x1；
LSSize.data[0]＝0x1 & 0x1f；
VAddrBase.data[0]＝ars_i.data[0]；
LSIndexed.data[0]＝indexed.data[0] & 0x1；
VAddrOffset.data[0]＝imm8.data[0]；
VAddrIndex.data[0]＝art_i.data[0]；
tmp0.data[0]＝(SGF8_X.data[0]|SGF8_XU.data[0]) & 0x1；
MemDataOut8.data[0]＝((tmp0.data[0])？gr_i.data [0]：gt_i.data[0]) &
0xff；
<dp n="d114"/>
VAddrIn_get()；
ars_o.data[0]＝VAddrIn.data[0]；
tmp1.data[0]＝(SGF8_IU.data[0] | SGF8_XU.data[0]) & 0x1；
ars_kill_o.data[0]＝(0 & tmp1.data[0]) & 0x1；
/* write-back inout operands */
if(！ars_kill_o.data[0]) *ars_＝ *((unsigned *) &ars_o)；
/* update output interface signals */
MemDataOut8_set()；
}
void
SGF8_X(gf8 gr_，unsigned ars_，unsigned art_)
{
/* operand variables */
V1_t gr_i；
V1_t ars_i；
V1_t art_i；
/* unused operand variables */
V1_t gt_i＝{{0}}；
V1_t ars_o；
V1_t imm8＝{{0}}；
/* operand kill variables */
V1_t ars_kill_o＝{{0}}；
/* one-hot instruction signals */
V1_t SGF8_IU＝{{0}}；
V1_t SGF8_X＝{{1}}；
V1_t SGF8_XU＝{{0}}；
/* state variables */
/* local wire variables */
V1_t tmp1；
V1_t tmp0；
V1_t indexed；
/* initialize in/inout operands */
gr_i.data[0]＝gr_；
ars_i＝*((V1_t *) &ars_)；
art_i＝*((V1_t *) &art_)；
tie_load_instruction＝0；
/* semantic statements */
indexed.data[0]＝(SGF8_X.data[0] | SGF8_XU.data[0]) & 0x1；
LSSize.data[0]＝0x1 & 0x1f；
VAddrBase.data[0]＝ars_i.data[0]；
LSIndexed.data[0]＝indexed.data[0] & 0x1；
VAddrOffset.data[0]＝imm8.data[0]；
VAddrIndex.data[0]＝art_i.data[0]；
tmp0.data[0]＝(SGF8_X.data[0] | SGF8_XU.data[0]) & 0x1；
MemDataOut8.data[0]＝((tmp0.data[0])？gr_i.data[0]：gt_i.data[0]) &
0xff；
VAddrIn_get()；
ars_o.data[0]＝VAddrIn.data[0]；
tmp1.data[0]＝(SGF8_IU.data[0] | SGF8_XU.data[0]) & 0x1；
ars_kill_o.data[0]＝(0 & tmp1.data[0]) & 0x1；
/* write-back inout operands */
/* update output interface signals */
MemDataOut8_set()；
}
#define SGF8_XU(gr，ars，art)\
SGF8_XU_func(gr，&(ars)，art)
void
<dp n="d115"/>
SGF8_XU_func(gf8 gr_，unsigned *ars_，unsigned art_)
{
/* operand variables */
V1_t gr_i；
V1_t ars_o；
V1_t ars_i；
V1_t art_i；
/* unused operand variables */
V1_t gt_i＝{{0}}；
V1_t imm8＝{{0}}；
/* operand kill variables */
V1_t ars_kill_o＝{{0}}；
/* one-hot instruction signals */
V1_t SGF8_IU＝{{0}}；
V1_t SGF8_X＝{{0}}；
V1_t SGF8_XU＝{{1}}；
/* state variables */
/* local wire variables */
V1_t tmp1；
V1_t tmp0；
V1_t indexed；
/* initialize in/inout operands */
gr_i.data[0]＝gr_；
ars_i＝*((V1_t *) ars_)；
art_i＝*((V1_t *) &art_)；
tie_load_instruction＝0；
/* semantic statements */
indexed.data[0]＝(SGF8_X.data[0] | SGF8_XU.data[0]) & 0x1；
LSSize.data[0]＝0x1 & 0x1f；
VAddrBase.data[0]＝ars_i.data[0]；
LSIndexed.data[0]＝indexed.data[0] & 0x1；
VAddrOffset.data[0]＝imm8.data[0]；
VAddrIndex.data[0]＝art_i.data[0]；
tmp0.data[0]＝(SGF8_X.data[0] | SGF8_XU.data[0]) & 0x1；
MemDataOut8.data[0]＝((tmp0.data[0])？gr_i.data[0]：gt_i.data[0]) &
0xff；
VAddrIn_get()；
ars_o.data[0]＝VAddrIn.data[0]；
tmp1.data[0]＝(SGF8_IU.data[0] | SGF8_XU.data[0]) & 0x1；
ars_kill_o.data[0]＝(0 & tmp1.data[0]) & 0x1；
/* write-back inout operands */
if(！ars_kill_o.data[0]) *ars_＝ *((unsigned *) &ars_o)；
/* update output interface signals */
MemDataOut8_set()；
}
unsigned
RUR0()
{
/* operand variables */
V1_t arr_o；
/* unused operand variables */
/* operand kill variables */
V1_t arr_kill_o＝{{0}}；
/* one-hot instruction signals */
V1_t RUR0＝{{1}}；
/* state variables */
V1_t gfmod_ps；
/* local wirevariables */
/* get input state values */
<dp n="d116"/>
GetState(gfmod_ps，STATE_gfmod)；
/* initialize in/inout operands */
tie_load_instruction＝0；
/* semantic statements */
arr_o.data[0]＝gfmod_ps.data[0]；
art_kill_o.data[0]＝(0 & RUR0.data[0]) & 0x1；
/* write-back inout operands */
/* return the output operand */
return *((unsigned *) &arr_o)；
}
void
WUR0(unsigned art_)
{
/* operand variables */
V1_t art_i；
/* unused operand variables */
/* operand kill variables */
/* one-hot instruction signals */
V1_t WUR0＝{{1}}；
/* state variables */
V1_t gfmod_ns；
V1_t gfmod_kill_ns；
/* local wire variables */
V1_t tmp0；
/* initialize in/inout operands */
art_i＝ *((V1_t *) &art_)；
tie_load_instruction＝0；
/* semantic statements */
tmp0.data[0]＝((art_i.data[0] & 0xff)) & 0xff；
gfmod_ns.data[0]＝(tmp0.data[0]) & 0xff；
gfmod_kill_ns.data[0]＝(0 & WUR0.data[0]) & 0x1；
/* write-back inout operands */
/* update out/inout states */
if(！gfmod_kill_ns.data[0])SetState(STATE_gfmod，gfmod_ns)；
}
#define gf8_loadi(_s，o)({\
gf8 t；\
gf8 *s＝_s；\
gf8 LGF8_I_return；\
LGF8_I_return＝LGF8_I(*((unsigned *)&(s))，*((int *)&(o)))；\
t＝*((gf8 *)&LGF8_I_return)；\
t；\
})
#define gf8_storei(_t，_s，o)({\
gf8 t＝_t；\
gf8 *s＝_s；\
SGF8_I(*((gf8*)&(t))，*((unsigned*)&(s))，*((int*)&(o)))；\
})
#define gf8_move(_r，_s)({\
gf8r＝_r；\
gf8s＝_s；\
gf8 GFADD8_return；\
GFADD8_return＝GFADD8(*((gf8*)&(s))，*((gf8*)&(0)))；\
r＝*((gf8 *) &GFADD8_return)；\
})
<dp n="d117"/>
#ifdef TIE_DEBUG
#undef gf8_loadi
#undef gf8_storei
#undef gf8_move
#undef GFADD8
#undef GFADD8I
#undef GFMULX8
#undef GFRWMOD8
#undef LGF8_I
#undef SGF8_I
#undef LGF8_IU
#undef SGF8_IU
#undef LGF8_X
#undef SGF8_X
#undef LGF8_XU
#undef SGF8_XU
#undef RUR0
#undef WUR0
#endif
#endif
cstub-gf-ref.c
#ifndef _XTENSA_
#ifdef TIE_DEBUG
#define gf8_loadi TIE_gf8_loadi
#define gf8_storei TIE_gf8_storei
#define gf8_move TIE_gf8_move
#define GFADD8 TIE_GFADD8
#define GFADD8I TIE_GFADD8I
#define GFMULX8 TIE_GFMULX8
#define GFRWMOD8 TIE_GFRWMOD8
#define LGF8_I TIE_LGF8_I
#define SGF8_I TIE_SGF8_I
#define LGF8_IU TIE_LGF8_IU
#define SGF8_IU TIE_SGF8_IU
#define LGF8_X TIE_LGF8_X
#define SGF8_X TIE_SGF8_X
#define LGF8_XU TIE_LGF8_XU
#define SGF8_XU TIE_SGF8_XU
#define RUR0 TIE_RUR0
#define WUR0 TIE_WUR0
#endif
#include ＜stdio.h＞
#define LittleEndian 0
#define BigEndian 1
#define PIFReadDataBits 128
#define PIFWriteDataBits 128
#define IsaMemoryOrder LittleEndian
#include ＂BR.h＂
#include ＂LS.h＂
#define BPW 32
#define WINDEX(_n)((_n)/BPW)
#define BINDEX(_n)((_n)％BPW)
typedef unsigned char Vb_t；
typedef unsigned short Vs_t ；
typedef struct V1_s{unsigned data[1]；}V1_t；
<dp n="d118"/>
typedef struct V2_s{unsigned data[2]；}V2_t；
typedef struct V4_s{unsigned data[4]；}V4_t；
typedef Vb_t gf8；
static int tie_load_instruction＝0；
void
TieMemRead(unsigned *data，unsigned addr)
{
unsigned char *mem；
unsigned modulus，bytes，offset；
int t，b0，b1，b2，b3；
bytes＝PIFReadDataBits / 8；
modulus＝bytes-1；
mem＝(unsigned char *)(addr &-modulus)；
offset＝(unsigned char *)addr-mem；
if(IsaMemoryOrder＝＝LittleEndian){
for(t＝0；t＜bytes/sizeof(int)；t++){
b0＝mem[(offset++) & modulus]；
b1＝mem[(offset++) & modulus]；
b2＝mem[(offset++) & modulus]；
b3＝mem[(offset++) & modulus]；
data[t]＝(b3＜＜24)|(b2＜＜16)|(b1＜＜8)|b0；
}
}else{
for(t＝bytes/sizeof(int)-1；t＞＝0；t--){
b3＝mem[(offset++) & modulus]；
b2＝mem[(offset++) & modulus]；
b1＝mem[(offset++) & modulus]；
b0＝mem[(offset++) & modulus]；
data[t]＝(b3＜＜24)|(b2＜＜16)|(b1＜＜8)|b0；
}
}
}
void
TieMemWrite(unsigned addr，unsigned bytes，unsigned *data){
unsigned char *mem；
unsigned modulus，offset，w；
int t；
if(PIFWriteDataBits ＜bytes * 8){
fprintf(stderr，＂Error：not configured to write ％d bytes\n＂
bytes)；
exit(1)；
}
modulus＝bytes-1；
mem＝(unsigned char *)(addr & -modulus)；
if(IsaMemoryOrder＝＝LittleEndian){
if(bytes＝＝1){
mem[0]＝data[0] & 0xff；
}else if(bytes＝＝2){
mem[0]＝data[0] & 0xff；
<dp n="d119"/>
mem[1]＝(data[0]＞＞8) & 0xff；
}else{
offset＝0；
for(t＝0；t＜bytes/sizeof(int)；t++){
w＝data[t]；
mem[offset++]＝ w & 255；
mem[offset++]＝(w＞＞8) & 255；
mem[offset++]＝(w＞＞16) & 255；
mem[offset++]＝(w＞＞24) & 255；
}
}
}else{
if(bytes＝＝1){
mem[0]＝data[0] & 0xff；
}else if(bytes＝＝2){
mem[1]＝data[0] & 0xff；
mem[0]＝(data[0]＞＞8) & 0xff；
}else{
offset＝0；
for(t＝bytes/sizeof(int)-1；t＞＝0；t--){
w＝data[t]；
mem[offset++]＝(w＞＞24) & 255；
mem[offset++]＝(w＞＞16) & 255；
mem[offset++]＝(w＞＞8) & 255；
mem[offset++]＝w & 255；
}
}
}
}
#define GetState(_s，_n) _s＝_n
#define SetState(_n，_s) _n＝_s
V1_t STATE_gfmod；
V1_t VAddr＝{{0}}；
V1_t VAddrBase＝{{0}}；
V1_t VAddrOffset＝{{0}}；
V1_t VAddrIndex＝{{0}}；
V1_t VAddrIn＝{{0}}；
V1_t ASSize＝{{0}}；
V1_t LSIndexed＝{{0}}；
V4_t MemDataIn128＝{{0，0，0，0}}；
V2_t MemDataIn64＝{{0，0}}；
V1_t MemDataIn32＝{{0}}；
V1_t MemDataIn16＝{{0}}；
V1_t MemDataIn8＝{{0}}；
V4_t MemDataOut128＝{{0，0，0，0}}；
V2_t MemDataOut64＝{{0，0}}；
V1_t MemDataOut32＝{{0}}；
V1_t MemDataOut16＝{{0}}；
V1_t MemDataOut8＝{{0}}；
V1_t Exception＝{{0}}；
V1_t ExcCause＝{{0}}；
V1_t CPEnable＝{{0}}；
void
VAddrIn_get(void)
{
if(LSIndexed.data[0] ！＝0){
<dp n="d120"/>
VAddrIn.data[0]＝VAddrBase.data[0]+VAddrIndex.data[0]；
}else{
VAddrIn.data[0]＝VAddrBase.data[0]+VAddrOffset.data[0]；
}
}
void
MemDataIn128_get(void)
{
unsigned data[4]；
if((！tie_load_instruction)||(LSSize.data[0]！＝16)){
return；
}
if(PIFReadDataBits＜128){
fprintf(stderr，＂Error：not configured to read 16 bytes\n＂)；
exit(-1)；
}
VAddrIn_get()；
TieMemRead(&data[0]，VAddrIn.data[0])；
MemDataIn128.data[0]＝data[0]；
MemDataIn128.data[1]＝data[1]；
MemDataIn128.data[2]＝data[2]；
MemDataIn128.data[3]＝data[3]；
}
void
MemDataIn64_get(void)
{
unsigned data[4]；
if((！tie_load_instruction)||(LSSize.data[0]！＝8)){
return；
}
if(PIFReadDataBits＜64){
fprintf(stderr，＂Error：not configured to read 8 bytes\n＂)；
exit(-1)；
}
VAddrIn_get()；
TieMemRead(&data[0]，VAddrIn.data[0])；
if(IsaMemoryOrder＝＝LittleEndian){
MemDataIn64.data[0]＝data[0]；
MemDataIn64.data[1]＝data[1]；
}else if(PIFReadDataBits＝＝64){
MemDataIn64.data[0]＝data[0]；
MemDataIn64.data[1]＝data[1]；
}else{
MemDataIn64.data[0]＝data[2]；
MemDataIn64.data[1]＝data[3]；
}
}
void
<dp n="d121"/>
MemDataIn32_get(void)
{
unsigned data[4]；
if((！tie_load_instruction)||(LSSize.data[0]！＝4)){
return；
}
if(PIFReadDataBits＜32){
fprintf(stderr，＂Error：not configured to read 4 bytes\n＂)；
exit(-1)；
}
VAddrIn_get()；
TieMemRead(&data[0]，VAddrIn.data[0])；
if(IsaMemoryOrder＝＝LittleEndian){
MemDataIn32.data[0]＝data[0]；
}else if(PIFReadDataBits＝＝32){
MemDataIn32.data[0]＝data[0]；
}else if(PIFReadDataBits＝＝64}{
MemDataIn32.data[0]＝data[1]；
}else{
MemDataIn32.data[0]＝data[3]；
}
}
void
MemDataIn16_get(void)
{
unsigned data[4]；
if((！tie_load_instruction)||(LSSize.data[0]！＝2)){
return；
}
if(PIFReadDataBits＜16){
fprintf(stderr，＂Error：not configured to read 2 bytes\n＂)；
exit(-1)；
}
VAddrIn_get()；
TieMemRead(&data[0]，VAddrIn.data[0])；
if(IsaMemoryOrder＝＝LittleEndian){
MemDataIn16.data[0]＝data[0] & 0xffff；
} else if(PIFReadDataBits＝＝32){
MemDataIn16.data[0]＝data[0]＞＞16；
} else if(PIFReadDataBits＝＝64){
MemDataIn16.data[0]＝data[1]＞＞16；
} else{
MemDataIn16.data[0]＝data[3]＞＞16；
}
}
void
MemDataIn8_get(void)
{
unsigned data[4]；
<dp n="d122"/>
if((！tie_load_instruction)||(LSSize.data[0]！＝1)){
return；
}
if(PIFReadDataBits＜8){
fprintf(stderr，＂Error：not configured to read 1 byte\n＂)；
exit(-1)；
}
VAddrIn_get()；
TieMemRead(&data[0]，VAddrIn.data[0])；
if(IsaMemoryOrder＝＝LittleEndian){
MemDataIn8.data[0]＝data[0] & 0xff；
} else if(PIFReadDataBits＝＝32){
MemDataIn8.data[0]＝data[0]＞＞24；
} else if(PIFReadDataBits＝＝64){
MemDataIn8.data[0]＝data[1]＞＞24；
} else{
MemDataIn8.data[0]＝data[3]＞＞24；
}
}
void
MemDataOut128_set(void)
{
if(LSSize.data[0] ！＝16){
return；
}
VAddrIn_get()；
TieMemWrite(VAddrIn.data[0] & -0xf，16，&MemDataOut128.data[0])；
}
void
MemDataOut64_set(void)
{
if(LSSize.data[0]！＝8){
return；
}
VAddrIn_get()；
TieMemWrite(VAddrIn.data[0] & -0x7，8，&MemDataOut64.data[0])；
}
void
MemDataOut32_set(void)
{
if(LSSize.data[0]！＝4){
return；
}
VAddrIn_get()；
TieMemWrite(VAddrIn.data[0] & -0x3，4，&MemDataOut32.data[0])；
}
void
<dp n="d123"/>
MemDataOut16 set(void)
{
if(LSSize.data[0]！＝2){
return；
}
VAddrIn_get()；
TieMemWrite(VAddrIn.data[0] & -0x1，2，&MemDataOut16.data[0])；
}
void
MemDataOut8_set(void)
{
if(LSSize.data[0]！＝1){
return；
}
VAddrIn_get()；
TieMemWrite(VAddrIn.data[0]，1，&MemDataOut8.data[0])；
}
void
Exception_set(void)
{
/* Exception handling is not supported in native mode */
}
void
CPEnable_get(void)
{
CPEnable.data[0]＝0xff；/* always enabled in native C mode */
}
#define RUR(n)({\
int v；\
switch (n){\
case 0：\
v＝RUR0()；break；\
default：\
fprintf(stderr，＂Error：invalid rur number ％d\n＂，n)；\
exit(-1)；\
}\
v；\
})
#define WUR(v，n)\
switch(n){\
case 0：\
WUR0(v)；break；\
default：\
fprintf(stderr，＂Error：invalid wur number ％d\n＂，n)；\
exit(-1)；\
}
gf8
GFADD8(gf8 gs_，gf8 gt_)
{
<dp n="d124"/>
/* operand variables */
V1_t gr_o；
V1_t gs_i；
V1_t gt_i；
/* unused operand variables */
/* operand kill variables */
V1_t gr_kill_o＝{{0}}；
/* one-hot instruction sisals */
V1_t GFADD8＝{{1}}；
/* state variables */
/* local wire variables */
/* initialize in/inout operands */
gs_i.data[0]＝gs_；
gt_i.data[0]＝gt_；
tie_load_instruction＝0；
/* semantic statements */
gr_o.data[0]＝(gs_i.data[0]^gt_i.data[0]) & 0xff；
gr_kill_o.data[0]＝(0 & GFADD8.data[0]) & 0x1；
/* write-back inout operands */
/* return the output operand */
return gr_o.data[0]；
}
gf8
GFADD8I(gf8 gs_，int imm4)
{
/* operand variables */
V1_t gr_o；
V1_t gs_i；
V1_t imm4；
/* unused operand variables */
/* operand kill variables */
V1_t gr_kill_o＝{{0}}；
/* one-hot instruction signals */
V1_t GFADD8I＝{{1}}；
/* state variables */
/* local wire variables */
/* initialize in/inout operands */
gs_i.data[0]＝gs_；
imm4.data[0]＝imm4_；
tie_load_instruction＝0；
/* semantic statements */
gr_o.data[0]＝(gs_i.data[0]^imm4.data[0]) & 0xff；
gr_kill_o.data[0]＝(0 & GFADD8I.data[0]) & 0x1；
/* write-back inout operands */
/* return the output operand */
return gr_o.data[0]；
}
gf8
GFMULX8(gf8 gs_)
{
/* operand variables */
V1_t gr_o；
V1_t gs_i；
/* unused operand variables */
/* operand kill variables */
V1_t gr_kill_o＝{{0}}；
/* one-hot instruction signals */
V1_t GFMULX8＝{{1}}；
<dp n="d125"/>
/* state variables */
V1_t gfmod_ps；
/* local wire variables */
V1_t tmp5；
V1_t tmp4；
V1_t tmp3；
V1_t tmp2；
V1_t tmp1；
V1_t tmp0；
/* get input state values */
GetState(gfmod_ps，STATE_gfmod)；
/* initialize in/inout operands */
gs_i.data[0]＝gs_；
tie_load_instruction＝0；
/* semantic statements */
tmp0.data[0]＝(((gs_i.data[0]＜＜24)＞＞31)) & 0x1；
tmp1.data[0]＝((gs_i.data[0] & 0x7f)) & 0x7f；
tmp2.data[0]＝((tmp1.data[0]＜＜1)|0) & 0xff；
tmp3.data[0]＝(tmp2.data[0]^gfmod_ps.data[0]) & 0xff；
tmp4.data[0]＝((gs_i.data[0] & 0x7f)) & 0x7f；
tmp5.data[0]＝((tmp4.data[0]＜＜1)|0) & 0xff；
gr_o.data[0]＝((tmp0.data[0])？tmp3.data[0]：tmp5.data[0]) & 0xff；
gr_kill_o.data[0]＝(0 & GFMULX8.data[0]) & 0x1；
/* write-back inout operands */
/* return the output operand */
return gr_o.data[0]；
}
#define GFRWMOD8(gt)\
GFRWMOD8_func(&(gt))
void
GFRWMOD8_func(gf8 *gt_)
{
/* operand variables */
V1_t gt_o；
V1_t gt_i；
/* unused operand variables */
/* operand kill variables */
V1_t gt_kill_o＝{{0}}；
/* one-hot instruction signals */
V1_t GFRWMOD8＝
/* state variables */
V1_t gfmod_ps；
V1_t gfmod_ns；
V1_t gfmod_kill_ns；
/* local wire variables */
Vi_t t1；
Vi_t t2；
/* get input state values */
GetState(gfmod_ps，STATE_gfmod)；
/* initialize in/inout operands */
gt_i.data[0]＝*gt_；
tie_load_instruction＝0；
/* semantic statements */
t1.data[0]＝gt_i.data[0] & 0xff；
t2.data[0]＝gfmod_ps.data[0] & 0xff；
gfmod_ns.data[0]＝t1.data[0] & 0xff；
gt_o.data[0]＝t2.data[0] & 0xff；
gfmod_kill_ns.data[0]＝(0 & GFRWMOD8.data[0]) & 0x1；
<dp n="d126"/>
gt_kill_o.data[0]＝(0 & GFRWMOD8.data[0]) & 0x1；
/* write-back inout operands */
if(！gt_kill_o.data[0]) *gt_＝gt_o.data[0]；
/* update out/inout states */
if(！gfmod_kill_ns.data[0])SetState(STATE_gfmod，gfmod_ns)；
}
gf8
LGF8_I(unsigned ars_，int imm8_)
{
/* operand variables */
V1_t gt_o；
V1_t ars_i；
V1_t imm8；
/* unused operand variables */
/* operand kill variables */
V1_t gt_kill_o＝{{0}}；
/* one-hot instruction signals */
V1_t LGF8_I＝{{1}}；
/* state variables */
/* local wire variables */
/* initialize in/inout operands */
ars_i＝ *((V1_t *)&ars_)；
imm8.data[0]＝imm8_；
tie_load_instruction＝1；
/* semantic statements */
LSSize.data[0]＝0x1 & 0x1f；
VAddrBase.data[0]＝ars_i.data[0]；
LSIndexed.data[0]＝0 & 0x1；
VAddrOffset.data[0]＝imm8.data[0]；
MemDataIn8_get()；
gt_o.data[0]＝MemDataIn8.data[0] & 0xff；
gt_kill_o.data[0]＝(0 & LGF8_I.data[0]) & 0x1；
/* write-back inout operands */
/* update output interface signals */
/* return the output operand */
return gt_o.data[0]；
}
#define LGF8_IU(ars，imm8)\
LGF8_IU_func(&(ars)，imm8)
gf8
LGF8_IU_func(unsigned *ars_，int imm8_)
{
/* operand variables */
V1_t gt_o；
V1_t ars_o；
V1_t ars_i；
V1_t imm8；
/* unused operand variables */
/* operand kill variables */
V1_t gt_kill_o＝{{0}}；
V1_t ars_kill_o＝{{0}}；
/* one-hot instruction signals */
V1_t LGF8_IU＝{{1}}；
/* state variables */
/* local wire variables */
/* initialize in/inout operands */
ars_i＝ *((V1_t *)ars_)；
<dp n="d127"/>
imm8.data[0]＝imm8_；
tie_load_instruction＝1；
/* semantic statements */
LSSize.data[0]＝0x1 & 0x1f；
VAddrBase.data[0]＝ars_i.data[0]；
LSIndexed.data [0]＝0 & 0x1；
VAddrOffset.data[0]＝imm8.data[0]；
MemDataIn8_get()；
gt_o.data[0]＝MemDataIn8.data[0] & 0xff；
VAddrIn_get()；
ars_o.data[0]＝VAddrIn.data[0]；
gt_kill_o.data[0]＝(0 & LGF8_IU.data[0]) & 0x1；
ars_kill_o.data[0]＝(0 & LGF8_IU.data[0]) & 0x1；
/* write-back inout operands */
if(！ars_kill_o.data[0]) *ars_＝*((unsigned*) &ars_o)；
/* update output interface signals */
/* return the output operand */
return gt_o. data[0]；
}
gf8
LGF8_X(unsigned ars_，unsigned art_)
{
/* operand variables */
V1_t gr_o；
V1_t ars_i；
V1_t art_i；
/* unused operand variables */
/* operand kill variables */
V1_t gr_kill_o＝{{0}}；
/* one-hot instruction signals */
V1_t LGF8_X＝{{1}}；
/* state variables */
/* local wire variables */
/* initialize in/inout operands */
ars_i＝*((V1_t*) &ars_)；
art_i＝*((V1_t*) &art_)；
tie_load_instruction＝1；
/* semantic statements */
LSSize.data[0]＝0x1 & 0x1f；
VAddrBase.data[0]＝ars_i.data[0]；
LSIndexed.data[0]＝0x1 & 0x1；
VAddrIndex.data[0]＝art_i.data[0]；
MemDataIn8_get()；
gr_o.data[0]＝MemDataIn8.data[0] & 0xff；
VAddrIn_get()；
ars_o.data[0]＝VAddrIn.data[0]；
gr_kill_o.data[0]＝(0 & LGF8_X.data[0]) & 0x1；
/* write-back inout operands */
/* update output interface signals */
/* return the output operand */
return gr_o.data[0]；
}
#define LGF8_XU(ars，art)\
LGF8_XU_func(&(ars)，art)
gf8
LGF8_XU_func(unsigned *ars_，unsigned art_)
{
<dp n="d128"/>
/* operand variables */
V1_t gr_o；
V1_t ars_o；
V1_t ars_i；
V1_t art_i；
/* unused operand variables */
/* operand kill variables */
V1_t gr_kill_o＝{{0}}；
V1_t ars_kill_o＝{{0}}；
/* one-hot instruction signals */
V1_t LGF8_XU＝{{1}}；
/* state variables */
/* local wire variables */
/* initialize in/inout operands */
ars_i＝ *((V1_t *)ars_)；
art_i＝ *((V1_t *)&art_)；
tie_load_instruction＝1；
/* semantic statements */
LSSize.data[0]＝0x1 & 0x1f；
VAddrBase.data[0]＝ars_i.data[0]；
LSIndexed.data[0]＝0x1 & 0x1；
VAddrIndex.data[0]＝art_i.data[0]；
MemDataIn8_get()；
gr_o.data[0]＝MemDataIn8.data[0] & 0xff；
VAddrIn_get()；
ars_o.data[0]＝VAddrIn.data[0]；
gr_kill_o.data[0]＝(0 & LGF8_XU.data[0]) & 0x1；
ars_kill_o.data[0]＝(0 & LGF8_XU.data[0]) & 0x1；
/* write-back inout operands */
if(！ars_kill_o.data[0])*ars_＝*((unsigned*) &ars_o)；
/* update output interface signals */
/* return the output operand */
return gr_o.data[0]；
}
void
SGF8_I(gf8 gt_，unsigned ars_，int imm8_)
{
/* operand variables */
V1_t gt_i；
V1_t ars_i；
V1_t imm8；
/* unused operand variables */
/* operand kill variables */
/* one-hot instruction signals */
/* state variables */
/* local wire variables */
/* initialize in/inout operands */
gt_i.data[0]＝gt_；
ars_i＝*((V1_t *) &ars_)；
imm8.data[0]＝imm8_；
tie_load_instruction＝0；
/* semantic statements */
LSSize.data[0]＝0x1&0x1f；
VAddrBase.data[0]＝ars_i.data[0]；
LSIndexed.data[0]＝0 & 0x1；
VAddrOffset.data[0]＝imm8.data[0]；
MemDataOut8.data[0]＝gt_i.data[0] & 0xff；
/* write-back inout operands */
/* update output interface signals */
<dp n="d129"/>
MemDataOut8_set()；
}
#define SGF8_IU(gt，ars，imm8)\
SGF8_IU_func(gt，&(ars)，imm8)
void
SGF8_IU_func(gf8 gt_，unsigned *ars_，int imm8_)
{
/* operand variables */
V1_t gt_i；
V1_t ars_o；
V1_t ars_i；
V1_t imm8；
/* unused operand variables */
/* operand kill variables */
V1_t ars_kill_o＝{{0}}；
/* one-hot instruction signals */
V1_t SGF8_IU＝
/* state variables */
/* local wire variables */
/* initialize in/inout operands */
gt_i.data[0]＝gt_；
ars_i＝*((V1_t *)ars_)；
imm8.data[0]＝imm8_；
tie_load_instruction＝0；
/* semantic statements */
LSSize.data[0]＝0x1 & 0x1f；
VAddrBase.data[0]＝ars_i.data[0]；
LSIndexed.data[0]＝0 & 0x1；
VAddrOffset.data[0]＝imm8.data[0]；
MemDataOut8.data[0]＝gt_i.data[0] & 0xff；
VAddrIn_get()；
ars_o.data[0]＝VAddrIn.data[0]；
ars_kill_o.data[0]＝(0 & SGF8_IU.data[0]) & 0x1
/* write-back inout operands */
if(！ars_kill_o.data[0]) *ars_＝*((unsigned *) &ars_o)；
/* update output interface signals */
MemDataOut8_set()；
}
void
SGF8_X(gf8 gr_，unsigned ars_，unsigned art_)
{
/* operand variables */
V1_t gr_i；
V1_t ars_i；
V1_t art_i；
/* unused operand variables */
/* operand kill variables */
/* one-hot instruction signals */
/* state variables */
/* local wire variables */
/* initialize in/inout operands */
gr_i.data[0]＝gr_；
ars_i＝*((V1_t *) &ars_)；
art_i＝*((V1_t *) &art_)；
tie_load_instruction＝0；
/* semantic statements */
LSSize.data[0]＝0x1 & 0x1f；
<dp n="d130"/>
VAddrBase.data[0]＝ars_i.data[0]；
LSIndexed.data[0]＝0x1 & 0x1；
VAddrIndex.data[0]＝art_i.data[0]；
MemDataOut8.data[0]＝gr_i.data[0] & 0xff；
/* write-back inout operands */
/* update output interface signals */
MemDataOut8_set()；
}
#define SGF8_XU(gr，ars，art)\
SGF8_XU_func(gr，&(ars)，art)
void
SGF8_XU_func(gf8 gr_，unsigned *ars_，unsigned art_)
{
/* operand variables */
V1_t gr_i；
V1_t ars_o；
V1_t ars_i；
V1_t art_i；
/* unused operand variables */
/* operand kill variables */
V1_t ars_kill_o＝{{0}}；
/* one-hot instruction signals */
V1_t SGF8_XU＝{{1}}；
/* state variables */
/* local wire variables */
/* initialize in/inout operands */
gr_i.data[0]＝gr_；
ars_i＝*((Vi_t *)ars_)；
art_i＝*((V1_t *) &art_)；
tie_load_instruction＝0；
/* semantic statements */
LSSize.data[0]＝0x1 & 0x1f；
VAddrBase.data[0]＝ars_i.data[0]；
LSIndexed.data[0]＝0x1 & 0x1；
VAddrIndex.data[0]＝art_i.data[0]；
MemDataOut8.data[0]＝gr_i.data[0] & 0xff；
VAddrIn_get()；
ars_o.data[0]＝VAddrIn.data[0]；
ars_kill_o.data[0]＝(0 & SGF8_XU.data[0]) & 0x1；
/* write-back inout operands */
if(！ars_kill_o.data[0]) *ars_＝*((unsigned *) &ars_o)；
/* update output interface signals */
MemDataOut8_set()；
}
unsigned
RUR0()
{
/* operand variables */
V1_t arr_o；
/* unused operand variables */
/* operand kill variables */
V1_t arr_kill_o＝{{0}}；
/* one-hot instruction signals */
V1_t RUR0＝{{1}}；
/* state variables */
V1_t gfmod_ps；
/* local wire variables */
<dp n="d131"/>
/* get input state values */
GetState(gfmod_ps，STATE_gfmod)；
/* initialize in/inout operands */
tie_load_instruction＝0；
/* semantic statements */
arr_o.data[0]＝gfmod_ps.data[0]；
arr_kill_o.data[0]＝(0 & RUR0.data[0]) & 0x1；
/* write-back inout operands*/
/* return the output operand */
return *((unsigned *) &arr_o)；
}
void
WUR0(unsigned art_)
{
/* operand variables */
V1_t art_i；
/* unused operand variables */
/* operand kill variables */
/* one-hot instruction signals */
V1_t WUR0＝{{1}}；
/* state variables */
V1_t gfmod_ns；
V1_t gfmod_kill_ns；
/* local wire variables */
V1_t tmp0；
/* initialize in/inout operands */
art_i＝*((V1_t*) &art_)；
tie_load_instruction＝0；
/* semantic statements */
tmp0.data[0]＝((art_i.data[0] & 0xff)) & 0xff；
gfmod_ns.data[0]＝(tmp0.data[0]) & 0xff；
gfmod_kill_ns.data[0]＝(0 & WUR0.data[0]) & 0x1；
/* write-back inout operands */
/* update out/inout states */
if(！gfmod_kill_ns.data[0])SetState(STATE_gfmod，gfmod_ns)；
}
#define gf8_loadi(_s，o)({\
gf8 t；\
gf8 *s＝_s；\
gf8 LGF8_I_return；\
LGF8_I_return＝LGF8_I(*((unsigned*)&(s))，*((int*)&(o)))；\
t＝*((gf8 *)&LGF8_I_return)；\
t；\
})
#define gf8_storei(_t，_s，o)({\
gf8 t＝_t；\
gf8 *s＝_s；\
SGF8_I(*((gf8 *)&(t))，*((unsigned *)&(s))，*((int *)&(o)))；\
})
#define gf8_move(_r，_s)({\
gf8 r＝_r；\
gf8 s＝_s；\
gf8 GFADD8_return；\
GFADD8_return＝GFADD8(*((gf8 *)&(s))，*((gf8 *)&(0)))；\
r＝*((gf8 *)&GFADD8_return)；\
})
<dp n="d132"/>
#ifdef TIE_DEBUG
#undef gf8_loadi
#undef gf8_storei
#undef gf8_move
#undef GFADD8
#undef GFADD8I
#undef GFMULX8
#undef GFRWMOD8
#undef LGF8_I
#undef SGF8_I
#undef LGF8_IU
#undef SGF8_IU
#undef LGF8_X
#undef SGF8_X
#undef LGF8_XU
#undef SGF8_XU
#undef RUR0
#undef WUR0
#endif
#endif
BR.h
/*
* Copyright 1999-2000 Tensilica Inc.
* These coded instructions，statements，and computer programs are
* Confidential Proprietary Information of Tensilica Inc. and may not be
* disclosed to third parties or copied in any form，in whole or in part，
* without the prior written consent of Tensilica Inc.
*/
#ifndef BR_HEADER
#define BR_HEADER
#ifndef _XTENSA_
typedef unsigned char xtbool；
typedef unsigned char xtbool2；
typedef unsigned char xtbool4；
typedef unsigned char xtbool8；
typedef unsigned short xtbool16；
xtbool
XT_ANDB(xtbool bs，xtbool bt)
{
return 0x1 & (bs & bt)；
}
xtbool
XT_ANDBC(xtbool bs，xtbool bt)
{
return 0x1 & (bs & ！bt)；
}
xtbool
XT_ORB(xtbool bs，xtbool bt)
{
return 0x1 & (bs | bt)；
<dp n="d133"/>
}
xtbool
XT_ORBC(xtbool bs，xtbool bt)
{
return 0x1 & (bs | ！bt)；
}
xtbool
XT_XORB(xtbool bs，xtbool bt)
{
return 0x1 & (bs ^ bt)；
}
xtbool
XT_ANY4(xtbool4 bs4)
{
return(bs4 & 0xf)！＝0；
}
xtbool
XT_ALL4(xtbool4 bs4)
{
return(bs4 & 0xf)＝＝0xf；
}
xtbool
XT_ANY8(xtbool8 bs8)
{
return(bs8 & 0xf)！＝0；
}
xtbool
XT_ALL8(xtbool8 bs8)
{
return(bs8 & 0xf)＝＝0xf；
}
#endif /* _XTENSA_ */
#endif/* BR_HEADER */
gf.v
module xmTIE_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[7：0]rd0_data_C1；
input[3：0]rd0_addr_C0；
input rd0_width8_C0；
input rd0_use1_C0；
output [7：0]rd1_data_C1；
input [3：0]rd1_addr_C0；
input rd1_width8_C0；
input rd1_use1_C0；
output [7：0]rd2_data_C1；
<dp n="d134"/>
input [3：0]rd2_addr_C0；
input rd2_width8_C0；
input rd2_use1_C0；
input [3：0]wd_addr_C0；
input wd_width8_C0；
input wd_def1_C0；
input wd_def2_C0；
input [7：0] wd_data8_C1；
input [7：0] wd_data8_C2；
input wd_wen_C1；
input wd_wen_C2；
input Kill_E；
input KillPipe_W；
output Stall_R；
input clk；
/***********************************************************************
READ PORT rd0
***********************************************************************/
// compute the address mask
wire rd0_addr_mask_C0＝1′d0；
//masked address pipeline
wire rd0_maddr_C0＝1′d0；
// bank-qualified use
wire rd0_use1_bank0_C0＝(rd0_use1_C0 & (rd0_maddr_C0＝＝(1′d0 &
rd0_addr_mask_C0)))；
// alignment mux for use 1
wire [7：0]rd0_data_bank0_C1；
assign rd0_data_C1[7：0]＝rd0_data_bank0_C1；
/***********************************************************************
READ PORT rd1
***********************************************************************/
// compute the address mask
wire rd1_addr_mask_C0＝1′d0；
// masked address pipeline
wire rd1_maddr_C0＝1′d0；
// bank-qualified use
wire rd1_use1_bank0_C0＝(rd1_use1_C0 & (rd1_maddr_C0＝＝(1′d0 &
rd1_addr_mask_C0)))；
// alignment mux for use 1
wire [7：0]rd1_data_bank0_C1；
assign rd1_data_C1[7：0]＝rd1_data_bank0_C1；
/***********************************************************************
READ PORT rd2
<dp n="d135"/>
***********************************************************************/
// compute the address mask
wire rd2_addr_mask_C0＝1′d0；
// masked address pipeline
wire rd2_maddr_C0＝1′d0；
// bank-qualified use
wire rd2_use1_bank0_C0＝(rd2_use1_C0 & (rd2_maddr_C0＝＝(1′d0 &
rd2_addr_mask_C0)))；
// alignment mux for use 1
wire [7：0] rd2_data_bank0_C1；
assign rd2_data_C1[7：0]＝rd2_data_bank0_C1；
/***********************************************************************
WRITE PORT wd
***********************************************************************/
// compute the address mask
wire wd_addr_mask_C0＝1′d0；
//bank-qualified write deffor port wd
wire wd_def1_bank0_C0＝(wd_def1_C0 & ((wd_addr_C0 & wd_addr_mask_C0)
＝＝(1′d0 & wd_addr_mask_C0)))；
wire wd_def2_bank0_C0＝(wd_def2_C0 & ((wd_addr_C0 & wd_addr_mask_C0)
＝＝(1′d0 & wd_addr_mask_C0)))；
//write mux for def 1
wire [7：0] wd_wdata_C1；
assign wd_wdata_C1＝{1{wd_data8_C1[7：0]}}；
//write mux for def 2
wire [7：0] wd_wdata_C2；
assign wd_wdata_C2＝{1{wd_data8_C2[7：0]}}；
wire Stall_R0；
/***********************************************************************
PIPELINED BANK
***********************************************************************/
xmTIE_gf_Regfile_bank TIE_gf_Regfile_bank0(rd0_data_bank0_C1，
rd0_addr_C0[3：0]，rd0_use1_bank0_C0，rd1_data_bank0_C1，
rd1_addr_C0[3：0]，
rd1_use1_bank0_C0，rd2_data_bank0_C1，rd2_addr_C0[3：0]，
rd2_use1_bank0_C0，
wd_addr_C0[3：0]，wd_def1_bank0_C0，wd_def2_bank0_C0，
wd_wdata_C1[7：0]，
wd_wdata_C2[7：0]，wd_wen_C1，wd_wen_C2，Kill_E，KillPipe_W，
Stall_R0，
clk)；
assign Stall_R＝Stall_R0|1′b0；
endmodule
<dp n="d136"/>
module xmTIE_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 [7：0] rdo_data_C1；
input [3：0] rd0_addr_C0；
input rd0_use1_C0；
output [7：0] rd1_data_C1；
input [3：0] rd1_addr_C0；
input rd1_use1_C0；
output [7：0] rd2_data_C1；
input [3：0] rd2_addr_C0；
input rd2_use1_C0；
input [3：0] wd_addr_C0；
input wd_def1_C0；
input wd_def2_C0；
input [7：0] wd_data_C1；
input [7：0] wd_data_C2；
input wd_wen_C1；
input wd_wen_C2；
input Kill_E；
input KillPipe_W；
output Stall_R；
input clk；
wire rd0_use2_C0＝1′d0；
wire rd1_use2_C0＝1′d0；
wire rd2_use2_C0＝1′d0；
wire kill_C0＝KillPipe_W；
wire kill_C1＝KillPipe_W|Kill_E；
wire kill_C2＝KillPipe_W；
wire kill_C3＝KillPipe_W；
//write definition pipeline
wire wd_ns_def1_C0＝wd_def1_C0 & 1′b1 & -kill_C0；
wire wd_def1_C1；
xtdelay1 #(1) iwd_def1_C1(wd_def1_C1，wd_ns_def1_C0，clk)；
wire wd_ns_def2_C0＝wd_def2_C0 & 1′b1 & -kill_C0；
wire wd_def2_C1；
xtdelay1 #(1) iwd_def2_C1(wd_def2_C1，wd_ns_def2_C0，clk)；
wire wd_ns_def2_C1＝wd_def2_C1 & wd_wen_C1 & -kill_C1；
wire wd_def2_C2；
xtdelay1 #(1) iwd_def2_C2(wd_def2_C2，wd_ns_def2_C1，clk)；
//write enable pipeline
wire wd_we_C2；
wire wd_we_C3；
wire wd_ns_we_C1＝(1′d0|(wd_def1_C1 & wd_wen_C1)) & -kill_C1；
wire wd_ns_we_C2＝(wd_we_C2|(wd_def2_C2 & wd_wen_C2)) & -kill_C2；
wire wd_ns_we_C3＝(wd_we_C3|(1′d0 & 1′d0)) & -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)；
// write address pipeline
wire [3：0] wd_addr_C1；
wire [3：0] wd_addr_C2；
wire [3：0] wd_addr_C3；
<dp n="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)；
// write data pipeline
wire [7：0] wd_result_C2；
wire [7：0] wd_result_C3；
wire [7：0] wd_mux_C1＝wd_data_C1；
wire [7：0] wd_mux_C2＝wd_def2_C2？wd_data_C2：wd_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 [7：0] rd0_data_C0；
wire [7：0] rd1_data_C0；
wire [7：0] rd2_data_C0；
// Read bypass controls for port rd0
wire bypass_data_rd0_C0_wd_C1＝(wd_addr_C1＝＝rd0_addr_C0) &
wd_def1_C1 & wd_wen_C1 & -kill_C1；
wire bypass_data_rd0_C0_wd_C2＝(wd_addr_C2＝＝rd0_addr_C0) &
wd_def2_C2 & wd_wen_C2 & -kill_C2；
wire bypass_result_rd0_C0_wd_C2＝(wd_addr_C2＝＝rd0_addr_C0) &
wd_we_C2 & -kill_C2；
wire bypass_result_rd0_C0_wd_C3＝(wd_addr_C3＝＝rd0_addr_C0) &
wd_we_C3 & -kill_C3；
// Read bypass for port rd0 use 1
wire [7：0] 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 [7：0] rd0_mux_C0；
wire [1：0] 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)；
// Read bypass controls for port rd1
wire bypass_data_rd1_C0_wd_C1＝(wd_addr_C1＝＝rd1_addr_C0) &
wd_def1_C1 & wd_wen_C1 & -kill_C1；
wire bypass_data_rd1_C0_wd_C2＝(wd_addr_C2＝＝rd1_addr_C0) &
wd_def2_C2 & wd_wen_C2 & -kill_C2；
wire bypass_result_rd1_C0_wd_C2＝(wd_addr_C2＝＝rd1_addr_C0) &
wd_we_C2 & -kill_C2；
wire bypass_result_rd1_C0_wd_C3＝(wd_addr_C3＝＝rd1_addr_C0) &
wd_we_C3 & -kill_C3；
// Read bypass for port rd1 use 1
wire [7：0] 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 [7：0] rd1_mux_C0；
wire [1：0] 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：
<dp n="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)；
// Read bypass controls for port rd2
wire bypass_data_rd2_C0_wd_C1＝(wd_addr_C1＝＝rd2_addr_C0) &
wd_def1_C1 & wd_wen_C1 & -kill_C1；
wire bypass_data_rd2_C0_wd_C2＝(wd_addr_C2＝＝rd2_addr_C0) &
wd_def2_C2 & wd_wen_C2 & -kill_C2；
wire bypass_result_rd2_C0_wd_C2＝(wd_addr_C2＝＝rd2_addr_C0) &
wd_we_C2 & -kill_C2；
wire bypass_result_rd2_C0_wd_C3＝(wd_addr_C3＝＝rd2_addr_C0) &
wd_we_C3 & -kill_C3；
// Read bypass for port rd2 use 1
wire [7：0] 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 [7：0] rd2_mux_C0；
wire [1：0] 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)；
assign Stall R＝
((wd_addr_C1＝＝rd0_addr_C0)&(
(rd0_use1_C0 & (wd_ns_def2_C1))))|
((wd_addr_C1＝＝rd1_addr_C0) & (
(rd1_use1_C0 & (wd_ns_def2_C1))))|
((wd_addr_C1＝＝rd2_addr_C0) & (
(rd2_use1_C0 & (wd_ns_def2_C1))))|
1′b0；
// register file core
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)；
endmodule
module xmTIE_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 [7：0] ps_data_C1；
input ps_width8_C0；
input ps_use1_C0；
input ns_width8_C0；
input ns_def1_C0；
input [7：0] ns_data8_C1；
input ns_wen_C1；
input Kill_E；
input KillPipe_W；
output Stall_R；
<dp n="d139"/>
input clk；
wire ps_addr_C0＝1′d0；
wire ns_addr_C0＝1′d0；
wire ns_wen_C2＝1′d1；
/***********************************************************************
READ PORT ps
***********************************************************************/
// compute the address mask
wire ps_addr_mask_C0＝1′d0；
// masked address pipeline
wire ps_maddr_C0＝1′d0；
// bank-qualified use
wire ps_use1_bank0_C0＝(ps_use1_C0 & (ps_maddr_C0＝＝(1′d0 &
ps_addr_mask_C0)))；
// alignment mux for use 1
wire [7：0] ps_data bank0_C1；
assign ps_data_C1[7：0]＝ps_data_bank0_C1；
/***********************************************************************
WRITE PORT ns
***********************************************************************/
// compute the address mask
wire ns_addr_mask_C0＝1′d0；
// bank-qualified write def for port ns
wire ns_def1_bank0_C0＝(ns_def1_C0 & ((ns_addr_C0 & ns_addr mask_C0)
＝＝(1′d0 & ns_addr_mask_C0)))；
// write mux for def 1
wire [7：0] ns_wdata_C1；
assign ns_wdata_C1＝{1{ns_data8_C1[7：0]}}；
wire Stall_R0；
/***********************************************************************
PIPELINED BANK
***********************************************************************/
xmTIE_gfmod_State_bank TIE_gfmod_State_bank0(ps_data_bank0_C1，
ps_use1_bank0_C0，ns_def1_bank0_C0，ns_wdata_C1[7：0]，ns_wen_C1，
ns_wen_C2，Kill_E，KillPipe_W，Stall_R0，clk)；
assign Stall_R＝Stall_R0 | 1′b0；
endmodule
module xmTIE_gfmod_State_bank(ps_data_C1，ps_use1_C0，ns_def1_C0，
ns_data_C1，
<dp n="d140"/>
ns_wen_C1，ns_wen_C2，Kill_E，KillPipe_W，Stall_R，clk)；
output [7：0] ps_data_C1；
input ps_use1_C0；
input ns_def1_C0；
input [7：0] ns_data_C1；
input ns_wen_C1；
input ns_wen_C2；
input Kill_E7
input KillPipe_W；
output Stall_R；
input clk；
wire ps_addr_C0＝1′d0；
wire ps_use2_C0＝1′d0；
wire ns_addr_C0＝1′d0；
wire ns_def2_C0＝1′d0；
wire [7：0] ns_data_C2＝0；
wire kill_C0＝KillPipe_W；
wire kill_C1＝KillPipe_W | Kill_E；
wire kill_C2＝KillPipe_W；
wire kill_C3＝KillPipe_W；
// write definition pipeline
wire ns_ns_def1_C0＝ns_def1_C0 & 1′b1 & -kill_C0；
wire ns_def1_C1；
xtdelay1 #(1) ins_def1_C1(ns_def1_C1，ns ns def1_C0，clk)；
wire ns_ns_def2_C0＝1′d0；
wire ns_def2_C1＝1′d0；
wire ns_ns_def2_C1＝1′d0；
wire ns_def2_C2＝1′d0；
// write enable pipeline
wire ns_we_C2；
wire ns_we_C3；
wire ns_ns_we_C1＝(1′d0|(ns_def1_C1 & ns_wen_C1)) & -kill_C1；
wire ns_ns_we_C2＝(ns_we_C2 | (ns_def2_C2 & ns_wen_C2)) & -kill_C2；
wire ns_ns_we_C3＝(ns_we_C3|(1′d0 & 1′d0)) & -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)；
// write address pipeline
wire ns_addr_C1；
wire ns_addr_C2；
wire ns_addr_C3；
assign ns_addr_C1＝1′d0；
assign ns_addr_C2＝1′d0；
assign ns_addr_C3＝1′d0；
// write data pipeline
wire [7：0] ns_result_C2；
wire [7：0] ns_result_C3；
wire [7：0] ns_mux_C1＝ns_data_C1；
wire [7：0] ns_mux_C2＝ns_def2_C2？ns_data_C2：ns_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[7：0]ps_data_C0；
// Read bypass controls for port ps
<dp n="d141"/>
wire bypass_data_ps_C0_ns_C1＝(ns_addr_C1＝＝ps_addr_C0) & ns_def1_C1
& ns_wen_C1 & -kill_C1；
wire bypass_result_ps_C0_ns_C2＝(ns_addr_C2＝＝ps_addr_C0) & ns_we_C2
& -kill_C2；
wire bypass_result_ps_C0_ns_C3＝(ns_addr_C3＝＝ps_addr_C0) & ns_we_C3
& -kill_C3；
// Read bypass for port ps use 1
wire [7：0] 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[7：0]ps_mux_C0；
wire[0：0]ps_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)；
assign Stall_R＝
((ns_addr_C1＝＝ps_addr_C0) & (
(ps_use1_C0&(ns_ns_def2_C1))))|
1′b0；
// register file core
xtregfile_1R1W_1 #(8) icore(ps_data_C0，ns_result_C3，ns_ns_we_C3，
clk)；
endmodule
module xmTIE_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，
<dp n="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
)；
output GFADD8；
output GFADD8I；
output GFMULX8；
output GFRWMOD8；
output LGF8_I；
output SGF8_I；
output LGF8_IU；
output SGF8_IU；
output LGF8_X；
output SGF8_X；
output LGF8_XU；
output SGF8_XU；
output RUR0；
output WUR0；
output [31：0] imm4；
<dp n="d143"/>
output [7：0] imm8；
output art_use；
output art_def；
output ars_use；
output ars_def；
output arr_use；
output arr_def；
output br_use；
output br_def；
output bs_use；
output bs_def；
output bt_use；
output bt_def；
output bs4_use；
output bs4_def；
output bs8_use；
output bs8_def；
output gr_use；
output gr_def；
output gs_use；
output gs_def；
output gt_use；
output gt_def；
output gfmod_use1；
output gfmod_def1；
output AR_rd0_use1；
output AR_rd0_width32；
output AR_rd1_use1；
output AR_rd1_width32；
output AR_wd_def1；
output AR_wd_width32；
output[3：0]gf_rd0_addr；
output gf_rd0_use1；
output gf_rd0_width8；
output[3：0]gf_rd1_addr；
output gf_rd1_use1；
output gf_rd1_width8；
output [3：0] gf_rd2_addr；
output gf_rd2_use1；
output gf_rd2_width8；
output [3：0] gf_wd_addr；
output gf_wd_def2；
output gf_wd_def1；
output gf_wd_width8；
output gf1_semantic；
output gf4_semantic；
output gf2_semantic；
output gf3_semantic；
output lgf_semantic；
output sgf_semantic；
output RUR0_semantic；
output WUR0_semantic；
output load_instruction；
output store_instruction；
output TIE_Inst；
input [23：0] Inst；
wire [3：0] op2＝{Inst[23：20]}；
wire [3：0] op1＝{Inst[19：16]}；
wire [3：0] op0＝{Inst[3：0]}；
<dp n="d144"/>
wire QRST＝(op0＝＝4′b0000)；
wire CUST0＝(op1＝＝4′b0110) & QRST；
assign GFADD8＝(op2＝＝4′b0000) & CUST0；
assign GFADD8I＝(op2＝＝4′b0100) & CUST0；
assign GFMULX8＝(op2＝＝4′b0001) & CUST0；
assign GFRWMOD8＝(op2＝＝4′b0010) & CUST0；
wire [3：0] r＝{Inst[15：12]}；
wire LSCI＝(op0＝＝4′b0011)；
assign LGF8_I＝(r＝＝4′b0000) & LSCI；
assign SGF8_I＝(r＝＝4′b0001) & LSCI；
assign LGF8_IU＝(r＝＝4′b0010) & LSCI；
assign SGF8_IU＝(r＝＝4′b0011) & LSCI；
wire LSCX＝(op1＝＝4′b1000) & QRST；
assign LGF8_X＝(op2＝＝4′b0000) & LSCX；
assign SGF8_X＝(op2＝＝4′b0001) & LSCX；
assign LGF8_XU＝(op2＝＝4′b0010) & LSCX；
assign SGF8_XU＝(op2＝＝4′b0011) & ISCX；
wire [3：0] s＝{Inst [11：8]}；
wire [3：0] t＝{Inst [7：4]}；
wire [7：0] st＝{s，t}；
wire RST3＝(op1＝＝4′b0011) & QRST；
wire RUR＝(op2＝＝4′b1110) & RST3；
assign RUR0＝(st＝＝8′b00000000) & RUR；
wire [7：0] sr＝{r，s}；
wire WUR＝(op2＝＝4′b1111) & RST3；
assign WUR0＝(sr＝＝8′b00000000) & WUR；
assign gfmod_use1＝GFMULX8 | GFRWMOD8 | RUR0 | 1′b0；
assign gfmod_def1＝GFRWMOD8 | WUR0 | 1′b0；
assign AR_rd0_use1＝1′b0
| LGF8_I
| SGF8_I
| LGF8_IU
| SGF8_IU
| LGF8_X
| SGF8_X
| LGF8_XU
| SGF8_XU；
assign AR_rd0_width32＝1′b0；
assign AR_rd1_use1＝1′b0
| LGF8_X
| SGF8_x
| GF8_XU
| SGF8_XU
| WUR0；
assign AR_rd1_width32＝1′b0；
assign AR_wd_def1＝1′b0
| LGF8_IU
| SGF8_IU
| LGF8_XU
| SGF8_XU
| RUR0；
assign AR_wd_width32＝1′b0；
assign gf_rd0_use1＝1′b0
| GFADD8
| GFADD8I
| GFMULX8；
assign gf_rd0_width8＝1′b0；
assign gf_rd1_use1＝1′b0
| GFADD8
| GFRWMOD8
<dp n="d145"/>
| SGF8_I
| SGF8_IU；
assign gf_rd1_width8＝1′b0；
assign gf_rd2_use1＝1′b0
| SGF8_X
| SGF8_XU；
assign gf_rd2_width8＝1′b0；
assign gf_wd_def2＝1′b0
| LGF8_I
| LGF8_IU
| LGF8_X
| LGF8_XU；
assign gf_wd_def1＝1′b0
| GFADD8
| GFADD8I
| GFMULX8
| GFRWMOD8；
assign gf_wd_width8＝1′b0；
assign art_def＝1′b0；
assign art_use＝LGF8_X|SGF8_X|LGF8_XU|SGF8_XU|WUR0|1′b0；
assign ars_def＝LGF8_IU|SGF8_IU|LGF8_XU|SGF8_XU|1′b0；
assign ars_use＝LGF8_I|SGF8_I|LGF8_IU|SGF8_IU|LGF8_X|SGF8_X|
LGF8_XU|SGF8_XU|1′b0；
assign arr_def＝RUR0|1′b0；
assign arr_use＝1′b0；
assign br_def＝1′b0；
assign br_use＝1′b0；
assign bs_def＝1′b0；
assign bs_use＝1′b0；
assign bt_def＝1′b0；
assign bt_use＝1′b0；
assign bs4_def＝1′b0；
assign bs4_use＝1′b0；
assign bs8_def＝1′b0；
assign bs8_use＝1′b0；
assign gr_def＝GFADD8|GFADD8I|GFMULX8|LGF8_X|LGF8XU|1′b0；
assign gr_use＝SGF8_X|SGF8_XU|1′b0；
assign gs_def＝1′b0；
assign gs_use＝GFADD8|GFADD8I|GFMULX8|1′b0；
assign gt_def＝GFRWMOD8|LGF8_I|LGF8_IU|1′b0；
assign gt_use＝GFADD8|GFRWMOS8|SGF8_I|SGF8_IU|1′b0；
wire [3：0] gr_addr＝r；
wire [3：0] gs_addr＝s；
wire [3：0] gt_addr＝t；
assign gf_wd_addr＝4′b0
|{4{gr_def}} & gr_addr
|{4{gt_def}} & gt_addr；
assign gf_rd0_addr＝gs_addr；
assign gf_rd1_addr＝gt_addr；
assign gf_rd2_addr＝gr_addr；
assign gf1_semantic＝GFADD8|1′b0；
assign gf4_semantic＝GFADD8I|1′b0；
assign gf2_semantic＝GFMULX8|1′b0；
assign gf3_semantic＝GFRWMOD8|1′b0；
assign Igf_semantic＝LGF8_I|LGF8_IU|LGF8_X|LGF8_XU|1′b0；
assign sgf_semantic＝SGF8_I|SGF8_IU|SGF8_X|SGF8_XU|1′b0；
assign RUR0_semantic＝RUR0|1′b0；
assign WUR0_semantic＝ WUR0|1′b0；
assign imm4＝t；
wire [7：0] imm8＝{Inst[23：6]}；
<dp n="d146"/>
assign load instruction＝1′b0
| LGF8_I
| LGF8_IU
| LGF8_X
| LGF8_XU；
assign store_instruction＝1′b0
| SGF8_I
| SGF8_IU
| SGF8_X
assign TIE_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
moduule xmTIE_gf1(
GFADD8_C0，
gr_o_C1，
gr_kill_C1，
gs_i_C1，
gt_i_C1，
clk
)；
input GFADD8_C0；
output [7：0] gr_o_C1；
output gr_kill_C1；
input [7：0] gs_i_C1；
input [7：0] gt_i_C1；
input clk；
assign gr_o_C1＝(gs_i_C1)^(gt_i_C1)；
wire GFADD8_C1；
xtdelay1 #(1) iGFADD8 C1(.xtin(GFADD8_C0)，.xtout(GFADD8_C1)，.clk(clk))；
assign gr_kill_C1＝(1′b0) & (GFADD8_C1)；
endmodule
module xmTIE_gf4(
GFADD8I_C0，
gr_o_C1，
gr_kill_C1，
gs_i_C1，
imm4_C0，
clk
)；
input GFADD8I_C0；
output [7：0] gr_o_C1；
output gr_kill_C1；
input [7：0] gs_i_C1；
input [31：0] imm4_C0；
<dp n="d147"/>
input clk；
wire[31：0]imm4_C1；
xtdelay1 #(32) iimm4_C1(.xtin(imm4_C0)，.xtout(imm4_C1)，.clk(clk))；
assign gr_o_C1＝(gs_i_C1)^(imm4_C1)；
wire GFADD8I_C1；
xtdelay1 #(1) iGFADD8I_C1(.xtin(GFADD8I_C0)，.xtout(GFADD8I_C1)，
.clk(clk))；
assign gr_kill_C1＝(1′b0) & (GFADD8I_C1)；
endmodule
module xmTIE_gf2(
GFMULX8_C0，
gr_o_C1，
gr_kill_C1，
gs_i_C1，
gfmod_ps_C1，
clk
)；
input GFMULX8_C0；
output [7：0] gr_o_C1；
output gr_kill_C1；
input [7：0] gs_i_C1；
input [7：0] gfmod_ps_C1；
input clk；
assign gr_o_C1＝(gs_i_C1[7])？(({gs_i_C1[6：0]，1′b0})^(gfmod_ps_C1))：
({gs_i_C1[6：0]，1′b0})；
wire GFMULX8_C1；
xtdelay1 #(1) iGFMULX8_C1(.xtin(GFMULX8_C0)，.xtout(GFMULX8_C1)，
.clk(clk))；
assign gr_kill_C1＝(1′b0) & (GFMULX8_C1)；
endmodule
module xmTIE_gf3(
GFRWMOD8_C0，
gt_i_C1，
gt_o_C1，
gt_kill_C1，
gfmod_ps_C1，
gfmod_ns_C1，
gfmod_kill_C1，
clk
)；
input GFRWMOD8_C0；
input [7：0] gt_i_C1；
output [7：0] gt_o_C1；
output gt_kill_C1；
input [7：0] gfmod_ps_C1；
output [7：0] gfmod_ns_C1；
output gfmod_kill_C1；
input clk；
wire [7：0] t1_C1；
assign t1_C1＝gt_i_C1；
wire [7：0] t2_C1；
assign t2_C1＝gfmod_ps_C1；
assign gfmod_ns_C1＝t1_C1；
assign gt_o_C1＝t2_C1；
wire GFRWMOD8_C1；
xtdelay1 #(1) iGFRWMOD8_C1(.xtin(GFRWMOD8_C0)，.xtout(GFRWMOD8_C1)，
.clk(clk))；
assign gfmod_kill_C1＝(1′b0) & (GFRWMOD8_C1)；
<dp n="d148"/>
assign gt_kill_C1＝(1′b0) & (GFRWMOD8_C1)；
endmodule
module xmTIE_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
)；
input LGF8_I_C0；
input LGF8_IU_C0；
input LGF8_X_C0；
input LGF8_XU_C0；
output [7：0] gt_o_C2；
output gt_kill_C2；
input [31：0] ars_i_C1；
output [31：0] ars_o_C1；
output ars_kill_C1；
input [7：0] imm8_C0；
output [7：0] gr_o_C2；
output gr_kill_C2；
input [31：0] art_i_C1；
input [7：0] MemDataIn8_C2；
input [31：0] VAddrIn_C1；
output [4：0] LSSize_C0；
output [31：0] VAddrBase_C1；
output [31：0] VAddrIndex_C1；
output [31：0] VAddrOffset_C0；
output LSIndexed_C0；
input clk；
wire indexed_C0；
assign indexed_C0＝(LGF8_X_C0)|(LGF8_XU_C0)；
assign LSSize_C0＝32′h1；
assign VAddrBase_C1＝ars_i_C1；
assign LSIndexed_C0＝indexed_C0；
assign VAddrOffset_C0＝imm8_C0；
assign VAddrIndex_C1＝art_i_C1；
assign gt_o_C2＝MemDataIn8_C2；
assign gr_o_C2＝MemDataIn8_C2；
assign ars_o_C1＝VAddrIn_C1；
wire LGF8_I_C2；
xtdelay2 #(1) iLGF8_I_C2(.xtin(LGF8_I_C0)，.xtout(LGF8_I_C2)，.clk(clk))；
wire LGF8_IU_C2；
<dp n="d149"/>
xtdelay2 #(1) iLGF8_IU_C2(.xtin(LGF8_IU_C0)，.xtout(LGF8_IU_C2)
.clk(clk))；
assign gt_kill_C2＝(1′b0) & ((LGF8_I_C2)|(LGF8_IU_C2))；
wire LGF8_IU_C1；
xtdelay1 #(1) iLGF8_IU_C1(.xtin(LGF8_IU_C0)，.xtout(LGF8_IU_C1)
.clk(clk))；
wire LGF8_XU_C1；
xtdelay1 #(1) iLGF8_XU_C1(.xtin(LGF8_XU_C0)，.xtout(LGF8_XU_C1)
.clk(clk))；
assign ars_kill_C1＝(1′b0) & ((LGF8_IU_C1)|(LGF8_XU_C1))；
wire LGF8_X_C2；
xtdelay2 #(1) iLGF8_X_C2(.xtin(LGF8_X_C0)，.xtout(LGF8_X_C2)，.clk(clk))；
wire LGF8_XU_C2；
xtdelay2 #(1) iLGF8_XU_C2(.xtin(LGF8_XU_C0)，.xtout(LGF8_XU_C2)，
.clk(clk))；
assign gr_kill_C2＝(1′b0) & ((LGF8_X_C2)|(LGF8_XU_C2))；
endmodule
module xmTIE_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
)；
input SGF8_I_C0；
input SGF8_IU_C0；
input SGF8_X_C0；
input SGF8_XU_C0；
input [7：0] gt_i_C1；
input [31：0] ars_i_C1；
output [31：0] ars_o_C1；
output ars_kill_C1；
input [7：0] imm8_C0；
input [7：0] gr_i_C1；
input [31：0] art_i_C1；
input [31：0] VAddrIn_C1；
output [4：0] LSSize_C0；
output [7：0] MemDataOut8_C1；
output [31：0] VAddrBase_C1；
output [31：0] VAddrIndex_C1；
output [31：0] VAddrOffset_C0；
output LSIndexed_C0；
input clk；
wire indexed_C0；
assign indexed_C0＝(SGF8_X_C0)|(SGF8_XU_C0)；
<dp n="d150"/>
assign LSSize_C0＝32′h1；
assign VAddrBase_C1＝ars_i_C1；
assign LSIndexed_C0＝indexed_C0；
assign VAddrOffset_C0＝imm8_C0；
assign VAddrIndex_C1＝art_i_C1；
wire SGF8_X_C1；
xtdelay1 #(1) iSGF8_X_C1(.xtin(SGF8_X_C0)，.xtout(SGF8_X_C1)，.clk(clk))；
wire SGF8_XU_C1；
xtdelay1 #(1) iSGF8_XU_C1(.xtin(SGF8_XU_C0)，.xtout(SGF8_XU_C1)，
.clk(clk))；
assign MemDataOut8_C1＝((SGF8_X_C1)|(SGF8_XU_C1))？(gr_i_C1)，
(gt_i_C1)；
assign ars_o_C1＝VAddrIn_C1；
wire SGF8_IU_C1；
xtdelay1 #(1) iSGF8_IU_C1(.xtin(SGF8_IU_C0)，.xtout(SGF8_IU_C1)，
.clk(clk))；
assign ars_kill_C1＝(1′b0) & ((SGF8_IU_C1)|(SGF8_XU_C1))；
endmodule
module xmTIE_RUR0(
RUR0_C0，
arr_o_C1，
arr_kill_C1，
gfmod_ps_C1，
clk
)；
input RUR0_C0；
output [31：0] arr_o_C1；
output arr_kill_C1；
input [7：0] gfmod_ps_C1；
input clk；
assign arr_o_C1＝{gfmod_ps_C1}；
wire RUR0_C1；
xtdelay1 #(1) iRUR0_C1(.xtin(RUR0_C0)，.xtout(RUR0_C1)，.clk(clk))；
assign arr_kill_C1＝(1′b0) & (RUR0_C1)；
endmodule
module xmTIE_WUR0(
WUR0_C0，
art_i_C1，
gfmod_ns_C1，
gfmod_kill_C1，
clk
)；
input WUR0_C0；
input [31：0] art_i_C1；
output [7：0] gfmod_ns_C1；
output gfmod_kill_C1；
input clk；
assign gfmod_ns_C1＝{art_i_C1[7：0]}；
wire WUR0_C1；
xtdelay1 #(1) iWUR0_C1(.xtin(WUR0_C0)，.xtout(WUR0_C1)，.clk(clk))；
assign gfmod_kill_C1＝(1′b0) & (WUR0 C1)；
endmodule
module xmTIE(
TIE_inst_R，
TIE_asRead_R，
TIE_atRead_R，
TIE_atWrite_R，
<dp n="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
)；
output TIE_inst_R；
output TIE_asRead_R；
output TIE_atRead_R；
output TIE_atWrite_R；
output TIE_arWrite_R；
output TIE_asWrite_R；
output TIE_aWriteM_R；
output TIE_aDataKill_E；
output [31：0] TIE_aWriteData_E；
output TIE_aDataKill_M；
output [31：0] TIE_aWriteData_M；
output TIE_Load_R；
<dp n="d152"/>
output TIE_Store_R；
output [4：0] TIE_LSSize_R；
output TIE_LSIndexed_R；
output [31：0] TIE_LSOffset_R；
input [127：0] TIE_MemLoadData_M；
output [7：0] TIE_MemStoreData8_E；
output [15：0] TIE_MemStoreData16_E；
output [31：0] TIE_MemStoreData32_E；
output [63：0] TIE_MemStoreData64_E；
output [127：0] TIE_MemStoreData128_E；
output TIE_Stall_R；
output TIE_Exception_E；
output [5：0] TIE_ExcCause_E；
output TIE_bsRead_R；
output TIE_btRead_R；
output TIE_btWrite_R；
output TIE_brWrite_R；
output TIE bsWrite_R；
output [4：0] TIE_bsReadSize_R；
output [4：0] TIE_btReadSize_R；
output [4：0] TIE_bWriteSize_R；
input [15：0] TIE_bsReadData_E；
input [15：0] TIE_btReadData_E；
output TIE_bWriteData1_E；
output [1：0] TIE_bWriteData2_E；
output [3：0] TIE_bWriteData4_E；
output [7：0] TIE_bWriteData8_E；
output [15：0] TIE_bWriteData16_E；
output TIE_bDataKill_E；
input [7：0] CPEnable；
input [23：0] Instr_R；
input [31：0] SBus_E；
input [31：0] TBus_E；
input [31：0] MemOpAddr_E；
input Kill_E；
input Except_W；
input Replay_W；
input G1WCLK；
input Reset；
// unused signals
wire TMode＝0；
// control signals
wire Killpipe_W；
wire clk；
// decoded signals
wire GFADD8_C0；
wire GFADD8I_C0；
wire GFMULX8_C0；
wire GFRWMOD8_C0；
wire LGF8_I_C0；
wire SGF8_I_C0；
wire LGF8_IU_C0；
wire SGF8_IU_C0；
wire LGF8_X_C0；
wire SGF8_X_C0；
wire LGF8_XU_C0；
wire SGF8_XU_C0；
<dp n="d153"/>
wire RUR0_C0；
wire WUR0_C0；
wire [31：0] imm4_C0；
wire [7：0] imm8_C0；
wire art_use_C0；
wire art_def_C0；
wire ars_use_C0；
wire ars_def_C0；
wire arr_use_C0；
wire arr_def_C0；
wire br_use_C0；
wire br_def_C0；
wire bs_use-C0；
wire bs_def_C0；
wire bt_use_C0；
wire bt_def_C0；
wire bs4_use_C0；
wire bs4_def_C0；
wire bs8_use_C0；
wire bs8_def_C0；
wire gr_use_C0；
wire gr_def_C0；
wire gs_use_C0；
wire gs_def_C0；
wire gt_use_C0；
wire gt_def_C0；
wire gfmod_use1_C0；
wire gfmod_def1_C0；
wire AR_rd0_use1_C0；
wire AR_rd0_width32_C0；
wire AR_rd1_use1_C0；
wire AR_rd1_width32_C0；
wire AR_wd_def1_C0；
wire AR_wd_width32_C0；
wire [3：0] gf_rd0_addr_C0；
wire gf_rd0_use1_C0；
wire gf_rd0_width8_C0；
wire [3：0] gf_rd1_addr_C0；
wire gf_rd1_use1_C0；
wire gf_rd1_width8_C0；
wire [3：0] gf_rd2_addr_C0；
wire gf_rd2_use1-C0；
wire gf_rd2_width8_C0；
wire [3：0] gf_wdaddr_C0；
wire gf_wd_def2_C0；
wire gf_wd_def1_C0；
wire gf_wd_width8_C0；
wire gf1_semantic C0；
wire gf4_semantic_C0；
wire gf2_semantic_C0；
wire gf3_semantic_C0；
wire lgf_semantic_C0；
wire sgf_semantic_C0；
wire RUR0_semantic_C0；
wire WUR0_semantic_C0；
wire load_instruction_C0；
wire store_instruction_C0；
wire TIE_Inst_C0；
wire [23：0] Inst_C0；
<dp n="d154"/>
// state data，write-enable and stall signals
wire [7：0] gfmod_ps_C1；
wire [7：0] gfmod_ns_C1；
wire gfmod_kill_C1；
wire gfmod_Stall_C1；
// register data，write-enable and stall signals
wire [31：0] AR_rd0_data_C1；
wire [31：0] AR_rd1_data_C1；
wire [31：0] AR_wd_data32_C1；
wire AR_wd_kill_C1；
wire [7：0] gf_rd0_data_C1；
wire [7：0] gf_rd1_data_C1；
wire [7：0] gf_rd2_data_C1；
wire [7：0] gf_wd_data8_C2；
wire gf_wd_kill_C2；
wire [7：0] gf_wd_data8_C1；
wire gf_wd_kill_C1；
wire gf_Stall_C1；
// operands
wire [31：0] art_i_C1；
wire [31：0] art_o_C1；
wire art_kill_C1；
wire [31：0] ars_i_C1；
wire [31：0] ars_o_C1；
wire ars_kill_C1；
wire [31：0] arr_o_C1；
wire arr_kill_C1；
wire [7：0] gr_i_C1；
wire [7：0] gr_o_C2；
wire gr_kill_C2；
wire [7：0] gr_o_C1；
wire gr_kill_C1；
wire [7：0] gs_i_C1；
wire [7：0] gt_i_C1；
wire [7：0] gt_o_C2；
wire gt_kill_C2；
wire [7：0] gt_o_C1；
wire gt_kill_C1；
// output state of semantic gf1
// output interface of semantic gf1
// output operand of semantic gf1
wire [7：0] gf1_gr_o_C1；
wire gf1_gr_kill_C1；
// output state of semantic gf4
// output interface of semantic gf4
// output operand of semantic gf4
wire [7：0] gf4_gr_o_C1；
wire gf4_gr_kill_C1；
// output state of semantic gf2
// output interface of semantic gf2
<dp n="d155"/>
// output operand of semantic gf2
wire [7：0] gf2_gr_o_C1；
wire gf2_gr_kill_C1；
// output state of semantic gf3
wire [7：0] gf3_gfmod_ns_C1；
wire gf3_gfmod_kill_C1；
// output interface of semantic gf3
// output operand of semantic gf3
wire [7：0] gf3_gt_o_C1；
wire gf3_gt_kill_C1；
// output state of semantic lgf
// output interface of semantic lgf
wire [4：0] lgf_LSSize_C0；
wire [31：0] lgf_VAddrBase_C1；
wire [31：0] lgf_VAddrIndex_C1；
wire [31：0] lgf_VAddrOffset_C0；
wire lgf_LSIndexed_C0；
// output operand of semantic lgf
wire [7：0] lgf_gt_o_C2；
wire lgf_gt_kill_C2；
wire [31：0] lgf_ars_o_C1；
wire lgf_ars_kill_C1；
wire [7：0] lgf_gr_o_C2；
wire lgf_gr_kill_C2；
// output state of semantic sgf
// output interface of semantic sgf
wire [4：0] sgf_LSSize_C0；
wire [7：0] sgf_MemDataOut8_C1；
wire [31：0] sgf_VAddrBase_C1；
wire [31：0] sgf_VAddrIndex_C1；
wire [31：0] sgf_VAddrOffset_C0；
wire sgf_LSIndexed_C0；
// output operand of semantic sgf
wire [31：0] sgf_ars_o_C1；
wire sgf_ars_kill_C1；
// output state of semantic RUR0
// output interface of semantic RUR0
// output operand of semantic RUR0
wire [31：0] RUR0_arr_o_C1；
wire RUR0_arr_kill_C1；
// output state of semantic WUR0
wire [7：0] WUR0_gfmod_ns_C1；
wire WUR0_gfmod_kill_C1；
// output interface of semantic WUR0
<dp n="d156"/>
// outputoperand of semantic WUR0
// TIE-defined interface signals
wire [31：0] VAddr_C1；
wire [31：0] VAddrBase_C1；
wire [31：0] VAddrOffset_C0；
wire [31：0] VAddrIndex_C1；
wire [31：0] VAddrIn_C1；
wire [4：0] LSSize_C0；
wire LSIndexed_C0；
wire [127：0] MemDataIn128_C2；
wire [63：0] MemDataIn64_C2；
wire [31：0] MemDataIn32_C2；
wire [15：0] MemDataIn16_C2；
wire [7：0] MemDataIn8_C2；
wire [127：0] MemDataOut128_C1；
wire [63：0] MemDataOut64_C1；
wire [31：0] MemDataOut32_C1；
wire [15：0] MemDataOut16_C1；
wire [7：0] MemDataOut8_C1；
wire Exception_C1；
wire [5：0] ExcCause_C1；
wire [7：0] CPEnable_C1；
xtflop #(1) reset(localReset，Reset，G1WCLK)；
xmTIE decoder TIE_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)，
<dp n="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_gf1 TIE_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_gf4 TIE_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_gf2 TIE_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)，
<dp n="d158"/>
.gfmod_ps_C1(gfmod_ps_C1)，
.clk(clk))；
xmTIE_gf3 TIE_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_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_sgf TIE_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_RUR0 TIE_RUR0(
.RUR0_C0(RUR0_C0)，
.arr_o_C1(RUR0_arr_o_C1)，
<dp n="d159"/>
.arr_kill_C1(RUR0_arr_kill_C1)，
.gfmod_ps_C1(gfmod_ps_C1)，
.clk(clk))；
xmTIE_WUR0 TIE_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_State TIE_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_Regfile TIE_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)
)；
// Stall logic
assign TLE_Stall_R＝1′b0
|gf_Stall_C1
|gfmod_Stall_C1；
// pipeline semantic select signals to each stage
wire lgf_semantic_C1；
<dp n="d160"/>
xtdelay1 #(1) ilgf_semantic_C1(.xtin(lgf_semantic_C0)，
.xtout(lgf_semantic_C1)，.clk(clk))；
wire sgf_semantic_C1；
xtdelay1 #(1) isgf_semantic_C1(.xtin(sgf_semantic_C0)，
.xtout(sgf_semantic_C1)，.clk(clk))；
wire gf3_semantic_C1；
xtdelay1 #(1) igf3_semantic C1(.xtin(gf3_semantic_C0)，
.xtout(gf3_semantic_C1)，.clk(clk))；
wire WUR0_semantic_C1；
xtdelay1 #(1) iWUR0_semantic_C1(.xtin(WUR0_semantic_C0)，
.xtout(WUR0_semantic_C1)，.clk(clk))；
wire RUR0_semantic_C1；
xtdelay1 #(1) iRUR0_semantic_C1(.xtin(RUR0_semantic_C0)，
.xtout(RUR0_semantic_C1)，.clk(clk))；
wire lgf_semantic_C2；
xtdelay2 #(1) ilgf_semantic_C2(.xtin(lgf_semantic_C0)，
.xtout(lgf_semantic_C2)，.clk(clk))；
wire gf1_semantic_C1；
xtdelay1 #(1) igf1_semantic_C1(.xtin (gf1_semantic_C0)，
.xtout(gf1_semantic_C1)，.clk(clk))；
wire gf4_semantic_C1；
xtdelay1 #(1) igf4_semantic_C1(.xtin(gf4_semantic_C0)，
.xtout(gf4_semantic_C1)，.clk(clk))；
wire gf2_semantic_C1；
xtdelay1 #(1) igf2_semantic_C1(.xtin(gf2_semantic_C0)，
.xtout(gf2_semantic_C1)，.clk(clk))；
// combine output interface signals from all semantics
assign VAddr_C1＝32′b0；
assign VAddrBase_C1＝32′b0
|(lgf_VAddrBase_C1 & {32{lgf_semantic_C1}})
|(sgf_VAddrBase_C1 & {32{sgf_semantic_C1}})；
assign VAddrOffset_C0＝32′b0
|(lgf_VAddrOffset_C0 & {32{lgf_semantic_C0}})
|(sgf_VAddrOffset_C0 & {32{sgf_semantic_C0}})；
assign VAddrIndex_C1＝32′b0
|(lgf_VAddrIndex_C1 & {32{lgf_semantic_C1}})
|(sgf_VAddrIndex_C1 & {32{sgf_semantic_C1}})；
assign LSSize_C0＝5′b0
|(lgf_LSSize_C0 & {5{lgf_semantic_C0}})
|(sgf_LSSize_C0 & {5{sgf_semantic_C0}})；
assign LSIndexed C0＝1′b0
|(lgf_LSIndexed_C0 & lgf_semantic_C0)
|(sgf_LSIndexed_C0 & sgf_semantic_C0)；
assign MemDataOut128_C1＝128′b0；
assign MemDataOut64_C1＝64′b0；
assign MemDataOut32_C1＝32′b0；
assign MemDataOut16_C1＝16′b0；
assign MemDataOut8_C1＝8′b0
|(sgf_MemDataOut8_C1 & {8{sgf_semantic_C1}})；
assign Exception_C1＝1′b0；
assign ExcCause_C1＝6′b0；
// combine output state signals from all semantics
assign gfmod_ns_C1＝8′b0
|(gf3_gfmod_ns_C1 & {8{gf3_semantic_C1}})
|(WUR0_gfmod_ns_C1 & {8{WUR0_semantic_C1}})；
assign gfmod_kill_C1＝1′b0
|(gf3_gfmod_kill_C1 & gf3_semantic_C1)
|(WUR0_gfmod_kill_C1 & WUR0_semantic_C1)；
<dp n="d161"/>
// combine output operand signals from all semantics
assign art_o_C1＝32′b0；
assign art_kill_C1＝1′b0；
assign ars_o_C1＝32′b0
|(lgf_ars_o_C1 & {32{lgf_semantic_C1}})
|(sgf_ars_o_C1 & {32{sgf_semantic_C1}})；
assign ars_kill_C1＝1′b0
|(lgf_ars_kill_C1 & lgf_semantic_C1)
|(sgf_ars_kill_C1 & sgf_semantic_C1)；
assign arr_o_C1＝32′b0
|(RUR0_arr_o_C1 & {32{RUR0_semantic_C1}})；
assign arr_kill_C1＝1′b0
|(RUR0_arr_kill_C1 & RUR0_semantic_C1)；
assign gr_o_C2＝8′b0
|(lgf_gr_o_C2 & {8{lgf_semantic_C2}})；
assign gr_kill_C2＝1′b0
|(lgf_gr_kill_C2 & lgf_semantic_C2)；
assign gr_o_C1＝8′b0
|(gf1_gr_o_C1 & {8{gf1_semantic_C1}})
|(gf4_gr_o_C1 & {8{gf4_semantic_C1}})
|(gf2_gr_o_C1 & {8{gf2_semantic_C1}})；
assign gr_kill_C1＝1′b0
|(gf1_gr_kill_C1 & gf1_semantic_C1)
|(gf4_gr_kill_C1 & gf4_semantic_C1)
|(gf2_gr_kill_C1 & gf2_semantic_C1)；
assign gt_o_C2＝8′b0
|(lgf_gt_o_C2 & {8{lgf_semantic_C2}})；
assign gt_kill_C2＝1′b0
|(lgf_gt_kill_C2 & lgf_semantic_C2)；
assign gt_o_C1＝8′b0
|(gf3_gt_o_C1 & {8{gf3_semantic_C1}})；
assign gt_kill_C1＝1′b0
|(gf3_gt_kill_C1 & gf3_semantic_C1)；
// output operand to write port mapping logic
assign AR_wd_data32_C1＝ars_o_C1|arr_o_C1|32′b0；
assign AR_wd_kill_C1＝ars_kill_C1|arr_kill_C1|1′b0；
assign gf_wd_data8_C2＝gt_o_C2|gr_o_C2|8′b0；
assign gf_wd_kill_C2＝gt_kill_C2|gr_kill_C2|1′b0；
assign gf_wd_data8_C1＝gr_o_C1|gt_o_C1|8′b0；
assign gf_wd_kill_C1＝gr_kill_C1|gt_kill_C1|1′b0；
// read port to input operand mapping logic
assign ars_i_C1＝AR_rd0_data_C1；
assign art_i_C1＝AR_rd1_data_C1；
assign gs_i_C1＝gf_rd0_data_C1；
assign gt_i_C1＝gf_rd1_data_C1；
assign gr_i_C1＝gf_rd2_data_C1；
// clock and instructions
assign clk＝G1WCLK；
assign Inst_C0＝Instr_R；
assign TIE_inst_R＝TIE_Inst_C0；
// AR-related signals to/from core
assign TIE_asRead_R＝ars_use_C0；
assign TIE_atRead_R＝art_use_C0；
assign TIE_atWrite_R＝art_def_C0；
assign TIE_arWrite_R＝arr_def_C0；
<dp n="d162"/>
assign TIE_asWrite_R＝ars_def_C0；
assign TIE_aWriteM_R＝0；
assign TIE_aWriteData_E＝AR_wd_data32_C1；
assign TIE_aWriteData_M＝0；
assign TIE_aDataKill_E＝AR_wd_kill_Ci；
assign TIE_aDataKill_M＝0；
assign AR_rd0_data_C1＝SBus_E；
assign AR_rd1_data_C1＝TBus_E；
// BR-related signals to/from core
assign TIE_bsRead_R＝1′b0|bs_use_C0|bs4_use_C0|bs8_use_C0；
assign TIE_btRead_R＝1′b0|bt_use_C0；
assign TIE_btWrite_R＝1′b0|bt_def_C0；
assign TIE_bsWrite_R＝1′b0|bs_def_C0|bs4_def_C0|bs8_def_C0；
assign TIE_brWrite_R＝1′b0|br_def_C0；
assign TIE_bWriteData16_E＝0；
assign TIE_bWriteData8_E＝0；
assign TIE_bWriteData4_E＝0；
assign TIE_bWriteData2_E＝0；
assign TIE_bWriteData1_E＝0；
assign TIE_bDataKill_E＝0；
assign TIE_bWriteSize_R＝{1′b0，1′b0，1′b0，1′b0，1′b0}；
assign TIE_bsReadSize_R＝{1′b0，1′b0，1′b0，1′b0，1′b0}；
assign TIE_btReadSize_R＝{1′b0，1′b0，1′b0，1′b0，1′b0}；
// Load/store signals to/from core
assign TIE_Load_R＝load_instruction_C0；
assign TIE_Store_R＝store_instruction_C0；
assign TIE_LSSize_R＝LSSize_C0；
assign TIE_LSIndexed_R＝LSIndexed_C0；
assign TIE_LSOffset_R＝VAddrOffset_C0；
assign TIE_MemStoreData128_E＝MemDataOut128_C1；
assign TIE_MemStoreData64_E＝MemDataOut64_C1；
assign TIE_MemStoreData32_E＝MemDataOut32_C1；
assign TIE_MemStoreData16_E＝MemDataOut16_C1；
assign TIE_MemStoreData8_E＝MemDataOut8_C1；
assign MemDataIn128_C2＝TIE_MemLoadData_M；
assign MemDataIn64_C2＝TIE_MemLoadData_M；
assign MemDataIn32_C2＝TIE_MemLoadData_M；
assign MemDataIn16_C2＝TIE_MemLoadData_M；
assign MemDataIn8_C2＝TIE_MemLoadData_M；
assign VAddrIn_C1＝MemOpAddr_E；
// CPEnable and control signals to/from core
assign CPEnable C1＝CPEnable；
assign TIE_Exception_E＝ xception_C1；
assign TIE_ExcCause_E＝ExcCause_C1；
assign KillPipe_W＝Except_W|Replay_W；
endmodule
module xtdelay1(xtout，xtin，clk)；
parameter size＝1；
output [size-1：0] xtout；
input [size-1：0] xtin；
input clk；
wire [size-1：0] t0；
xtflop #(size)i0(t0，xtin，clk)；
assign xtout＝t0；
endmodule
module xtdelay2(xtout，xtin，clk)；
<dp n="d163"/>
parameter size＝1；
output [size-1：0] xtout；
input [size-1：0] xtin；
input clk；
wire[size-1：0]t0；
xtflop #(size)i0(t0，xtin，clk)；
wire [size-1：0] t1；
xtflop #(size)i1(t1，t0，clk)；
assign xtout＝t1；
endmodule
module xtmux3p(o，d0，d1，d2，s0，s1)；
parameter size＝1；
output [size-1：0] o；
input [size-1：0] d0，d1，d2；
input s0，s1；
wire[1：0]s＝s0？0：s1？1：2；
xtmux3e #(size)i0(o，d0，d1，d2，s)；
endmodule
module xtregfile_1R1W_1(rd0_data，wr0_data，wr0_we，clk)；
parameter size＝32，addr_size＝0；
output [size-1：0] rd0_data；
input [size-1：0] wr0_data；
input wr0_we；
input clk；
wire wr0_addr＝0；
wire word0_we＝wr0_we & (wr0_addr＝＝0)；
wire [size-1：0] word0；
xtenflop #(size)iword0(word0，wr0_data，word0_we，clk)；
assign rd0_data＝word0；
endmodule
module xtregfile_3R1W_16(rd0_data，rd0_addr，rd1_data，rd1_addr，rd2_data，
rd2_addr，wr0_data，wr0_addr，wr0_we，clk)；
parameter size＝32，addr_size＝4；
output [size-1：0] rd0_data；
input [addr_size-1：0] rd0_addr；
output [size-1：0] rd1_data；
input [addr_size-1：0] rd1_addr；
output [size-1：0] rd2_data；
input [addr_size-1：0] rd2_addr；
input [size-1：0] wr0_data；
input [addr_size-1：0] wr0_addr；
input wr0_we；
input clk；
wire [size-1：0] wr0_ndata；
xtnflop #(size)iwr0_ndata(wr0_ndata，wr0_data，clk)；
wire word0_we＝wr0_we & (wr0_addr＝＝0)；
wire [size-1：0] word0；
wire gclk0；
xtclock_gate_nor xt_clock_gate_nor0(gclk0，clk，-word0_we)；
xtRFlatch #(size)iword0(word0，wr0_ndata，gclk0)；
wire word1_we＝wr0_we & (wr0_addr＝＝1)；
wire [size-1：0] word1；
wire gclk1；
<dp n="d164"/>
xtclock_gate_nor xt_clock_gate_nor1(gclk1，clk，-word1_we)；
xtRFlatch #(size) iword1(word1，wr0_ndata，gclk1)；
wire word2_we＝wr0_we & (wr0_addr＝＝2)；
wire [size-1：0] word2；
wire gclk2；
xtclock_gate_nor xt_clock_gate_nor2(gclk2，clk，-word2_we)；
xtRFlatch #(size) iword2(word2，wr0_ndata，gclk2)；
wire word3_we＝wr0_we&(wr0_addr＝＝3)；
wire[size-1：0]word3；
wire gclk3；
xtclock_gate_nor xt_clock_gate_nor3(gclk3，clk，-word3_we)；
xtRFlatch #(size) iword3(word3，wr0_ndata，gclk3)；
wire word4_we＝wr0_we & (wr0_addr＝＝4)；
wire [size-1：0] word4；
wire gclk4；
xtclock_gate_nor xt_clock_gate_nor4(gclk4，clk，-word4_we)；
xtRFlatch #(size) iword4(word4，wr0_ndata，gclk4)；
wire word5_we＝wr0_we & (wr0_addr＝＝5)；
wire [size-1：0] word5；
wire gclk5；
xtclock_gate_nor xt_clock_gate_nor5(gclk5，clk，-word5_we)；
xtRFlatch #(size) iword5(word5，wr0_ndata，gclk5)；
wire word6_we＝wr0 we & (wr0_addr＝＝6)；
wire [size-1：0] word6；
wire gclk6；
xtclock_gate_nor xt_clock_gate_nor6(gclk6，clk，-word6_we)；
xtRFlatch #(size) iword6(word6，wr0_ndata，gclk6)；
wire word7_we＝wr0_we & (wr0_addr＝＝7)；
wire [size-1：0] word7；
wire gclk7；
xtclock_gate_nor xt_clock_gate_nor7(gclk7，clk，-word7_we)；
xtRFlatch #(size) iword7(word7，wr0_ndata，gclk7)；
wire word8_we＝wr0_we & (wr0_addr＝＝8)；
wire [size-1：0] word8；
wire gclk8；
xtclock_gate_nor xt_clock_gate_nor8(gclk8，clk，-word8_we)；
xtRFlatch #(size) iword8(word8，wr0_ndata，gclk8}；
wire word9_we＝wr0_we & (wr0_addr＝＝9)；
wire [size-1：0] word9；
wire gclk9；
xtclock_gate_nor xt_clock_gate_nor9(gclk9，clk，-word9_we)；
xtRFlatch #(size) iword9(word9，wr0_ndata，gclk9)；
wire word10_we＝wr0_we & (wr0_addr＝＝10)；
wire [size-1：0] word10；
wire gclk10；
xtclock_gate_nor xt_clock_gate_nor10(gclk10，clk，-word10_we)；
xtRFlatch #(size) iword10(word10，wr0_ndata，gclk10)；
wire word11_we＝wr0_we & (wr0_addr＝＝11)；
wire [size-1：0] word11；
wire gclk11；
<dp n="d165"/>
xtclock_gate_nor xt_clock_gate_nor11(gclk11，clk，-word11_we)；
xtRFlatch #(size) iword11(word11，wr0_ndata，gclk11)；
wire word12_we＝wr0_we & (wr0_addr＝＝12)；
wire [size-1：0] word12；
wire gclk12；
xtclock_gate_nor xt_clock_gate_nor12(gclk12，clk，-word12_we)；
xtRFlatch #(size) iword12(word12，wr0_ndata，gclk12)；
wire word13_we＝wr0_we & (wr0_addr＝＝13)；
wire [size-1：0] word13；
wire gclk13；
xtclock_gate_nor xt_clock_gate_nor13(gclk13，clk，-word13_we)；
xtRFlatch #(size) iword13(word13，wr0_ndata，gclk13)；
wire word14_we＝wr0_we & (wr0_addr＝＝14)；
wire [size-1：0] word14；
wire gclk14；
xtclock_gate_nor xt_clock_gate_nor14(gclk14，clk，-word14_we)；
xtRFlatch #(size) iword14(word14，wr0_ndata，gclk14)；
wire word15_we＝wr0_we & (wr0_addr＝＝15)；
wire[size-1：0]word15；
wire gclk15；
xtclock_gate_nor xt_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，rd0 addr)；
xtmux16e #(size) rd1(rd1_data，word0，word1，word2，word3，word4，
word5，word6，word7，word8，word9，word10，word11，word12，word13，word14，
word15，rd1 addr)；
xtmux16e #(size) rd2(rd2_data，word0，word1，word2，word3，word4，
word5，word6，word7，word8，word9，word10，word11，word12，word13，word14，
word15，rd2_addr)；
endmodule
module xtmux16e(o，d0，d1，d2，d3，d4，d5，d6，d7，d8，d9，d10，d11，d12，
d13，d14，d15，s)；
parameter size＝1；
output [size-1：0] o；
input [size-1：0] d0，d1，d2，d3，d4，d5，d6，d7，d8，d9，d10，d11，d12，
d13，d14，d15；
input [3：0] s；
wire [size-1：0] t0；
xtmux4e #(size) i0(t0，d0，d1，d2，d3，{s[1]，s[0]})；
wire [size-1：0] t1；
xtmux4e #(size) i1(t1，d4，d5，d6，d7，{s[1]，s[0]})；
wire [size-1：0] t2；
xtmux4e #(size) i2(t2，d8，d9，d10，d11，{s[1]，s[0]})；
wire [size-1：0] t3；
xtmux4e #(size) i3(t3，d12，d13，d14，d15，{s[1]，s[0]})；
wire [size-1：0] t4；
xtmux4e #(size) i4(t4，t0，t1，t2，t3，{s[3]，s[2]})；
assign o＝t4；
endmodule
module xtRFenlatch(xtRFenlatchout，xtin，xten，clk)；
parameter size＝32；
<dp n="d166"/>
output [size-1：0] xtRFenlatchout；
input [size-1：0] xtin；
input xten；
input clk；
reg [size-1：0] xtRFenlatchout；
always @(clk or xten or xtin or xtRFenlatchout)begin
if(clk)begin
xtRFenlatchout＜＝ #1(xten)？xtin：xtRFenlatchout；
end
end
endmodule
module xtRFlatch(xtRFlatchout，xtin，clk)；
parameter size＝32；
output [size-1：0] xtRFlatchout；
input [size-1：0] xtin；
input clk；
reg [size-1：0] xtRFlatchout；
always @(clk or xtin)begin
if(clk)begin
xtRFlatchout＜＝ #1 xtin；
end
end
endmodule
module xtadd(xtout，a，b)；
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] a；
input [size-1：0] b；
assign xtout＝a+b；
endmodule
module xtaddc(sum，carry，a，b，c)；
parameter size＝32；
output [size-1：0] sum；
output carry；
input [size-1：0] a；
input [size-1：0] b；
input c；
wire junk；
assign{carry，sum，junk}＝{a，c}+{b，c}；
endmodule
module xtaddcin(xtout，a，b，c)；
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] a；
input [size-1：0] b；
.input c；
<dp n="d167"/>
assign xtout＝({a，c}+{b，c})＞＞1；
endmodule
module xtaddcout(sum，carry，a，b)；
parameter size＝1；
output [size-1：0] sum；
output carry；
input [size-1：0] a；
input [size-1：0] b；
assign{carry，sum}＝a+b；
endmodule
module xtbooth(out，cin，a，b，sign，negate)；
parameter size＝16；
output [size+1：0] out；
output cin；
input [size-1：0] a；
input [2：0] b；
input sign，negate；
wire ase＝sign & a [size-1]；
wire [size+1：0] ax1＝{ase，ase，a}；
wire [size+1：0] ax2＝{ase，a，1′d0}；
wire one＝b[1] ^ b[0]；
wire two＝b[2]？-b[1] & -b[0]：b[1] & b[0]；
wire cin＝negate？(-b[2] & (b[1]|b[0]))：(b[2] & -(b[1] & b[0]))；
assign out＝{size+2{cin}}^(ax1&{size+2{one}}|ax2&{size+2{two}})；
endmodule
module xtclock_gate_nor(xtout，xtin1，xtin2)；
output xtout；
input xtin1，xtin2；
assign xtout＝-(xtin1||xtin2)；
endmodule
module xtclock_gate_or(xtout，xtin1，xtin2
output xtout；
input xtin1，xtin2；
assign xtout＝(xtin1||xtin2)；
endmodule
module xtcsa(sum，carry，a，b，c)；
parameter size＝1；
output [size-1：0] sum；
output [size-1：0] carry；
input [size-1：0] a；
input [size-1：0] b；
input [size-1：0] c；
assign sum＝a^b^c；
assign carry＝(a&b)|(b&c)|(c&a)；
endmodule
module xtenflop(xtout，xtin，en，clk)；
parameter size＝32；
<dp n="d168"/>
output [size-1：0] xtout；
input [size-1：0] xtin；
input en；
input clk；
reg [size-1：0] tmp；
assign xtout＝tmp；
always @(posedge clk)begin
if(en)
tmp＜＝#1 xtin；
end
endmodule
module xtfa(sum，carry，a，b，c)；
output sum，carry；
input a，b，c；
assign sum＝a^b^c；
assign carry＝a&b|a&c|b&c；
endmodule
module xtflop(xtout，xtin，clk)；
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] xtin；
input clk；
reg [size-1：0] tmp；
assign xtout＝tmp；
always @(posedge clk) begin
tmp＜＝#1 xtin；
end
endmodule
module xtha(sum，carry，a，b)；
output sum，carry；
input a，b；
assign sum＝a^b；
assign carry＝a&b；
endmodule
module xtinc(xtout，a)；
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] a；
assign xtout＝a+1；
endmodule
module xtmux2e(xtout，a，b，sel)；
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] a；
input [size-1：0] b；
input sel；
assign xtout＝(-sel)？a：b；
endmodule
module xtmux3e(xtout，a，b，c，sel)；
<dp n="d169"/>
parameter size＝32；
output [size-1：0] xtout ；
input [size-1：0] a；
input [size-1：0] b；
input [size-1：0] c；
input [1：0] sel；
reg [size-1：0] xtout；
always @(a or b or c or sel)begin
xtout＝sel[1]？c：(sel[0]？b：a)；
end
endmddule
module xtmux4e(xtout，a，b，c，d，sel)；
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] a；
input [size-1：0] b；
input [size-1：0] c；
input [size-1：0] d；
input [1：0] sel；
reg [size-1：0] xtout；
// synopsys infer_mux＂xtmux4e＂
always @(sel or a or b or c or d)begin：xtmux4e
case(sel) //synopsys parallel_case full_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 @(sel or a or b or c or d)
endmodule
module xtnflop(xtout，xtin，clk)；
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] xtin；
input clk；
reg [size-1：0] tmp；
assign xtout＝tmp；
always @(negedge clk)begin
tmp＜＝ #1 xtin；
end // always @(negedge clk)
endmodule
module xtscflop(xtout，xtin，clrb，clk)；// sync clear ff
parameter size＝32；
output [size-1：0] xtout；
<dp n="d170"/>
input [size-1：0] xtin；
input clrb；
input clk；
reg [size-1：0] tmp；
assign xtout＝tmp；
always @(posedge clk)begin
if(！clrb)tmp＜＝0；
else tmp＜＝ #1 xtin；
end
endmodule
module xtscenflop(xtout，xtin，en，clrb，clk)；// sync clear
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] xtin；
input en；
input clrb；
input clk；
reg [size-1：0] tmp；
assign xtout＝tmp；
always @(posedge clk)begin
if(！clrb)tmp＜＝0；
else if(en)
tmp＜＝ #1 xtin；
end
endmodule
gf check.dcsh
/*
* Copyright 1999-2000 Tensilica Inc.
* These coded instructions，statements，and computer programs are
* Confidential Proprietary Information of Tensilica Inc.and may not be
* disclosed to third parties or copied in any form，in whole or in part，
* without the prior written consent of Tensilica Inc.
*/
/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝
Generic setup
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
*/
hdlin_auto_save_templates＝true
define_design_lib WORK-path workdir
define_name_rules no_slash-restrict ＂/＂-replacement_char＂_＂
verilogout_no_tri＝true
verbose_messages＝false
sh mkdir-p workdir
sh date
sh hostname
/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝
<dp n="d171"/>
Read and elaborate the design
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
*/
/*
foreach(F，{＂gf.v＂，＂gf_FF.v＂，＂gf_tlt.v＂}){
*/
foreach(F，{＂gf.v＂}){
read-f verilog＂/home/earl/tensilica/test/gf/gf.out/＂+F
/*
remove_design find(design，＂xtha＂)＞/dev/null
remove_design find(design，＂xtfa＂)＞/dev/null
remove_design find(design，＂xtmux4b＂)＞/dev/null
read-f verilog＂/home/earl/tensilica/test/gf/gf.out/prim.v＂
*/
/*
elaborate xmTIE
*/
current_design xmTIE
link
ungroup-all -flatten
check_design
remove_design find(design，＂*＂)
}
quit
gf.dcsh
/ *
* Copyright 1999-2000 Tensilica Inc.
* These coded instructions，statements，and computer programs are
* Confidential Proprietary Information of Tensilica Inc.and may not be
* disclosed to third parties or copied in any form，in whole or in part，
* without the prior written consent of Tensilica Inc.
*/
/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝
Generic setup
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
*/
hdlin auto_save_templates＝true
define_design_lib WORK-path workdir
define_name_rules no_slash-restrict＂/＂-replacement_char＂_＂
verilogout_no_tri＝true
verbose_messages＝false
sh mkdir -p workdir
sh date
sh hostname
/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝
<dp n="d172"/>
Library-specific parameters
Mostare self-explanatory.Examples for each are shown.
LIB_MAP_ONLY is a set of gates to use the＂set_map_only＂attribute for
Design Compiler.Typically this should be all 3∶1 and 4∶1 muxes and
all half-adders and full-adders.
LIB_SCAN_FLOP is a set of flops to not use for sequential mapping
because
they represent scan flops in the library.
LIB_DONT_USE can select target gates in the library not to use.
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
*/
synthetic_library＝{standard.sldb}
search_path＝search_path+{＂/cad/artisan/Phantom/synopsys/acb872＂}
target_library＝slow.db
link_library＝{＂*＂}+target_library+synthetic_library
CLOCK_PERIOD＝6.67 /* target clock period */
CLOCK_SKEW＝.35 /* estimated clock skew */
CRITICAL_RANGE＝.8 /* keep paths off-critical paths tight */
BOUNDARY_LOAD＝slow/INVX1/A /* typical load */
DRIVE_CELL＝DFFX4 /* typical drive cell name */
DRIVE_PIN＝Q /* typical drive pin name */
DRIVE_PIN_FROM＝CK /* typical drive from pin name */
OPERATING_CONDITION＝slow /* operating conditions */
WIRE_LOAD＝TSMC32K_Aggresive /* wire-load model */
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-specific parameters
TIE_DESIGN is the name of the top-level design for optimization.
Typically
it is＂xmTIE＂the root of the TIE logic. However，it can be set to any
lower-level design(e.g.，any single semantic block such as
xmTIE_myblock)
to optimize just that semantic block logic.
TIE_RETIME enables＂optimize_registers＂for retiming a TIE pipelined
design.It can be set to 0，1 or 2. If 0，no retiming is done.If 1，
retiming of semantic block logic is done. If 2，a more aggressive
retiming
is done which includes the control and bypass logic in the register
files.
Retiming requires a Design Compiler Ultra license.
TIE_MAP_EFFORT controls the Design Compiler effort level on the final
pass
of incremental compiles.
AREA_IS_PRIORITY tweaks the optimization script to try for a minimum
area
.design. Use it only when timing constraints are very loose.
<dp n="d173"/>
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
*/
TIE_DESIGN＝xmTIE
TIE_RETIME＝0
TIE_MAP_EFFORT＝medium
AREA_IS_PRIORITY＝0
/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝
Configure the synthetic library
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
*/
read standard.sldb
set_dont_use standard.sldb/*/rpl
remove_attribute standard.sldb/*cmp*/rpl dont_use
/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝
Read and elaborate the design
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
*/
read-f verilog＂/home/earl/tensilica/test/gf/gf.out/gf.v＂
remove_design find(design，＂xtha＂)＞/dev/null
remove_design find(design，＂xtfa＂)＞/dev/null
remove_design find(design，＂xtmux4b＂)＞/dev/null
read -f verilog＂/home/earl/tensilica/test/gf/gf.out/prim.v＂
elaborate TIE_DESIGN
current_design TIE_DESIGN
link
/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝
Optimize
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
*/
/*
+----------------------------------------------------------------+
| Copyright(c)1997-2000 Tensilica Inc. |
| |
| These coded instructions，statements，and computer programs |
| are Confidential Proprietary Information of Tensilica Inc. |
| and may not be disclosed to third parties or copied in any |
| form，in wholeor in part，without the prior written |
| consent of Tensilica Inc. |
+----------------------------------------------------------------+
Title：Synthesis script for Tensilica primitives
Created：Fri Nov 12，1999
；# Author：Richard Rudell
；# ＜rudell@tensilica.com＞
<dp n="d174"/>
Description：
The Design Compiler＂current_design＂is relevant when this script is
run.
A hierarchical search from the current design finds the set of
primitives.
TENSILICA_SOURCE/Hardware/scripts/syn/Xtensa_cons_generic.dc sets the
constraints on the primitives.
The primitives are ungrouped when they are optimized. Most primitives
are
optimized with a CLOCK_PERIOD of 0 and a CLOCK_SKEW of 0(i.e.，min-
delay).Some are mapped with the real constraints.Not all primitives
are
optimized.
The primitives are ordered so that primitives which contain other
primitives
as instances will be optimized later in the flow. The order is
hardwired.
XTADD and XTMUL give better results when mapped＂incremental＂. A
primitive
with lots of generic logic when it is mapped usually is worse when
mapped
incremental.
prim.v contains special synthesis versions of xtmux3e，xtmux4e，and
xtcsa.
These designs contain cells of xtmux3e_1024，xtmux4e_1024，and
xtcsa_1024
which then instantiate 1,024 xtmux3b，xtmux4b，and xtfa cells. It is
important that these designs are ungrouped and optimized to remove the
many
nets with no fanout. This trick is used to.ensure efficient cells from
the
library are used，regardless of the width of the primitive.
Single-bit versions of xtmux3b，xtmux4b，xtfa and xtha are premapped
hoping
to get single cells from the library of they exist. Note that this is
pretty much guaranteed for xtmux4b，xtfa，and xtha as they are
instantiated
in＂prim.v＂as GTECH components.
Revision History：
Nov 1999：Rewrite to specialize it for some primitives
Nov 1998：Original version
*/
XTVERBOSE＝0
XTCURRENT_DESIGN＝current_design
XTCLOCK_PERIOD＝CLOCK_PERIOD
XTCLOCK_SKEW＝CLOCK_SKEW
LAST_TIME＝time()
/* configure the library */
<dp n="d175"/>
read target_library
set_map_only LIB_MAP_ONLY+{gtech/GTECH_ADD_ABC，gtech/GTECH_ADD_AB，
gtech/GTECH_MUX4}true
if(LIB_DONT_USE ！＝{}){
set_dont_use LIB_DONT_USE
}
current_design XTCURRENT_DESIGN
XTGATE＝find(design，＂xtmux*b＂，-hier)+find(design，＂xtfa＂，-hier)+
find(design，＂xtha＂，-hier)＞/dev/null
XTCLOCKGATE＝find(design，＂xtclock_gate*＂，-hier)＞/dev/null
XTRFLATCH＝find(design，＂xtRF*latch*＂，-hier)＞/dev/null
XTMUX2＝find(design，＂xtmux2_size*＂，-hier)+find(design，
＂xtmux2e_size*＂，-hier)+find(design，＂xtmux2p_size*＂，-hier)＞/dev/null
XTMUX3＝find(design，＂xtmux3_size*＂，-hier)+find(design，
＂xtmux3e_size*＂，-hier)+find(design，＂xtmux3p_size*＂，-hier)＞/dev/null
XTMUX4＝find(design，＂xtmux4_size*＂，-hier)+find(design，
＂xtmux4e_size*＂，-hier)+find(design，＂xtmux4p_size*＂，-hier)＞/dev/null
XTBOOTH＝find(design，＂xtbooth*＂，-hier)＞/dev/null
XTADD＝find(design，＂xtinc*＂，-hier)+find(design，＂xtadd*＂，-hier)+
find(design，＂xtcsa_size*＂，-hier)+find(design，＂xtrelational*＂，-hier)
＞/dev/null
XTMUL＝find(design，＂xtmul*＂，-hier)+find(design，＂xtmac*＂，-hier)
＞/dev/null
XTREGFILE＝find(design，＂xtregfile*＂，-hier)＞/dev/null
/* set the compilation order */
XTPRIM＝XTGATE+XTCLOCKGATE+XTRFLATCH+XTMUX2+XTMUX3+XTMUX4+
XTBOOTH+XTADD+XTMUL+XTREGFILE
/* set compile options */
XTFLATTEN＝{}
XTSTRUCTURE＝{}
XTDONT_TOUCH＝XTCLOCKGATE+XTREGFILE
XTINCREMENTAL＝XTADD+XTMUL+XTREGFILE
XTAREA＝XTCLOCKGATE+XTRFLATCH
XTRELAXED＝XTREGFILE
/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝
Premap the primitives
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
*/
if(XTFLATTEN ！＝{}){
set_flatten true -design XTFLATTEN
}
if(XTPRIM-XTSTRUCTURE！＝{}){
set_structure false -design XTPRIM-XTSTRUCTURE
}
if(XTDONT_TOUCH！＝{}){
set_dont_touch XTDONT_TOUCH true
}
foreach(D，XTPRIM){
echo＂Primitive map＂+D
current_design D
<dp n="d176"/>
echo＂Ungrouping＂+D
ungroup-all -flatten＞/dev/null
echo＂Constraining＂+D
if(({D}-XTAREA)＝{}){
echo D+＂：Area optimization＂
set_max_area 0
}else{
if(({D}-XTRELAXED)＝＝{}){
/* normal constraints */
CLOCK_PERIOD＝XTCLOCK_PERIOD
CLOCK_SKEW＝XTCLOCK_SKEW
}else{
/* overconstrain all other primitives */
CLOCK_PERIOD＝0
CLOCK_SKEW＝0
}
echo D+＂：Clock period is＂+CLOCK_PERIOD+＂and clock skew is＂
+CLOCK_SKEW
/ *
+----------------------------------------------------------------+
| Copyright(c)1997-2000 Tensilica Inc. |
| |
| These coded instructions，statements，and computer programs |
| are Confidential Proprietary Information of Tensilica Inc. |
| and may not be disclosed to third parties or copied in any |
| form，in whole or in part，without the prior written |
| consent of Tensilica Inc. |
+----------------------------------------------------------------+
Title：Generic Design Compiler Constraints
Created：November，1998
；# Author：Richard Rudell
；# ＜rudell@tensilica.com＞
Description：
Revision History：
Nov 1999：Changed multicycle paths for RFLATCH into a
set_disable_timing on the latches instead
Nov 1998：Original version
*/
/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝Clocks＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/
CLOCK_PORT＝find(port，＂CLK＂)+find(port，＂G*CLK＂)+find(port，＂clk＂)
＞/dev/null
if(CLOCK_PORT＝＝{}){
create_clock-name CLK-period CLOCK_PERIOD
}else{
CLOCK_PORT＝filter(CLOCK_PORT，＂@port_direction＝＝in＂)＞/dev/null
create_clock CLOCK_PORT -name CLK -period CLOCK_PERIOD
}
set_dont_touch_network find(clock，＂*＂)
set_fix_hold find(clock，＂*＂)
set_cloc}_skew-ideal-uncertainty CLOCK_SKEW find(clock，＂*＂)
<dp n="d177"/>
DEBUG_CLOCK_PORT＝find(port，＂TClockDR＂)＞/dev/null
if(DEBUG_CLOCK_PORT ！＝{}){
create_clock DEBUG_CLOCK_PORT -name TClockDR -period 4 *CLOCK_PERIOD
}
/* ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝I/O delays，loads，drives＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝*/
set_input_delay .20 *CLOCK_PERIOD -clock CLK all_inputs() - CLOCK_PORT -
DEBUG_CLOCK_PORT
set_output_delay .20 * CLOCK_PERIOD -clock CLK all_outputs()
set_load{4 *load_of(BOUNDARY_LOAD)}all_outputs()
set_driving_cell -cell DRIVE_CELL -pin DRIVE_PIN -from_pin DRIVE_PIN_FRO
all_inputs() -CLOCK_PORT -DEBUG_CLOCK_PORT＞/dev/null
/* ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝Miscellaneous＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ */
set_operating_conditions OPERATING_CONDITION
/* BACKWARD COMPATIBILITY ISSUE：set_wire_load_model DOES NOT work with
DC98.08 */
/* set_wire_load_model -name WIRE_LOAD */
set_wire_load WIRE_LOAD
set_critical_range CRITICAL_RANGE current_design
/* ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ Clock Gating Checks ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ */
set_clock_gating_check -setup CLOCK_SKEW -hold CLOCK_SKEW current_design
/* ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ Disable latch timing ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ */
/* the if prevents RFLATCH from being printed */
if(FOOBAR＝＝FOOBAR){
RFLATCH＝find(cell，＂*xtRF*latchout*＂，-hier)＞/dev/null
if(RFLATCH！＝{}){
echo disabling timing through the latches
set_disable_timing RFLATCH
}
}
/* ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ False paths ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ */
/*
if (DEBUG_CLOCK_PORT ！＝{}){
set_false_path -from TClockDR -to CLK
set_false_path -from CLK -to TClockDR
}
*/
if(({D} -XTREGFILE)＝＝{}){
set_input_delay .35 * CLOCK_PERIOD -clock CLK find(port，
＂wr*_addr＂)＞/dev/null
set_input_delay .35 * CLOCK_PERIOD -clock CLK find(port，
＂wr*_we＂)
}
}
echo＂Optimizing＂+D
if(({D}-XTINCREMENTAL)＝＝{}){
compile -map_effort low-ungroup_all -no_design_rule -incremental
}else{
compile -map_effort low -ungroup_all -no_design_rule
}
<dp n="d178"/>
if(XTVERBOSE){
echo＂Reporting＂+D
report_constraint
report_timing
report_area
report_reference
ELAPSE_TIME＝time() -LAST_TIME
LAST_TIME＝time()
echo D+＂elapse time is＂+ELAPSE_TIME
echo D+＂total time is＂+time()
echo D+＂memory is＂+mem()
}
}
echo＂Prim total time is＂+time()
echo＂Prim memory is＂+mem()
remove_design find(design，＂xtmux3e_1024＂)＞/dev/null
remove_design find(design，＂xtmux4e_1024＂)＞/dev/null
remove_design find(design，＂xtcsa 1024＂)＞/dev/null
current_design XTCURRENT_DESIGN
CLOCK_PERIOD＝XTCLOCK_PERIOD
CLOCK_SKEW＝XTCLOCK_SKEW
/*
+----------------------------------------------------------------+
| Copyright(c)1997-2000 Tensilica Inc. |
| |
| These coded instructions，statements，and computer programs |
| are Confidential Proprietary Information of Tensilica Inc. |
| and may not be disclosed to third parties or copied in any |
| form，in whole or in part，without the prior written |
| consent of Tensilica Inc. |
+----------------------------------------------------------------+
Title：Synthesis script for TIE Coprocessors
Created：Fri Nov 12，1999
；# Author：Richard Rudell
；#＜rudell@tensilica.com＞
Des cription：
Controls Design Compiler for optimizing TIE Coprocessors.
Set TIE_DESIGN to TIE to optimize the TIE module，or set it to the
verilog
name of a semantic block(e.g.，TIE_vec_mac)to optimize just that
module.
Set TIE_RETIME to 1 to perform retiming(＂optimize_registers＂). All of
the
TIE logic except for the the pipelined register files will be retimed.
If
TIE_RETIME is 2，only the register file cores will not be retimed.
This
allows for retiming of the pipeline logic within the register files，
but is
<dp n="d179"/>
more taxing on the Design Compiler retiming algorithm.
TIE_MAP_EFFORT is one of{low，medium，high}for the final
optimization.
The steps are as follows：
-group the top-level logic into a design(TIE_toplogic)
-set compile options
-optimize the design for each top-level cell(low effort)
-TIE_RETIME：regroup the top-level design for retiming
-optimize top-level design(using TIE_MAP_EFFORT)
-TIE_RETIME：retime the top-level design
-optimize top-level design(using TIE_MAP_EFFORT)
-fix design rules
Revision History：
Nov 1999：Original version
*/
/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝
Group the TIE top-level logic into a subdesign
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
*/
current_design TIE_DESIGN
if(TIE_UNGROUP！＝{}){
/* remove some cells */
ungroup TIE_UNGROUP -flatten
}
if(TIE_DESIGN＝＝＂xmTIE＂){
/* group the top-level random logic into a subdesign */
TIE_CELL_LIST＝find(cell，＂TIE_*＂)＞/dev/null
group-design_name xmTIE_toplogic-cell_name.TIE_toplogic -except
TIE_CELL_LIST
}
/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝
Find the top-level cells and their designs
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
*/
current_design TIE_DESIGN
if(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/null
TIE_XTREGFILE＝find(design，＂xtregfile*＂，-hier)＞/dev/null
<dp n="d180"/>
TIE_DECODER＝find(design，＂xmTIE_decoder＂，-hier)＞/dev/hull
/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝
Set optimization controls.
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
*/
TIE_FLATTEN＝TIE_DECODER /* always flatten decoder */
if(AREA_IS_PRIORITY){
TIE_STRUCTURE＝TIE_DESIGN_LIST
}else{
TIE_STRUCTURE＝TIE_DECODER /* always structure decoder */
}
if(TIE_FLATTEN ！＝{}){
set_flatten true -effort medium -design TIE_FLATTEN
}
if(TIE_DESIGN_LIST -TIE_STRUCTURE ！＝{}){
set_structure false -design TIE_DESIGN_LIST - TIE_STRUCTURE
}
/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝
Premap the hierarchical designs
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
*/
LAST_TIME＝time()
foreach(D，TIE_DESIGN_LIST){
echo＂Premapping＂+D
current_design D
echo＂Ungrouping＂+D
ungroup -all -flatten
echo＂Constraining＂+D
set_resource_allocation none
set_resourGe_implementation area_only
/*
+----------------------------------------------------------------+
| Copyright(c)1997-2000Tensilica Inc. |
| |
| These coded instructions，statements，and computer programs |
| are Confidential Proprietary Information of Tensilica Inc. |
| and may not be disclosed to third parties or copied in any |
| form，in whole or in part，without the prior written |
| consent of Tensilica Inc. |
+----------------------------------------------------------------+
Title：Generic Design Compiler Constraints
Created：November，1998
；# Author：Richard Rudel
；# ＜rudell@tensilica.com＞
Description：
<dp n="d181"/>
Revision History：
Nov 1999：Changed multicycle paths for RFIATCH into a
set_disable_timing on the latches instead
Nov 1998：Original version
*/
/* ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ Clocks ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ */
CLOCK_PORT＝find(port，＂CLK＂)+find(port，＂G*CLK＂)+find(port，＂clk＂)
＞/dev/null
if(CLOCK_PORT＝＝{}){
create clock -name CLK-period CLOCK PERIOD
}else{
CLOCK_PORT＝filter(CLOCK_PORT，＂@port_direction＝＝in＂)＞/dev/null
create_clock CLOCK_PORT -name CLK-period CLOCK_PERIOD
}
set_dont_touch_network find(clock，＂*＂)
set_fix_hold find(clock，＂*＂)
set_clock_skew-ideal -uncertainty CLOCK_SKEW find(clock，＂*＂)
DEBUG_CLOCK_PORT＝find(port，＂TClockDR＂)＞/dev/null
if(DEBUG_CLOCK_PORT ！＝{}){
create_clock DEBUG_CLOCK_PORT -name TClockDR-period 4 * CLOCK_PERIOD
}
/* ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ I/O delays，loads，drives ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ */
set_input_delay .20 * CLOCK_PERIOD-clock CLK all_inputs() - CLOCK_PORT-
DEBUG_CLOCK_PORT
set_output_delay .20 * CLOCK_PERIOD-clock CLK all_outputs()
set_load{4 * load_of(BOUNDARY_LOAD)} all_outputs()
set_driving_cell -cell DRIVE_CELL-pin DRIVE_PIN-from_pin DRIVE_PIN_FROM
all_inputs() -CLOCK_PORT -DEBUG_CLOCK_PORT＞/dev/null
/* ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ Miscellaneous ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ */
set_operating_conditions OPERATING_CONDITION
/* BACKWARD COMPATIBILITY ISSUE：set_wire_load_model DOES NOT work with
DC98.08 */
/* set_wire_load_model -name WIRE LOAD */
set_wire_load WIRE_LOAD
set_critical_range CRITICAL_RANGE current_design
/* ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ Clock Gating Checks ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ */
set_clock_gating_check -setup CLOCK_SKEW -hold CLOCK_SKEW current_design
/* ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ Disable latch timing ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ */
/* the if prevents RFLATCH from being printed */
if(FOOBAR＝＝FOOBAR){
RFLATCH＝find(cell，＂*xtRF*latchout*＂，-hier)＞/dev/null
if(RFLATCH！＝{}){
echo disabling timingthrough the latches
set disable timing RFIATCH
}
}
/* ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ False paths ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ */
<dp n="d182"/>
/*
if(DEBUG_CLOCK_PORT！＝{}){
set_false_path -from TClockDR -to CLK
set_false_path -from CLK -to TClockDR
}
*/
if(FOOBAR＝＝FOOBAR){
X＝find(port，＂MemOpAddr_E＂)＞/dev/null
if(X！＝{}){
echo setting input delay for TIE memory interface
set_input_delay .50 * CLOCK_PERIOD -clock CLK X
}
X＝find(port，＂TIE_MemLoadData_M＂)+find(port，＂MemDataIn*＂)
＞/dev/null
if(X！＝{}){
echo setting input delay for TIE memory interface
set_input_delay .60 * CLOCK_PERIOD -clock CLK X
}
/* constraints for TIE register files and TIE state */
X＝find(port，＂rd*_data_C*＂)+find(port，＂ps_data_C*＂)＞/dev/null
if(X！＝{}){
echo setting output delay for TIE register file
set_output_delay .95 * CLOCK_PERIOD -clock CLK X
}
X＝find(port，＂wd* data*_C*＂)+find(port，＂wr*_data*_C*＂)+
find(port，＂ns_data*_C*＂)＞/dev/null
if(X！＝{}){
echo setting input delay for TIE register file
set_input_delay .90 * CLOCK_PERIOD -clock CLK X
}
X＝find(port，＂wd*_wen_C*＂)+find(port，＂Kill*＂)＞/dev/null
if(X！＝{}){
X＝filter(X，＂@port_direction＝＝in＂)＞/dev/null
if(X！＝{}){
echo setting input delay for TIE register file controls
set_input_delay .35 * CLOCK PERIOD -clock CLK X
}
}
}
if(TIE_RETIME){
set_critical_range CLOCK_PERIOD current_design
}
echo＂Optimizing＂+D
compile -map_effort low -ungroup_all -no_design_rule
echo＂Reporting＂+D
report_constraint
report_timing
report_area
report_reference
ELAPSE_TIME＝time()-LAST_TIME
LAST_TIME＝time()
echo D+＂elapse time is＂+ELAPSE_TIME
echo D+＂total time is＂+time()
echo D+＂memory is＂+mem()
}
<dp n="d183"/>
echo＂Premap total time is＂+time()
echo＂Premap memory is＂+mem()
/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝
Report on the top level
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
*/
current_design TIE_DESIGN
/*
+----------------------------------------------------------------+
| Copyright(c)1997-2000Tensilica Inc. |
| |
| These coded instructions，statements，and computer programs |
| are Confidential Proprietary Information of Tensilica Inc. |
| and may not be disclosed to third parties or copied in any |
| form，in whole or in part，without the prior written |
| consent of Tensilica Inc. |
+----------------------------------------------------------------+
Title：Generic Design Compiler Constraints
Created：November，1998
；# Author：Richard Rudell
；# ＜rudell@tensilica.com＞
Description：
Revision History：
Nov 1999：Changed multicycle paths for RFLATCH into a
set_disable_timing on the latches instead
Nov 1998：Original version
*/
/* ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ Clocks ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ */
CLOCK_PORT＝find(port，＂CLK＂)+find(port，＂G*CLK＂)+find(port，＂clk＂)
＞/dev/null
if(CLOCK_PORT＝＝{}){
create_clock-name CLK-period CLOCK_PERIOD
}else{
CLOCK_PORT＝filter(CLOCK_PORT，＂@port_direction＝＝in＂)＞/dev/null
create_clock CLOCK_PORT -name CLK-period CLOCK_PERIOD
}
set_dont_touch network find(clock，＂*＂)
set_fix hold find(clock，＂*＂)
set_clock_skew -ideal -uncertainty CLOCK_SKEW find(clock，＂*＂)
DEBUG_CLOCK_PORT＝find(port，＂TClockDR＂)＞/dev/null
if(DEBUG_CLOCK_PORT！＝{}){
create_clock DEBUG_CLOCK_PORT-name TClockDR-period 4 * CLOCK_PERIOD
}
/* ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ I/O delays，loads，drives ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ */
<dp n="d184"/>
set_input_delay .20 * CLOCK_PERIOD -clock CLK all_inputs() -CLOCK_PORT-
DEBUG_CLOCK_PORT
set_output_delay .20 * CLOCK_PERIOD -clock CLK all_outputs()
set_load{4 * load_of(BOUNDARY_LOAD)} all_outputs()
set_driving_cell-cell DRIVE_CELL-pin DRIVE_PIN -from_pin DRIVE_PIN_FROM
all_inputs() -CLOCK_PORT -DEBUG_CLOCK_PORT＞/dev/null
/* ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ Miscellaneous ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ */
set_operating_conditions OPERATING_CONDITION
/* BACKWARD COMPATIBILITY ISSUE：set_wire_load_model DOES NOT work with
DC98.08 */
/* set_wire_load_model -name WIRE_LOAD */
set_wire_load WIRE_LOAD
set_critical_range CRITICAL RANGE current_design
/* ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ Clock Gating Checks ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ */
set_clock_gating_check-setup CLOCK_SKEW-hold CLOCK_SKEW current_design
/* ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ Disable latch timing ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ */
/* the if prevents RFLATCH from being printed */
if(FOOBAR＝＝FOOBAR){
RFLATCH＝find(cell，＂*xtRF*latchout*＂，-hier)＞/dev/null
if(RFLATCH！＝{}){
echo disabling timing through the latches
set_disable_timing RFLATCH
}
}
/* ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ False paths ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ */
/*
if(DEBUG_CLOCK_PORT！＝{}){
set_false_path -from TClockDR -to CLK
set_false_path -from CLK-to TClockDR
}
*/
if(FOOBAR＝＝FOOBAR){
X＝find(port，＂MemOpAddr_E＂)＞/dev/null
if(X！＝{}){
echo setting inputdelay for TIE memory interface
set_input_delay .50 * CLOCK_PERIOD -clock CLK X
}
X＝find(port，＂TIE_MemLoadData_M＂)+find(port，＂MemDataIn*＂)
＞/dev/null
if(X！＝{}){
echo setting input delay for TIE memory interface
set_input_delay .60*CLOCK_PERIOD -clock CLK X
}
/* constraints for TIE register files and TIE state */
X＝find(port，＂rd*_data_C*＂)+find(port，＂ps_data_C*＂)＞/dev/null
if(X！＝{}){
echo setting output delay for TIE register file
set_output_delay .95*CLOCK PERIOD-clock CLK X
}
X＝find(port，＂wd*_data*_C*＂)+find(port，＂wr*_data*_C*＂)+
find(port，＂ns_data*_C*＂)＞/dev/null
if(X！＝{}){
<dp n="d185"/>
echo setting input delay for TIE register file
set_input_delay .90*CLOCK_PERIOD -clock CLK X
}
X＝find(port，＂wd*_wen_C*＂)+find(port，＂Kill*＂)＞/dev/null
if(X！＝{}){
X＝filter(X，＂@port_direction＝＝in＂)＞/dev/null
if(X！＝{}){
echo setting input delay for TIE register file controls
set_input_delay .35 * CLOCK_PERIOD-clock CLK X
}
}
}
report_constraint
report_timing
report_area
report_reference
/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝
Prepare design for retiming＝keep the register files as subdesigns，
and group everything else into＂datapath＂. Also，set a very high
critical range so that all paths are made fast.
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
*/
current_design TIE_DESIGN
if(TIE_RETIME){
set_critical_range CLOCK_PERIOD current_design
if(TIE_RETIME＝＝2){
TIE_KEEP_DESIGN＝TIE_XTREGFILE
}else{
TIE_KEEP_DESIGN＝TIE_REGFILE
}
list TIE_KEEP_DESIGN
if(TIE_KEEP_DESIGN＝＝{}){
TIE_RETIME_DESIGN＝TIE_DESIGN
ungroup -all -flatten
}else{
TIE_RETIME_DESIGN＝＂xmTIE_datapath＂
set_dont_touch TIE_KEEP_DESIGN true
ungroup-all-flatten
set_dont_touch TIE_KEEP_DESIGN false
if(TIE_RETIME＝＝2){
TIE_KEEP_CELL＝find(cell，＂*icore＂)
}else{
TIE_KEEP_CELL＝find(cell，＂TIE*_Regfile＂)+find(cell，
＂TIE*_State＂)
}
group -design TIE_RETIME_DESIGN-cell TIE_RETIME_DESIGN-except
TIE_KEEP_CELL
list TIE_KEEP_CELL
}
}
/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝
.Pass1
<dp n="d186"/>
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
*/
current_design TIE_DESIGN
if(TIE_XTREGFILE！＝{}){
set_dont_touch TIE_XTREGFILE false
}
if(TIE_DESIGN＝＝＂xmTIE＂){
compile_no_new_cells_at_top_level＝true
}
uniquify
compile -incremental -map_effort TIE_MAP_EFFORT -no_design_rule -
boundary_optimization
report_constraint
report_timing
report_area
report_reference
ELAPSE_TIME＝time() -LAST_TIME
LAST_TIME＝time()
echo＂passl elapse time is＂+ELAPSE_TIME
echo＂passl total time is＂+time()
echo＂passl memory is＂+mem()
/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝
Retime
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
*/
current_design TIE_DESIGN
if(TIE_RETIME){
if(TIE_RETIME_DESIGN ！＝TIE_DESIGN){
characterize TIE_RETIME_DESIGN
current_desigu TIE_RETIME_DESIGN
set_wire_load WIRE_LOAD
}
optimize_registers -check_design -print_critical_loop-
no_incremental_map
current_design TIE_DESIGN
set_critical_range CRITICAL_RANGE current_design
}
/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝
Pass2(add area constraint)
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
*/
current_design TIE_DESIGN
set_max_area 0
compile -incremental -map_effort TIE_MAP_EFFORT -no_design_rule -
boundary_optimization
report_constraint
report_timing
report_area
report_reference
ELAPSE_TIME＝time() -LAST_TIME
LAST_TIME＝time()
<dp n="d187"/>
echo＂pass2 elapse time is＂+ELAPSE_TIME
echo＂pass2 total time is＂+time()
echo＂pass2 memory is＂+mem()
/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝
pass3(Design Rules)
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
*/
current_design TIE_DESIGN
compile -incremental -map_effort TIE_MAP_EFFORT -only_design_rule -
boundary_optimization
report_constraint
report_timing
report_area
report_reference
ELAPSE_TIME＝time() -LAST_TIME
LAST_TIME＝time()
echo＂pass3 elapse time is＂+ELAPSE_TIME
echo＂pass3 total time is＂+time()
echo＂pass3 memory is＂+mem()
/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝
Write it out
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
*/
current_design TIE_DESIGN
write -oTIE_DESIGN+＂.db＂-hier
/*＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝
Final hierarchical area/timing report
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
*/
current_design TIE_DESIGN
X＝find(cell，＂TIE_*＂)+find(cell，＂icore＂)＞/dev/null
if(X！＝{}){
characterize X
}
current_design TIE_DESIGN
report_hierarchy＞TIE_DESIGN+＂.report＂
foreach(D，TIE_DESIGN+find(design，＂*＂，-hier)){
echo＂Final report＂+D
current_design D
report_constraint＞＞TIE_DESIGN+＂.report＂
report_timing＞＞TIE_DESIGN+＂.report＂
report_area＞＞TIE_DESIGN+＂.report＂
report_reference＞＞TIE_DESIGN+＂.report＂
}
echo＂xmTIE elapse time is＂+time()＞＞TIE_DESIGN+＂.report＂
echo＂xmTIE memory is＂+mem()＞＞TIE_DESIGN+＂.report＂
<dp n="d188"/>
sh rm -rf workdir
echo＂xmTIE total time is＂+time()
echo＂xmTIE memory is＂+mem()
quit
prim.v
//+----------------------------------------------------------------+
//| Copyright(c)1997-2000Tensilica Inc. |
//| |
//| These coded instructions，statements，and computer programs|
//| are Confidential Proprietary Information of Tensilica Inc. |
//| and may not be disclosed to third parties or copied in any |
//| form，in whole or in part，without the prior written |
//| consent of Tensilica Inc. |
//+----------------------------------------------------------------+
//
// Title：Base Synthesis Primitives
//
// Created：Tue Sep 28 16：59：24 1999
//
//
// Description：
//
// Revision History：
//
module xtmux3e(xtout，a，b，c，sel)；
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] a，b，c；
input [1：0] sel；
wire [1023：0] tmp；
wire [1023：0] fa；
wire [1023：0] fb；
wire [1023：0] fc；
assign fa [1023：size]＝{(1024-size){1′b0}}；
assign fa [size-1：0]＝a；
assign fb [1023：size]＝{(1024-size){1′b0}}；
assign fb [size-1：0]＝b；
assign fc [1023：size]＝{(1024-size){1′b0}}；
assign fc [size-1：0]＝c；
xtmux3e_1024 i(tmp，fa，fb，fc，sel)；
assign xtout＝tmp；
endmodule
module xtmux3b(xtout，a，b，c，sel)；
output xtout；
input a，b，c；
input [1：0] sel；
// synopsys infer mux＂xtmux3b＂
assign xtout＝sel[1]？c ：(sel[0]？b：a)；
endmodule
_
module xtmux4e(xtout，a，b，c，d，sel)；
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] a，b，c，d；
input [1：0] sel；
<dp n="d189"/>
wire [1023：0] tmp；
wire [1023：0] fa；
wire [1023：0] fb；
wire [1023：0] fc；
wire [1023：0] fd；
assign fa [1023：size]＝{(1024-size){1′b0}}；
assign fa [size-1：0]＝a；
assign fb [1023：size]＝{(1024-size){1′b0}}；
assign fb [size-1：0]＝b；
assign fc [1023：size]＝{(1024-size){1′b0}}；
assign fc [size-1：0]＝c；
assign fd [1023：size]＝{(1024-size){1′b0}}；
assign fd [size-1：0]＝d；
xtmux4e_1024 i(tmp，fa，fb，fc，fd，sel)；
assign xtout＝tmp；
endmodule
module xtmux4b(xtout，a，b，c，d，sel)；
output xtout；
input a，b，c，d；
input [1：0] sel；
GTECH_MUX4 i(.D0(a)，.D1(b)，.D2(c)，.D3(d)，.A(sel[0])，.B(sel[1])，
.Z(xtout))；
endmodule
_
module xtcsa(sum，carry，a，b，c)；
parameter size＝32；
output [size-1：0] sum，carry；
input [size-1：0] a，b，c；
wire [1023：0] tmp1，tmp2；
wire [1023：0] fa；
wire [1023：0] fb；
wire [1023：0] fc；
assign fa [1023：size]＝{(1024-size){1′b0}}；
assign fa [size-1：0]＝a；
assign fb [1023：size]＝{(1024-size){1′b0}}；
assign fb [size-1：0]＝b；
assign fc [1023：size]＝{(1024-size){1′b0}}；
assign fc [size-1：0]＝c；
xtcsa_1024 i(tmp1，tmp2，fa，fb，fc)；
assign sum＝tmp1；
assign carry＝tmp2；
endmodule
module xtfa(sum，carry，a，b，c)；
output sum，carry；
input a，b，c；
GTECH_ADD_ABC i(a，b，c，sum，carry)；
endmodule
module xtha(sum，carry，a，b)；
output sum，carry；
input a，b；
GTECH_ADD_AB i(a，b，sum，carry)；
endmodule
_
module xtmux3e_1024(xtout，a，b，c，sel)；
output [1023：0] xtout；
<dp n="d190"/>
input [1023：0] a，b，c；
input [1：0] sel；
xtmux3b i0(.xtout(xtout[0])，.a(a[0])，.b(b[0])，.c(c[0])，.sel(sel))；
xtmux3b i1(.xtout(xtout[1])，.a(a[1])，.b(b[1])，.c(c[1])，.sel(sel))；
xtmux3b i2(.xtout(xtout[2])，.a(a[2])，.b(b[2])，.c(c[2])，.sel(sel))；
xtmux3b i3(.xtout(xtout[3])，.a(a[3])，.b(b[3])，.c(c[3])，.sel(sel))；
xtmux3b i4(.xtout(xtout[4])，.a(a[4])，.b(b[4])，.c(c[4])，.sel(sel))；
xtmux3b i5(.xtout(xtout[5])，.a(a[5])，.b(b[5])，.c(c[5])，.sel(sel))；
xtmux3b i6(.xtout(xtout[6])，.a(a[6])，.b(b[6])，.c(c[6])，.sel(sel))；
xtmux3b i7(.xtout(xtout[7])，.a(a[7])，.b(b[7])，.c(c[7])，.sel(sel))；
xtmux3b i8(.xtout(xtout[8])，.a(a[8])，.b(b[8])，.c(c[8])，.sel(sel))；
xtmux3b i9(.xtout(xtout[9])，.a(a[9])，.b(b[9])，.c(c[9])，.sel(sel))；
xtmux3b i10(.xtout(xtout[10])，.a(a[10])，.b(b[10])，.c(c[10])，
.sel(sel))；
xtmux3b i11(.xtout(xtout[11])，.a(a[11])，.b(b[11])，.c(c[11])，
.sel(sel))；
xtmux3b i12(.xtout(xtout[12])，.a(a[12])，.b(b[12])，.c(c[12])，
.sel(sel))；
xtmux3b i13(.xtout(xtout[13])，.a(a[13])，.b(b[13])，.c(c[13])，
.sel(sel))；
xtmux3b i14(.xtout(xtout[14])，.a(a[14])，.b(b[14])，.c(c[14])，
.sel(sel))；
xtmux3b i15(.xtout(xtout[15])，.a(a[15])，.b(b[15])，.c(c[15])，
.sel(sel))；
xtmux3b i16(.xtout(xtout[16])，.a(a[16])，.b(b[16])，.c(c[16])，
.sel(sel))；
xtmux3b i17(.xtout(xtout[17])，.a(a[17])，.b(b[17])，.c(c[17])，
.sel(sel))；
xtmux3b i18(.xtout(xtout[18])，.a(a[18])，.b(b[18])，.c(c[18])，
.sel(sel))；
xtmux3b i19(.xtout(xtout[19])，.a(a[19])，.b(b[19])，.c(c[19])，
.sel(sel))；
xtmux3b i20(.xtout(xtout[20])，.a(a[20])，.b(b[20])，.c(c[20])，
.sel(sel))；
xtmux3b i21(.xtout(xtout[21])，.a(a[21])，.b(b[21])，.c(c[21])，
.sel(sel))；
xtmux3b i22(.xtout(xtout[22])，.a(a[22])，.b(b[22])，.c(c[22])，
.sel(sel))；
xtmux3b i23(.xtout(xtout[23])，.a(a[23])，.b(b[23])，.c(c[23])，
.sel(sel))；
xtmux3b i24(.xtout(xtout[24])，.a(a[24])，.b(b[24])，.c(c[24])，
.sel(sel))；
xtmux3b i25(.xtout(xtout[25])，.a(a[25])，.b(b[25])，.c(c[25])，
.sel(sel))；
xtmux3b i26(.xtout(xtout[26])，.a(a[26])，.b(b[26])，.c(c[26])，
.sel(sel))；
xtmux3b i27(.xtout(xtout[27])，.a(a[27])，.b(b[27])，.c(c[27])，
.sel(sel))；
xtmux3b i28(.xtout(xtout[28])，.a(a[28])，.b(b[28])，.c(c[28])，
.sel(sel))；
xtmux3b i29(.xtout(xtout[29])，.a(a[29])，.b(b[29])，.c(c[29])，
.sel(sel))；
xtmux3b i30(.xtout(xtout[30])，.a(a[30])，.b(b[30])，.c(c[30])，
.sel(sel))；
xtmux3b i31(.xtout(xtout[31])，.a(a[31])，.b(b[31])，.c(c[31])，
.sel(sel))；
xtmux3b i32(.xtout(xtout[32])，.a(a[32])，.b(b[32])，.c(c[32])，
.sel(sel))；
xtmux3b i33(.xtout(xtout[33])，.a(a[33])，.b(b[33])，.c(c[33])，
.sel(sel))；
<dp n="d191"/>
xtmux3b i34(.xtout(xtout[34])，.a(a[34])，.b(b[34])，.c(c[34])，
.sel(sel))；
xtmux3b i35(.xtout(xtout[35])，.a(a[35])，.b(b[35])，.c(c[35])，
.sel(sel))；
xtmux3b i36(.xtout(xtout[36])，.a(a[36])，.b(b[36])，.c(c[36])，
.sel(sel))；
xtmux3b i37(.xtout(xtout[37])，.a(a[37])，.b(b[37])，.c(c[37])，
.sel(sel))；
xtmux3b i38(.xtout(xtout[38])，.a(a[38])，.b(b[38])，.c(c[38])，
.sel(sel))；
xtmux3b i39(.xtout(xtout[39])，.a(a[39])，.b(b[39])，.c(c[39])，
.sel(sel))；
xtmux3b i40(.xtout(xtout[40])，.a(a[40])，.b(b[40])，.c(c[40])，
.sel(sel))；
xtmux3b i41(.xtout(xtout[41])，.a(a[41])，.b(b[41])，.c(c[41])，
.sel(sel))；
xtmux3b i42(.xtout(xtout[42])，.a(a[42])，.b(b[42])，.c(c[42])，
.sel(sel))；
xtmux3b i43(.xtout(xtout[43])，.a(a[43])，.b(b[43])，.c(c[43])，
.sel(sel))；
xtmux3b i44(.xtout(xtout[44])，.a(a[44])，.b(b[44])，.c(c[44])，
.sel(sel))；
xtmux3b i45(.xtout(xtout[45])，.a(a[45])，.b(b[45])，.c(c[45])，
.sel(sel))；
xtmux3b i46(.xtout(xtout[46])，.a(a[46])，.b(b[46])，.c(c[46])，
sel(sel))；
xtmux3b i47(.xtout(xtout[47])，.a(a[47])，.b(b[47])，.c(c[47])，
.sel(sel))；
xtmux3b i48(.xtout(xtout[48])，.a(a[48])，.b(b[48])，.c(c[48])，
.sel(sel))；
xtmux3b i49(.xtout(xtout[49])，.a(a[49])，.b(b[49])，.c(c[49])
.sel(sel))；
xtmux3b i50(.xtout(xtout[50])，.a(a[50])，.b(b[50])，.c(c[50])，
.sel(sel))；
xtmux3b i51(.xtout(xtout[51])，.a(a[51])，.b(b[51])，.c(c[51])，
.sel(sel))；
xtmux3b i52(.xtout(xtout[52])，.a(a[52])，.b(b[52])，.c(c[52])，
.sel(sel))；
xtmux3b i53(.xtout(xtout[53])，.a(a[53])，.b(b[53])，.c(c[53])，
.sel(sel))；
xtmux3b i54(.xtout(xtout[54])，.a(a[54])，.b(b[54])，.c(c[54])，
.sel(sel))；
xtmux3b i55(.xtout(xtout[55])，.a(a[55])，.b(b[55])，.c(c[55])，
.sel(sel))；
xtmux3b i56(.xtout(xtout[56])，.a(a[56])，.b(b[56])，.c(c[56])，
.sel(sel))；
xtmux3b i57(.xtout(xtout[57])，.a(a[57])，.b(b[57])，.c(c[57])，
.sel(sel))；
xtmux3b i58(.xtout(xtout[58])，.a(a[58])，.b(b[58])，.c(c[58])，
.sel(sel))；
xtmux3b i59(.xtout(xtout[59])，.a(a[59])，.b(b[59])，.c(c[59])，
.sel(sal))；
xtmux3b i60(.xtout(xtout[60])，.a(a[60])，.b(b[60])，.c(c[60])，
.sel(sel))；
xtmux3b i61(.xtout(xtout[61])，.a(a[61])，.b(b[61])，.c(c[61])，
.sel(sel))；
xtmux3b i62(.xtout(xtout[62])，.a(a[62])，.b(b[62])，.c(c[62])，
.sel(sel))；
xtmux3b i63(.xtout(xtout[63])，.a(a[63])，.b(b[63])，.c(c[63])，
.sel(sel))；
<dp n="d192"/>
xtmux3b i64(.xtout(xtout[64])，.a(a[64])，.b(b[64])，.c(c[64])，
.sel(sel))；
xtmux3b i65(.xtout(xtout[65])，.a(a[65])，.b(b[65])，.c(c[65])，
.sel(sel))；
xtmux3b i66(.xtout(xtout[66])，.a(a[66])，.b(b[66])，.c(c[66])，
.sel(sel))；
xtmux3b i67(.xtout(xtout[67])，.a(a[67])，.b(b[67])，.c(c[67])，
.sel(sel))；
xtmux3b i68(.xtout(xtout[68])，.a(a[68])，.b(b[68])，.c(c[68])，
.sel(sel))；
xtmux3b i69(.xtout(xtout[69])，.a(a[69])，.b(b[69])，.c(c[69])，
.sel(sel))；
xtmux3b i70(.xtout(xtout[70])，.a(a[70])，.b(b[70])，.c(c[70])，
.sel(sel))；
xtmux3b i71(.xtout(xtout[71])，.a(a[71])，.b(b[71])，.c(c[71])，
.sel(sel))；
xtmux3b i72(.xtout(xtout[72])，.a(a[72])，.b(b[72])，.c(c[72])，
.sel(sel))；
xtmux3b i73(.xtout(xtout[73])，.a(a[73])，.b(b[73])，.c(c[73])，
.sel(sel))；
xtmux3b i74(.xtout(xtout[74])，.a(a[74])，.b(b[74])，.c(c[74])，
.sel(sel))；
xtmux3b i75(.xtout(xtout[75])，.a(a[75])，.b(b[75])，.c(c[75])，
.sel(sel))；
xtmux3b i76(.xtout(xtout[76])，.a(a[76])，.b(b[76])，.c(c[76])，
.sel(sel))；
xtmux3b i77(.xtout(xtout[77])，.a(a[77])，.b(b[77])，.c(c[77])，
.sel(sel))；
xtmux3b i78(.xtout(xtout[78])，.a(a[78])，.b(b[78])，.c(c[78])，
.sel(sel))；
xtmux3b i79(.xtout(xtout[79])，.a(a[79])，.b(b[79])，.c(c[79])，
.sel(sel))；
xtmux3b i80(.xtout(xtout[80])，.a(a[80])，.b(b[80])，.c(c[80])，
.sel(sel))；
xtmux3b i81(.xtout(xtout[81])，.a(a[81])，.b(b[81])，.c(c[81])，
.sel(sel))；
xtmux3b i82(.xtout(xtout[82])，.a(a[82])，.b(b[82])，.c(c[82])，
.sel(sel))；
xtmux3b i83(.xtout(xtout[83])，.a(a[83])，.b(b[83])，.c(c[83])，
.sel(sel))；
xtmux3b i84(.xtout(xtout[84])，.a(a[84])，.b(b[84])，.c(c[84])，
.sel(sel))；
xtmux3b i85(.xtout(xtout[85])，.a(a[85])，.b(b[85])，.c(c[85])，
.sel(sel))；
xtmux3b i86(.xtout(xtout[86])，.a(a[86])，.b(b[86])，.c(c[86])，
.sel(sel))；
xtmux3b i87(.xtout(xtout[87])，.a(a[87])，.b(b[87])，.c(c[87])，
.sel(sel))；
xtmux3b i88(.xtout(xtout[88])，.a(a[88])，.b(b[88])，.c(c[88])，
.sel(sel))；
xtmux3b i89(.xtout(xtout[89])，.a(a[89])，.b(b[89])，.c(c[89])，
.sel(sel))；
xtmux3b i90(.xtout(xtout[90])，.a(a[90])，.b(b[90])，.c(c[90])，
.sel(sel))；
xtmux3b i91(.xtout(xtout[91])，.a(a[91])，.b(b[91])，.c(c[91])，
.sel(sel))；
xtmux3b i92(.xtout(xtout[92])，.a(a[92])，.b(b[92])，.c(c[92])，
.sel(sel))；
xtmux3b i93(.xtout(xtout[93])，.a(a[93])，.b(b[93])，.c(c[93])，
.sel(sel))；
<dp n="d193"/>
xtmux3b i94(.xtout(xtout[94])，.a(a[94])，.b(b[94])，.c(c[94])，
.sel(sel))；
xtmux3b i95(.xtout(xtout[95])，.a(a[95])，.b(b[95])，.c(c[95])，
.sel(sel))；
xtmux3b i96(.xtout(xtout[96])，.a(a[96])，.b(b[96])，.c(c[96])，
.sel(sel))；
xtmux3b i97(.xtout(xtout[97])，.a(a[97])，.b(b[97])，.c(c[97])，
.sel(sel))；
xtmux3b i98(.xtout(xtout[98])，.a(a[98])，.b(b[98])，.c(c[98])，
.sel(sel))；
xtmux3b i99(.xtout(xtout[99])，.a(a[99])，.b(b[99])，.c(c[99])，
.sel(sel))；
xtmux3b i100(.xtout(xtout[100])，.a(a[100])，.b(b[100])，.c(c[100])，
.sel(sel))；
xtmux3b i101(.xtout(xtout[101])，.a(a[101])，.b(b[101])，.c(c[101])，
.sel(sel))；
xtmux3b i102(.xtout(xtout[102])，.a(a[102])，.b(b[102])，.c(c[102])，
.sel(sel))；
xtmux3b i103(.xtout(xtout[103])，.a(a[103])，.b(b[103])，.c(c[103])，
.sel(sel))；
xtmux3b i104(.xtout(xtout[104])，.a(a[104])，.b(b[104])，.c(c[104])，
.sel(sel))；
xtmux3b i105(.xtout(xtout[105])，.a(a[105])，.b(b[105])，.c(c[105])，
.sel(sel))；
xtmux3b i106(.xtout(xtout[106])，.a(a[106])，.b(b[106])，.c(c[106])，
.sel(sel))；
xtmux3b i107(.xtout(xtout[107])，.a(a[107])，.b(b[107])，.c(c[107])，
.sel(sel))；
xtmux3b i108(.xtout(xtout[108])，.a(a[108])，.b(b[108])，.c(c[108])，
.sel(sel))；
xtmux3b i109(.xtout(xtout[109])，.a(a[109])，.b(b[109])，.c(c[109])，
.sel(sel))；
xtmux3b i110(.xtout(xtout[110])，.a(a[110])，.b(b[110])，.c(c[110])，
.sel(sel))；
xtmux3b i111(.xtout(xtout[111])，.a(a[111])，.b(b[111])，.c(c[111])，
.sel(sel))；
xtmux3b i112(.xtout(xtout[112])，.a(a[112])，.b(b[112])，.c(c[112])，
.sel(sel))；
xtmux3b i113(.xtout(xtout[113])，.a(a[113])，.b(b[113])，.c(c[113])，
.sel(sel))；
xtmux3b i114(.xtout(xtout[114])，.a(a[114])，.b(b[114])，.c(c[114])，
.sel(sel))；
xtmux3b i115(.xtout(xtout[115])，.a(a[115])，.b(b[115])，.c(c[115])，
.sel(sel))；
xtmux3b i116(.xtout(xtout[116])，.a(a[116])，.b(b[116])，.c(c[116])，
.sel(sel))；
xtmux3b i117(.xtout(xtout[117])，.a(a[117])，.b(b[117])，.c(c[117])，
.sel(sel))；
xtmux3b i118(.xtout(xtout[118])，.a(a[118])，.b(b[118])，.c(c[118])，
.sel(sel))；
xtmux3b i119(.xtout(xtout[119])，.a(a[119])，.b(b[119])，.c(c[119])，
.sel(sel))；
xtmux3b i120(.xtout(xtout[120])，.a(a[120])，.b(b[120])，.c(c[120])，
.sel(sel))；
xtmux3b i121(.xtout(xtout[121])，.a(a[121])，.b(b[121])，.c(c[121])，
.sel(sel))；
xtmux3b i122(.xtout(xtout[122])，.a(a[122])，.b(b[122])，.c(c[122])，
.sel(sel))；
xtmux3b i123(.xtout(xtout[123])，.a(a[123])，.b(b[123])，.c(c[123])，
.sel(sel))；
<dp n="d194"/>
xtmux3b i124(.xtout(xtout[124])，.a(a[124])，.b(b[124])，.c(c[124])，
.sel(sel))；
xtmux3b i125(.xtout(xtout[125])，.a(a[125])，.b(b[125])，.c(c[125])，
.sel(sel))；
xtmux3b i126(.xtout(xtout[126])，.a(a[126])，.b(b[126])，.c(c[126])，
.sel(sel))；
xtmux3b i127(.xtout(xtout[127])，.a(a[127])，.b(b[127])，.c(c[127])，
.sel(sel))；
xtmux3b i128(.xtout(xtout[128])，.a(a[128])，.b(b[128])，.c(c[128])，
.sel(sel))；
xtmux3b i129(.xtout(xtout[129])，.a(a[129])，.b(b[129])，.c(c[129])，
.sel(sel))；
xtmux3b i130(.xtout(xtout[130])，.a(a[130])，.b(b[130])，.c(c[130])，
.sel(sel))；
xtmux3b i131(.xtout(xtout[131])，.a(a[131])，.b(b[131])，.c(c[131])，
.sel(sel))；
xtmux3b i132(.xtout(xtout[132])，.a(a[132])，.b(b[132])，.c(c[132])，
.sel(sel))；
xtmux3b i133(.xtout(xtout[133])，.a(a[133])，.b(b[133])，.c(c[133])，
.sel(sel))；
xtmux3b i134(.xtout(xtout[134])，.a(a[134])，.b(b[134])，.c(c[134])，
.sel(sel))；
xtmux3b i135(.xtout(xtout[135])，.a(a[135])，.b(b[135])，.c(c[135])，
.sel(sel))；
xtmux3b i136(.xtout(xtout[136])，.a(a[136])，.b(b[136])，.c(c[136])，
.sel(sel))；
xtmux3b i137(.xtout(xtout[137])，.a(a[137])，.b(b[137])，.c(c[137])，
.sel(sel))；
xtmux3b i138(.xtout(xtout[138])，.a(a[138])，.b(b[138])，.c(c[138])，
.sel(sel))；
xtmux3b i139(.xtout(xtout[139])，.a(a[139])，.b(b[139])，.c(c[139])，
.sel(sel))；
xtmux3b i140(.xtout(xtout[140])，.a(a[140])，.b(b[140])，.c(c[140])，
.sel(sel))；
xtmux3b i141(.xtout(xtout[141])，.a(a[141])，.b(b[141])，.c(c[141])，
.sel(sel))；
xtmux3b i142(.xtout(xtout[142])，.a(a[142])，.b(b[142])，.c(c[142])，
.sel(sel))；
xtmux3b i143(.xtout(xtout[143])，.a(a[143])，.b(b[143])，.c(c[143])，
.sel(sel))；
xtmux3b i144(.xtout(xtout[144])，.a(a[144])，.b(b[144])，.c(c[144])，
.sel(sel))；
xtmux3b i145(.xtout(xtout[145])，.a(a[145])，.b(b[145])，.c(c[145])，
.sel(sel))；
xtmux3b i146(.xtout(xtout[146])，.a(a[146])，.b(b[146])，.c(c[146])，
.sel(sel))；
xtmux3b i147(.xtout(xtout[147])，.a(a[147])，.b(b[147])，.c(c[147])，
.sel(sel))；
xtmux3b i148(.xtout(xtout[148])，.a(a[148])，.b(b[148])，.c(c[148])，
.sel(sel))；
xtmux3b i149(.xtout(xtout[149])，.a(a[149])，.b(b[149])，.c(c[149])，
.sel(sel))；
xtmux3b i150(.xtout(xtout[150])，.a(a[150])，.b(b[150])，.c(c[150])，
.sel(sel))；
xtmux3b i151(.xtout(xtout[151])，.a(a[151])，.b(b[151])，.c(c[151])，
.sel(sel))；
xtmux3b i152(.xtout(xtout[152])，.a(a[152])，.b(b[152])，.c(c[152])，
.sel(sel))；
xtmux3b i153(.xtout(xtout[153])，.a(a[153])，.b(b[153])，.c(c[153])，
.sel(sel))；
<dp n="d195"/>
xtmux3b i154(.xtout(xtout[154])，.a(a[154])，.b(b[154])，.c(c[154])，
.sel(sel))；
xtmux3b i155(.xtout(xtout[155])，.a(a[155])，.b(b[155])，.c(c[155])，
.sel(sel))；
xtmux3b i156(.xtout(xtout[156])，.a(a[156])，.b(b[156])，.c(c[156])，
.sel(sel))；
xtmux3b i157(.xtout(xtout[157])，.a(a[157])，.b(b[157])，.c(c[157])，
.sel(sel))；
xtmux3b i158(.xtout(xtout[158])，.a(a[158])，.b(b[158])，.c(c[158])，
.sel(sel))；
xtmux3b i159(.xtout(xtout[159])，.a(a[159])，.b(b[159])，.c(c[159])，
.sel(sel))；
xtmux3b i160(.xtout(xtout[160])，.a(a[160])，.b(b[160])，.c(c[160])，
.sel(sel))；
xtmux3b i161(.xtout(xtout[161])，.a(a[161])，.b(b[161])，.c(c[161])，
.sel(sel))；
xtmux3b i162(.xtout(xtout[162])，.a(a[162])，.b(b[162])，.c(c[162])，
.sel(sel))；
xtmux3b i163(.xtout(xtout[163])，.a(a[163])，.b(b[163])，.c(c[163])，
.sel(sel))；
xtmux3b i164(.xtout(xtout[164])，.a(a[164])，.b(b[164])，.c(c[164])，
.sel(sel))；
xtmux3b i165(.xtout(xtout[165])，.a(a[165])，.b(b[165])，.c(c[165])，
.sel(sel))；
xtmux3b i166(.xtout(xtout[166])，.a(a[166])，.b(b[166])，.c(c[166])，
.sel(sel))；
xtmux3b i167(.xtout(xtout[167])，.a(a[167])，.b(b[167])，.c(c[167])，
.sel(sel))；
xtmux3b i168(.xtout(xtout[168])，.a(a[168])，.b(b[168])，.c(c[168])，
.sel(sel))；
xtmux3b i169(.xtout(xtout[169])，.a(a[169])，.b(b[169])，.c(c[169])，
.sel(sel))；
xtmux3b i170(.xtout(xtout[170])，.a(a[170])，.b(b[170])，.c(c[170])，
.sel(sel))；
xtmux3b i171(.xtout(xtout[171])，.a(a[171])，.b(b[171])，.c(c[171])，
.sel(sel))；
xtmux3b i172(.xtout(xtout[172])，.a(a[172])，.b(b[172])，.c(c[172])，
.sel(sel))；
xtmux3b i173(.xtout(xtout[173])，.a(a[173])，.b(b[173])，.c(c[173])，
.sel(sel))；
xtmux3b i174(.xtout(xtout[174])，.a(a[174])，.b(b[174])，.c(c[174])，
.sel(sel))；
xtmux3b i175(.xtout(xtout[175])，.a(a[175])，.b(b[175])，.c(c[175])，
.sel(sel))；
xtmux3b i176(.xtout(xtout[176])，.a(a[176])，.b(b[176])，.c(c[176])，
.sel(sel))；
xtmux3b i177(.xtout(xtout[177])，.a(a[177])，.b(b[177])，.c(c[177])，
.sel(sel))；
xtmux3b i178(.xtout(xtout[178])，.a(a[178])，.b(b[178])，.c(c[178])，
.sel(sel))；
xtmux3b i179(.xtout(xtout[179])，.a(a[179])，.b(b[179])，.c(c[179])，
.sel(sel))；
xtmux3b i180(.xtout(xtout[180])，.a(a[180])，.b(b[180])，.c(c[180])，
.sel(sel))；
xtmux3b i181(.xtout(xtout[181])，.a(a[181])，.b(b[181])，.c(c[181])，
.sel(sel))；
xtmux3b i182(.xtout(xtout[182])，.a(a[182])，.b(b[182])，.c(c[182])，
.sel(sel))；
xtmux3b i183(.xtout(xtout[183])，.a(a[183])，.b(b[183])，.c(c[183])，
.sel(sel))；
<dp n="d196"/>
xtmux3b i184(.xtout(xtout[184])，.a(a[184])，.b(b[184])，.c(c[l84])，
.sel(sel))；
xtmux3b i185(.xtout(xtout[185])，.a(a[185])，.b(b[185])，.c(c[185])，
.sel(sel))；
xtmux3b i186(.xtout(xtout[186])，.a(a[186])，.b(b[186])，.c(c[186])，
.sel(sel))；
xtmux3b i187(.xtout(xtout[187])，.a(a[187])，.b(b[187])，.c(c[187])，
.sel(sel))；
xtmux3b i188(.xtout(xtout[188])，.a(a[188])，.b(b[188])，.c(c[188])，
.sel(sel))；
xtmux3b i189(.xtout(xtout[189])，.a(a[189])，.b(b[189])，.c(c[189])，
.sel(sel))；
xtmux3b i190(.xtout(xtout[190])，.a(a[190])，.b(b[190])，.c(c[190])，
.sel(sel))；
xtmux3b i191(.xtout(xtout[191])，.a(a[191])，.b(b[191])，.c(c[191])，
.sel(sel))；
xtmux3b i192(.xtout(xtout[192])，.a(a[192])，.b(b[192])，.c(c[192])，
.sel(sel))；
xtmux3b i193(.xtout(xtout[193])，.a(a[193])，.b(b[193])，.c(c[193])，
.sel(sel))；
xtmux3b i194(.xtout(xtout[194])，.a(a[194])，.b(b[194])，.c(c[194])，
.sel(sel))；
xtmux3b i195(.xtout(xtout[195])，.a(a[195])，.b(b[195])，.c(c[195])，
.sel(sel))；
xtmux3b i196(.xtout(xtout[196])，.a(a[196])，.b(b[196])，.c(c[196])，
.sel(sel))；
xtmux3b i197(.xtout(xtout[197])，.a(a[197])，.b(b[197])，.c(c[197])，
.sel(sel))；
xtmux3b i198(.xtout(xtout[198])，.a(a[198])，.b(b[198])，.c(c[198])，
.sel(sel))；
xtmux3b i199(.xtout(xtout[199])，.a(a[199])，.b(b[199])，.c(c[199])，
.sel(sel))；
xtmux3b i200(.xtout(xtout[200])，.a(a[200])，.b(b[200])，.c(c[200])，
.sel(sel))；
xtmux3b i201(.xtout(xtout[201])，.a(a[201])，.b(b[201])，.c(c[201])，
.sel(sel))；
xtmux3b i202(.xtout(xtout[202])，.a(a[202])，.b(b[202])，.c(c[202])，
.sel(sel))；
xtmux3b i203(.xtout(xtout[203])，.a(a[203])，.b(b[203])，.c(c[203])，
.sel(sel))；
xtmux3b i204(.xtout(xtout[204])，.a(a[204])，.b(b[204])，.c(c[204])，
.sel(sel))；
xtmux3b i205(.xtout(xtout[205])，.a(a[205])，.b(b[205])，.c(c[205])，
.sel(sel))；
xtmux3b i206(.xtout(xtout[206])，.a(a[206])，.b(b[206])，.c(c[206])，
.sel(sel))；
xtmux3b i207(.xtout(xtout[207])，.a(a[207])，.b(b[207])，.c(c[207])，
.sel(sel))；
xtmux3b i208(.xtout(xtout[208])，.a(a[208])，.b(b[208])，.c(c[208])，
.sel(sel))；
xtmux3b i209(.xtout(xtout[209])，.a(a[209])，.b(b[209])，.c(c[209])，
.sel(sel))；
xtmux3b i210(.xtout(xtout[210])，.a(a[210])，.b(b[210])，.c(c[210])，
.sel(sel))；
xtmux3b i211(.xtout(xtout[211])，.a(a[211])，.b(b[211])，.c(c[211])，
.sel(sel))；
xtmux3b i212(.xtout(xtout[212])，.a(a[212])，.b(b[212])，.c(c[212])，
.sel(sel))；
xtmux3b i213(.xtout(xtout[213])，.a(a[213])，.b(b[213])，.c(c[213])，
.sel(sel))；
<dp n="d197"/>
xtmux3b i214(.xtout(xtout[214])，.a(a[214])，.b(b[214])，.c(c[214])，
.sel(sel))；
xtmux3b i215(.xtout(xtout[215])，.a(a[215])，.b(b[215])，.c(c[215])，
.sel(sel))；
xtmux3b i216(.xtout(xtout[216])，.a(a[216])，.b(b[216])，.c(c[216])，
.sel(sel))；
xtmux3b i217(.xtout(xtout[217])，.a(a[217])，.b(b[217])，.c(c[217])，
.sel(sel))；
xtmux3b i218(.xtout(xtout[218])，.a(a[218])，.b(b[218])，.c(c[218])，
.sel(sel))；
xtmux3b i219(.xtout(xtout[219])，.a(a[219])，.b(b[219])，.c(c[219])，
.sel(sel))；
xtmux3b i220(.xtout(xtout[220])，.a(a[220])，.b(b[220])，.c(c[220])，
.sel(sel))；
xtmux3b i221(.xtout(xtout[221])，.a(a[221])，.b(b[221])，.c(c[221])，
.sel(sel))；
xtmux3b i222(.xtout(xtout[222])，.a(a[222])，.b(b[222])， .c(c[222])，
.sel(sel))；
xtmux3b i223(.xtout(xtout[223])，.a(a[223])，.b(b[223])，.c(c[223])，
.sel(sel))；
xtmux3b i224(.xtout(xtout[224])，.a(a[224])，.b(b[224])，.c(c[224])，
.sel(sel))；
xtmux3b i225(.xtout(xtout[225])，.a(a[225])，.b(b[225])，.c(c[225])，
.sel(sel))；
xtmux3b i226(.xtout(xtout[226])，.a(a[226])，.b(b[226])，.c(c[226])，
.sel(sel))；
xtmux3b i227(.xtout(xtout[227])，.a(a[227])，.b(b[227])，.c(c[227])，
.sel(sel)；
xtmux3b i228(.xtout(xtout[228])，.a(a[228])，.b(b[228])，.c(c[228])，
.sel(sel))；
xtmux3b i229(.xtout(xtout[229])，.a(a[229])，.b(b[229])，.c(c[229])，
.sel(sel))；
xtmux3b i230(.xtout(xtout[230])，.a(a[230])，.b(b[230])，.c(c[230])，
.sel(sel))；
xtmux3b i231(.xtout(xtout[231])，.a(a[231])，.b(b[231])，.c(c[231])，
.sel(sel))；
xtmux3b i232(.xtout(xtout[232])，.a(a[232])，.b(b[232])，.c(c[232])，
.sel(sel))；
xtmux3b i233(.xtout(xtout[233])，.a(a[233])，.b(b[233])，.c(c[233])，
.sel(sel))；
xtmux3b i234(.xtout(xtout[234])，.a(a[234])，.b(b[234])，.c(c[234])，
.sel(sel))；
xtmux3b i235(.xtout(xtout[235])，.a(a[235])，.b(b[235])，.c(c[235])，
.sel(sel))；
xtmux3b i236(.xtout(xtout[236])，.a(a[236])，.b(b[236])，.c(c[236])，
.sel(sel))；
xtmux3b i237(.xtout(xtout[237])，.a(a[237])，.b(b[237])，.c(c[237])，
.sel(sel))；
xtmux3b i238(.xtout(xtout[238])，.a(a[238])，.b(b[238])，.c(c[238])，
.sel(sel))；
xtmux3b i239(.xtout(xtout[239])，.a(a[239])，.b(b[239])，.c(c[239])，
.sel(sel))；
xtmux3b i240(.xtout(xtout[240])，.a(a[240])，.b(b[240])，.c(c[240])，
.sel(se1))；
xtmux3b i241(.xtout(xtout[241])，.a(a[241])，.b(b[241])，.c(c[241])，
.sel(sel))；
xtmux3b i242(.xtout(xtout[242])，.a(a[242])，.b(b[242])，.c(c[242])，
.sel(sel))；
xtmux3b i243(.xtout(xtout[243])，.a(a[243])，.b(b[243])，.c(c[243])，
.sel(sel))；
<dp n="d198"/>
xtmux3b i244(.xtout(xtout[244])，.a(a[244])，.b(b[244])，.c(c[244])，
.sel(sel))；
xtmux3b i245(.xtout(xtout[245])，.a(a[245])，.b(b[245])，.c(c[245])，
.sel(sel))；
xtmux3b i246(.xtout(xtout[246])，.a(a[246])，.b(b[246])，.c(c[246])，
.sel(sel))；
xtmux3b i247(.xtout(xtout[247])，.a(a[247])，.b(b[247])，.c(c[247])，
.sel(sel))；
xtmux3b i248(.xtout(xtout[248])，.a(a[248])，.b(b[248])，.c(c[248])，
.sel(sel))；
xtmux3b i249(.xtout(xtout[249])，.a(a[249])，.b(b[249])，.c(c[249])，
.sel(sel))；
xtmux3b i250(.xtout(xtout[250])，.a(a[250])，.b(b[250])，.c(c[250])，
.sel(sel))；
xtmux3b i251(.xtout(xtout[251])，.a(a[251])，.b(b[251])，.c(c[251])，
.sel(sel))；
xtmux3b i252(.xtout(xtout[252])，.a(a[252])，.b(b[252])，.c(c[252])，
.sel(sel))；
xtmux3b i253(.xtout(xtout[253])，.a(a[253])，.b(b[253])，.c(c[253])，
.sel(sel))；
xtmux3b i254(.xtout(xtout[254])，.a(a[254])，.b(b[254])，.c(c[254])，
.sel(sel))；
xtmux3b i255(.xtout(xtout[255])，.a(a[255])，.b(b[255])，.c(c[255])，
.sel(sel))；
xtmux3b i256(.xtout(xtout[256])，.a(a[256])，.b(b[256])，.c(c[256])，
.sel(sel))；
xtmux3b i257(.xtout(xtout[257])，.a(a[257])，.b(b[257])，.c(c[257])，
.sel(sel))；
xtmux3b i258(.xtout(xtout[258])，.a(a[258])，.b(b[258])，.c(c[258])，
.sel(sel))；
xtmux3b i259(.xtout(xtout[259])，.a(a[259])，.b(b[259])，.c(c[259])，
.sel(sel))；
xtmux3b i260(.xtout(xtout[260])，.a(a[260])，.b(b[260])，.c(c[260])，
.sel(sel))；
xtmux3b i261(.xtout(xtout[261])，.a(a[261])，.b(b[261])，.c(c[261])，
.sel(sel))；
xtmux3b i262(.xtout(xtout[262])，.a(a[262])，.b(b[262])，.c(c[262])，
.sel(sel))；
xtmux3b i263(.xtout(xtout[263])，.a(a[263])，.b(b[263])，.c(c[263])，
.sel(sel))；
xtmux3b i264(.xtout(xtout[264])，.a(a[264])，.b(b[264])，.c(c[264])，
.sel(sel))；
xtmux3b i265(.xtout(xtout[265])，.a(a[265])，.b(b[265])，.c(c[265])，
.sel(sel))；
xtmux3b i266(.xtout(xtout[266])，.a(a[266])，.b(b[266])，.c(c[266])，
.sel(sel))；
xtmux3b i267(.xtout(xtout[267])，.a(a[267])，.b(b[267])，.c(c[267])，
.sel(sel))；
xtmux3b i268(.xtout(xtout[268])，.a(a[268])，.b(b[268])，.c(c[268])，
.sel(sel))；
xtmux3b i269(.xtout(xtout[269])，.a(a[269])，.b(b[269])，.c(c[269])，
.sel(sel))；
xtmux3b i270(.xtout(xtout[270])，.a(a[270])，.b(b[270])，.c(c[270])，
.sel(sel))；
xtmux3b i271(.xtout(xtout[271])，.a(a[271])，.b(b[271])，.c(c[271])，
.sel(sel))；
xtmux3b i272(.xtout(xtout[272])，.a(a[272])，.b(b[272])，.c(c[272])，
.sel(sel))；
xtmux3b i273(.xtout(xtout[273])，.a(a[273])，.b(b[273])，.c(c[273])，
.sel(sel))；
<dp n="d199"/>
xtmux3b i274(.xtout(xtout[274])，.a(a[274])，.b(b[274])，.c(c[274])，
.sel(sel))；
xtmux3b i275(.xtout(xtout[275])，.a(a[275])，.b(b[275])，.c(c[275])，
.sel(sel))；
xtmux3b i276(.xtout(xtout[276])，.a(a[276])，.b(b[276])，.c(c[276])，
.sel(sel))；
xtmux3b i277(.xtout(xtout[277])，.a(a[277])，.b(b[277])，.c(c[277])，
.sel(sel))；
xtmux3b i278(.xtout(xtout[278])，.a(a[278])，.b(b[278])，.c(c[278])，
.sel(sel))；
xtmux3b i279(.xtout(xtout[279])，.a(a[279])，.b(b[279])，.c(c[279])，
.sel(sel))；
xtmux3b i280(.xtout(xtout[280])，.a(a[280])，.b(b[280])，.c(c[280])，
.sel(sel))；
xtmux3b i281(.xtout(xtout[281])，.a(a[281])，.b(b[281])，.c(c[281])，
.sel(sel))；
xtmux3b i282(.xtout(xtout[282])，.a(a[282])，.b(b[282])，.c(c[282])，
.sel(sel))；
xtmux3b i283(.xtout(xtout[283])，.a(a[283])，.b(b[283])，.c(c[283])，
.sel(sel))；
xtmux3b i284(.xtout(xtout[284])，.a(a[284])，.b(b[284])，.c(c[284])，
.sel(sel))；
xtmux3b i285(.xtout(xtout[285])，.a(a[285])，.b(b[285])，.c(c[285])，
.sel(sel))；
xtmux3b i286(.xtout(xtout[286])，.a(a[286])，.b(b[286])，.c(c[286])，
.sel(sel))；
xtmux3b i287(.xtout(xtout[287])，.a(a[287])，.b(b[287])，.c(c[287])，
.sel(sel))；
xtmux3b i288(.xtout(xtout[288])，.a(a[288])，.b(b[288])，.c(c[288])，
.sel(sel))；
xtmux3b i289(.xtout(xtout[289])，.a(a[289])，.b(b[289])，.c(c[289])，
.sel(sel))；
xtmux3b i290(.xtout(xtout[290])，.a(a[290])，.b(b[290])，.c(c[290])，
.sel(sel))；
xtmux3b i291(.xtout(xtout[291])，.a(a[291])，.b(b[291])，.c(c[291])，
.sel(sel))；
xtmux3b i292(.xtout(xtout[292])，.a(a[292])，.b(b[292])，.c(c[292])，
.sel(sel))；
xtmux3b i293(.xtout(xtout[293])，.a(a[293])，.b(b[293])，.c(c[293])，
.sel(sel))；
xtmux3b i294(.xtout(xtout[294])，.a(a[294])，.b(b[294])，.c(c[294])，
.sel(sel))；
xtmux3b i295(.xtout(xtout[295])，.a(a[295])，.b(b[295])，.c(c[295])，
.sel(sel))；
xtmux3b i296(.xtout(xtout[296])，.a(a[296])，.b(b[296])，.c(c[296])，
.sel(sel))；
xtmux3b i297(.xtout(xtout[297])，.a(a[297])，.b(b[297])，.c(c[297])，
.sel(sel))；
xtmux3b i298(.xtout(xtout[298])，.a(a[298])，.b(b[298])，.c(c[298])，
.sel(sel))；
xtmux3b i299(.xtout(xtout[299])，.a(a[299])，.b(b[299])，.c(c[299])，
.sel(sel))；
xtmux3b i300(.xtout(xtout[300])，.a(a[300])，.b(b[300])，.c(c[300])，
.sel(sel))；
xtmux3b i301(.xtout(xtout[301])，.a(a[301])，.b(b[301])，.c(c[301])，
.sel(sel))；
xtmux3b i302(.xtout(xtout[302])，.a(a[302])，.b(b[302])，.c(c[302])，
.sel(sel))；
xtmux3b i303(.xtout(xtout[303])，.a(a[303])，.b(b[303])，.c(c[303])，
.sel(sel))；
<dp n="d200"/>
xtmux3b i304(.xtout(xtout[304])，.a(a[304])，.b(b[304])，.c(c[304])，
.sel(sel))；
xtmux3b i305(.xtout(xtout[305])，.a(a[305])，.b(b[305])，.c(c[305])，
.sel(sel))；
xtmux3b i306(.xtout(xtout[306])，.a(a[306])，.b(b[306])，.c(c[306])，
.sel(sel))；
xtmux3b i307(.xtout(xtout[307])，.a(a[307])，.b(b[307])，.c(c[307])，
.sel(sel))；
xtmux3b i308(.xtout(xtout[308])，.a(a[308])，.b(b[308])，.c(c[308])，
.sel(sel))；
xtmux3b i309(.xtout(xtout[309])，.a(a[309])，.b(b[309])，.c(c[309])，
.sel(sel))；
xtmux3b i310(.xtout(xtout[310])，.a(a[310])，.b(b[310])，.c(c[310])，
.sel(sel))；
xtmux3b i311(.xtout(xtout[311])，.a(a[311])，.b(b[311])，.c(c[311])，
.sel(sel))；
xtmux3b i312(.xtout(xtout[312])，.a(a[312])，.b(b[312])，.c(c[312])，
.sel(sel))；
xtmux3b i313(.xtout(xtout[313])，.a(a[313])，.b(b[313])，.c(c[313])，
.sel(sel))；
xtmux3b i314(.xtout(xtout[314])，.a(a[314])，.b(b[314])，.c(c[314])，
.sel(sel))；
xtmux3b i315(.xtout(xtout[315])，.a(a[315])，.b(b[315])，.c(c[315])，
.sel(sel))；
xtmux3b i316(.xtout(xtout[316])，.a(a[316])，.b(b[316])，.c(c[316])，
.sel(sel)；
xtmux3b i317(.xtout(xtout[317])，.a(a[317])，.b(b[317])，.c(c[317])，
.sel(sel)；
xtmux3b i318(.xtout(xtout[318])，.a(a[318])，.b(b[318])，.c(c[318])，
.sel(sel)；
xtmux3b i319(.xtout(xtout[319])，.a(a[319])，.b(b[319])，.c(c[319])，
.sel(sel)；
xtmux3b i320(.xtout(xtout[320])，.a(a[320])，.b(b[320])，.c(c[320])，
.sel(sel)；
xtmux3b i321(.xtout(xtout[321])，.a(a[321])，.b(b[321])，.c(c[321])，
.sel(sel)；
xtmux3b i322(.xtout(xtout[322])，.a(a[322])，.b(b[322])，.c(c[322])，
.sel(sel)；
xtmux3b i323(.xtout(xtout[323])，.a(a[323])，.b(b[323])，.c(c[323])，
.sel(sel))；
xtmux3b i324(.xtout(xtout[324])，.a(a[324])，.b(b[324])，.c(c[324])，
.sel(sel))；
xtmux3b i325(.xtout(xtout[325])，.a(a[325])，.b(b[325])，.c(c[325])，
.sel(sel))；
xtmux3b i326(.xtout(xtout[326])，.a(a[326])，.b(b[326])，.c(c[326])，
.sel(sel))；
xtmux3b i327(.xtout(xtout[327])，.a(a[327])，.b(b[327])，.c(c[327])，
.sel(sel))；
xtmux3b i328(.xtout(xtout[328])，.a(a[328])，.b(b[328])，.c(c[328])，
.sel(sel))；
xtmux3b i329(.xtout(xtout[329])，.a(a[329])，.b(b[329])，.c(c[329])，
.sel(sel))；
xtmux3b i330(.xtout(xtout[330])，.a(a[330])，.b(b[330])，.c(c[330])，
.sel(sel))；
xtmux3b i331(.xtout(xtout[331])，.a(a[331])，.b(b[331])，.c(c[331])，
.sel(sel))；
xtmux3b i332(.xtout(xtout[332])，.a(a[332])，.b(b[332])，.c(c[332])，
.sel(sel))；
xtmux3b i333(.xtout(xtout[333])，.a(a[333])，.b(b[333])，.c(c[333])，
.sel(sel))；
<dp n="d201"/>
xtmux3b i334(.xtout(xtout[334])，.a(a[334])，.b(b[334])，.c(c[334])，
.sel(sel))；
xtmux3b i335(.xtout(xtout[335])，.a(a[335])，.b(b[335])，.c(c[335])，
.sel(sel))；
xtmux3b i336(.xtout(xtout[336])，.a(a[336])，.b(b[336])，.c(c[336])，
.sel(sel))；
xtmux3b i337(.xtout(xtout[337])，.a(a[337])，.b(b[337])，.c(c[337])，
.sel(sel))；
xtmux3b i338(.xtout(xtout[338])，.a(a[338])，.b(b[338])，.c(c[338])，
.sel(sel))；
xtmux3b i339(.xtout(xtout[339])，.a(a[339])，.b(b[339])，.c(c[339])，
.sel(sel))；
xtmux3b i340(.xtout(xtout[340])，.a(a[340])，.b(b[340])，.c(c[340])，
.sel(sel))；
xtmux3b i341(.xtout(xtout[341])，.a(a[341])，.b(b[341])，.c(c[341])，
.sel(sel))；
xtmux3b i342(.xtout(xtout[342])，.a(a[342])，.b(b[342])，.c(c[342])，
.sel(sel))；
xtmux3b i343(.xtout(xtout[343])，.a(a[343])，.b(b[343])，.c(c[343])，
.sel(sel))；
xtmux3b i344(.xtout(xtout[344])，.a(a[344])，.b(b[344])，.c(c[344])，
.sel(sel))；
xtmux3b i345(.xtout(xtout[345])，.a(a[345])，.b(b[345])，.c(c[345])，
.sel(sel))；
xtmux3b i346(.xtout(xtout[346])，.a(a[346])，.b(b[346])，.c(c[346])，
.sel(sel))；
xtmux3b i347(.xtout(xtout[347])，.a(a[347])，.b(b[347])，.c(c[347])，
.sel(sel))；
xtmux3b i348(.xtout(xtout[348])，.a(a[348])，.b(b[348])，.c(c[348])，
.sel(sel))；
xtmux3b i349(.xtout(xtout[349])，.a(a[349])，.b(b[349])，.c(c[349])，
.sel(sel))；
xtmux3b i350(.xtout(xtout[350])，.a(a[350])，.b(b[350])，.c(c[350])，
.sel(sel))；
xtmux3b i351(.xtout(xtout[351])，.a(a[351])，.b(b[351])，.c(c[351])，
.sel(sel))；
xtmux3b i352(.xtout(xtout[352])，.a(a[352])，.b(b[352])，.c(c[352])，
.sel(sel))；
xtmux3b i353(.xtout(xtout[353])，.a(a[353])，.b(b[353])，.c(c[353])，
.sel(sel))；
xtmux3b i354(.xtout(xtout[354])，.a(a[354])，.b(b[354])，.c(c[354])，
.sel(sel))；
xtmux3b i355(.xtout(xtout[355])，.a(a[355])，.b(b[355])，.c(c[355])，
.sel(sel))；
xtmux3b i356(.xtout(xtout[356])，.a(a[356])，.b(b[356])，.c(c[356])，
.sel(sel))；
xtmux3b i357(.xtout(xtout[357])，.a(a[357])，.b(b[357])，.c(c[357])，
.sel(sel))；
xtmux3b i358(.xtout(xtout[358])，.a(a[358])，.b(b[358])，.c(c[358])，
.sel(sel))；
xtmux3b i359(.xtout(xtout[359])，.a(a[359])，.b(b[359])，.c(c[359])，
.sel(sel))；
xtmux3b i360(.xtout(xtout[360])，.a(a[360])，.b(b[360])，.c(c[360])，
.sel(sel))；
xtmux3b i361(.xtout(xtout[361])，.a(a[361])，.b(b[361])，.c(c[361])，
.sel(sel))；
xtmux3b i362(.xtout(xtout[362])，.a(a[362])，.b(b[362])，.c(c[362])，
.sel(sel))；
xtmux3b i363(.xtout(xtout[363])，.a(a[363])，.b(b[363])，.c(c[363])，
.sel(sel))；
<dp n="d202"/>
xtmux3b i364(.xtout(xtout[364])，.a(a[364])，.b(b[364])，.c(c[364])，
.sel(sel))；
xtmux3b i365(.xtout(xtout[365])，.a(a[365])，.b(b[365])，.c(c[365])，
.sel(sel))；
xtmux3b i366(.xtout(xtout[366])，.a(a[366])，.b(b[366])，.c(c[366])，
.sel(sel))；
xtmux3b i367(.xtout(xtout[367])，.a(a[367])，.b(b[367])，.c(c[367])，
.sel(sel))；
xtmux3b i368(.xtout(xtout[368])，.a(a[368])，.b(b[368])，.c(c[368])，
.sel(sel))；
xtmux3b i369(.xtout(xtout[369])，.a(a[369])，.b(b[369])，.c(c[369])，
.sel(sel))；
xtmux3b i370(.xtout(xtout[370])，.a(a[370])，.b(b[370])，.c(c[370])，
.sel(sel))；
xtmux3b i371(.xtout(xtout[371])，.a(a[371])，.b(b[371])，.c(c[371])，
.sel(sel))；
xtmux3b i372(.xtout(xtout[372])，.a(a[372])，.b(b[372])，.c(c[372])，
.sel(sel))；
xtmux3b i373(.xtout(xtout[373])，.a(a[373])，.b(b[373])，.c(c[373])，
.sel(sel))；
xtmux3b i374(.xtout(xtout[374])，.a(a[374])，.b(b[374])，.c(c[374])，
.sel(sel))；
xtmux3b i375(.xtout(xtout[375])，.a(a[375])，.b(b[375])，.c(c[375])，
.sel(sel))；
xtmux3b i376(.xtout(xtout[376])，.a(a[376])，.b(b[376])，.c(c[376])，
.sel(sel))；
xtmux3b i377(.xtout(xtout[377])，.a(a[377])，.b(b[377])，.c(c[377])，
.sel(sel))；
xtmux3b i378(.xtout(xtout[378])，.a(a[378])，.b(b[378])，.c(c[378])，
.sel(sel))；
xtmux3b i379(.xtout(xtout[379])，.a(a[379])，.b(b[379])，.c(c[379])，
.sel(sel))；
xtmux3b i380(.xtout(xtout[380])，.a(a[380])，.b(b[380])，.c(c[380])，
.sel(sel))；
xtmux3b i381(.xtout(xtout[381])，.a(a[381])，.b(b[381])，.c(c[381])，
.sel(sel))；
xtmux3b i382(.xtout(xtout[382])，.a(a[382])，.b(b[382])，.c(c[382])，
.sel(sel))；
xtmux3b i383(.xtout(xtout[383])，.a(a[383])，.b(b[383])，.c(c[383])，
.sel(sel))；
xtmux3b i384(.xtout(xtout[384])，.a(a[384])，.b(b[384])，.c(c[384])，
.sel(sel))；
xtmux3b i385(.xtout(xtout[385])，.a(a[385])，.b(b[385])，.c(c[385])，
.sel(sel))；
xtmux3b i386(.xtout(xtout[386])，.a(a[386])，.b(b[386])，.c(c[386])，
.sel(sel))；
xtmux3b i387(.xtout(xtout[387])，.a(a[387])，.b(b[387])，.c(c[387])，
.sel(sel))；
xtmux3b i388(.xtout(xtout[388])，.a(a[388])，.b(b[388])，.c(c[388])，
.sel(sel))；
xtmux3b i389(.xtout(xtout[389])，.a(a[389])，.b(b[389])，.c(c[389])，
.sel(sel))；
xtmux3b i390(.xtout(xtout[390])，.a(a[390])，.b(b[390])，.c(c[390])，
.sel(sel))；
xtmux3b i391(.xtout(xtout[391])，.a(a[391])，.b(b[391])，.c(c[391])，
.sel(sel))；
xtmux3b i392(.xtout(xtout[392])，.a(a[392])，.b(b[392])，.c(c[392])，
.sel(sel))；
xtmux3b i393(.xtout(xtout[393])，.a(a[393])，.b(b[393])，.c(c[393])，
.sel(sel))；
<dp n="d203"/>
xtmux3b i394(.xtout(xtout[394])，.a(a[394])，.b(b[394])，.c(c[394])，
.sel(sel))；
xtmux3b i395(.xtout(xtout[395])，.a(a[395])，.b(b[395])，.c(c[395])，
.sel(sel))；
xtmux3b i396(.xtout(xtout[396])，.a(a[396])，.b(b[396])，.c(c[396])，
.sel(sel))；
xtmux3b i397(.xtout(xtout[397])，.a(a[397])，.b(b[397])，.c(c[397])，
.sel(sel))；
xtmux3b i398(.xtout(xtout[398])，.a(a[398])，.b(b[398])，.c(c[398])，
.sel(sel))；
xtmux3b i399(.xtout(xtout[399])，.a(a[399])，.b(b[399])，.c(c[399])，
.sel(sel))；
xtmux3b i400(.xtout(xtout[400])，.a(a[400])，.b(b[400])，.c(c[400])，
.sel(sel))；
xtmux3b i401(.xtout(xtout[401])，.a(a[401])，.b(b[401])，.c(c[401])，
.sel(sel))；
xtmux3b i402(.xtout(xtout[402])，.a(a[402])，.b(b[402])，.c(c[402])，
.sel(sel))；
xtmux3b i403(.xtout(xtout[403])，.a(a[403])，.b(b[403])，.c(c[403])，
.sel(sel))；
xtmux3b i404(.xtout(xtout[404])，.a(a[404])，.b(b[404])，.c(c[404])，
.sel(sel))；
xtmux3b i405(.xtout(xtout[405])，.a(a[405])，.b(b[405])，.c(c[405])，
.sel(sel))；
xtmux3b i406(.xtout(xtout[406])，.a(a[406])，.b(b[406])，.c(c[406])，
.sel(sel))；
xtmux3b i407(.xtout(xtout[407])，.a(a[407])，.b(b[407])，.c(c[407])，
.sel(sel))；
xtmux3b i408(.xtout(xtout[408])，.a(a[408])，.b(b[408])，.c(c[408])，
.sel(sel))；
xtmux3b i409(.xtout(xtout[409])，.a(a[409])，.b(b[409])，.c(c[409])，
.sel(sel))；
xtmux3b i410(.xtout(xtout[410])，.a(a[410])，.b(b[410])，.c(c[410])，
.sel(sel))；
xtmux3b i411(.xtout(xtout[411])，.a(a[411])，.b(b[411])，.c(c[411])，
.sel(sel))；
xtmux3b i412(.xtout(xtout[412])，.a(a[412])，.b(b[412])，.c(c[412])，
.sel(sel))；
xtmux3b i413(.xtout(xtout[413])，.a(a[413])，.b(b[413])，.c(c[413])，
.sel(sel))；
xtmux3b i414(.xtout(xtout[414])，.a(a[414])，.b(b[414])，.c(c[414])，
.sel(sel))；
xtmux3b i415(.xtout(xtout[415])，.a(a[415])，.b(b[415])，.c(c[415])，
.sel(sel))；
xtmux3b i416(.xtout(xtout[416])，.a(a[416])，.b(b[416])，.c(c[416])，
.sel(sel))；
xtmux3b i417(.xtout(xtout[417])，.a(a[417])，.b(b[417])，.c(c[417])，
.sel(sel))；
xtmux3b i418(.xtout(xtout[418])，.a(a[418])，.b(b[418])，.c(c[418])，
.sel(sel))；
xtmux3b i419(.xtout(xtout[419])，.a(a[419])，.b(b[419])，.c(c[419])，
.sel(sel))；
xtmux3b i420(.xtout(xtout[420])，.a(a[420])，.b(b[420])，.c(c[420])，
.sel(sel) )；
xtmux3b i421(.xtout(xtout[421])，.a(a[421])，.b(b[421])，.c(c[421])，
.sel(sal))；
xtmux3b i422(.xtout(xtout[422])，.a(a[422])，.b(b[422])，.c(c[422])，
.sel(sel))；
xtmux3b i423(.xtout(xtout[423])，.a(a[423])，.b(b[423])，.c(c[423])，
.sel(sel))；
<dp n="d204"/>
xtmux3b i424(.xtout(xtout[424])，.a(a[424])，.b(b[424])，.c(c[424])，
.sel(sel))；
xtmux3b i425(.xtout(xtout[425])，.a(a[425])，.b(b[425])，.c(c[425])，
.sel(sel))；
xtmux3b i426(.xtout(xtout[426])，.a(a[426])，.b(b[426])，.c(c[426])，
.sel(sel))；
xtmux3b i427(.xtout(xtout[427])，.a(a[427])，.b(b[427])，.c(c[427])，
.sel(sel))；
xtmux3b i428(.xtout(xtout[428])，.a(a[428])，.b(b[428])，.c(c[428])，
.sel(sel))；
xtmux3b i429(.xtout(xtout[429])，.a(a[429])，.b(b[429])，.c(c[429])，
.sel(sel))；
xtmux3b i430(.xtout(xtout[430])，.a(a[430])，.b(b[430])，.c(c[430])，
.sel(sel))；
xtmux3b i431(.xtout(xtout[431])，.a(a[431])，.b(b[431])，.c(c[431])，
.sel(sel))；
xtmux3b i432(.xtout(xtout[432])，.a(a[432])，.b(b[432])，.c(c[432])，
.sel(sel))；
xtmux3b i433(.xtout(xtout[433])，.a(a[433])，.b(b[433])，.c(c[433])，
.sel(sel))；
xtmux3b i434(.xtout(xtout[434])，.a(a[434])，.b(b[434])，.c(c[434])，
.sel(sel))；
xtmux3b i435(.xtout(xtout[435])，.a(a[435])，.b(b[435])，.c(c[435])，
.sel(sel))；
xtmux3b i436(.xtout(xtout[436])，.a(a[436])，.b(b[436])，.c(c[436])，
.sel(sel))；
xtmux3b i437(.xtout(xtout[437])，.a(a[437])，.b(b[437])，.c(c[437])，
.sel(sel))；
xtmux3b i438(.xtout(xtout[438])，.a(a[438])，.b(b[438])，.c(c[438])，
.sel(sel))；
xtmux3b i439(.xtout(xtout[439])，.a(a[439])，.b(b[439])，.c(c[439])，
.sel(sel))；
xtmux3b i440(.xtout(xtout[440])，.a(a[440])，.b(b[440])，.c(c[440])，
.sel(sel))；
xtmux3b i441(.xtout(xtout[441])，.a(a[441])，.b(b[441])，.c(c[441])，
.sel(sel))；
xtmux3b i442(.xtout(xtout[442])，.a(a[442])，.b(b[442])，.c(c[442])，
.sel(sel))；
xtmux3b i443(.xtout(xtout[443])，.a(a[443])，.b(b[443])，.c(c[443])，
.sel(sel))；
xtmux3b i444(.xtout(xtout[444])，.a(a[444])，.b(b[444])，.c(c[444])，
.sel(sel))；
xtmux3b i445(.xtout(xtout[445])，.a(a[445])，.b(b[445])，.c(c[445])，
.sel(sel))；
xtmux3b i446(.xtout(xtout[446])，.a(a[446])，.b(b[446])，.c(c[446])，
.sel(sel))；
xtmux3b i447(.xtout(xtout[447])，.a(a[447])，.b(b[447])，.c(c[447])，
.sel(sel))；
xtmux3b i448(.xtout(xtout[448])，.a(a[448])，.b(b[448])，.c(c[448])，
.sel(sel))；
xtmux3b i449(.xtout(xtout[449])，.a(a[449])，.b(b[449])，.c(c[449])，
.sel(sel))；
xtmux3b i450(.xtout(xtout[450])，.a(a[450])，.b(b[450])，.c(c[450])，
.sel(sel))；
xtmux3b i451(.xtout(xtout[451])，.a(a[451])，.b(b[451])，.c(c[451])，
.sel(sel))；
xtmux3b i452(.xtout(xtout[452])，.a(a[452])，.b(b[452])，.c(c[452])，
.sel(sel))；
xtmux3b i453(.xtout(xtout[453])，.a(a[453])，.b(b[453])，.c(c[453])，
.sel(sel))；
<dp n="d205"/>
xtmux3b i454(.xtout(xtout[454])，.a(a[454])，.b(b[454])，.c(c[454])，
.sel(sel))；
xtmux3b i455(.xtout(xtout[455])，.a(a[455])，.b(b[455])，.c(c[455])，
.sel(sel))；
xtmux3b i456(.xtout(xtout[456])，.a(a[456])，.b(b[456])，.c(c[456])，
.sel(sel))；
xtmux3b i457(.xtout(xtout[457])，.a(a[457])，.b(b[457])，.c(c[457])，
.sel(sel))；
xtmux3b i458(.xtout(xtout[458])，.a(a[458])，.b(b[458])，.c(c[458])，
.sel(sel))；
xtmux3b i459(.xtout(xtout[459])，.a(a[459])，.b(b[459])，.c(c[459])，
.sel(sel))；
xtmux3b i460(.xtout(xtout[460])，.a(a[460])，.b(b[460])，.c(c[460])，
.sel(sel))；
xtmux3b i461(.xtout(xtout[461])，.a(a[461])，.b(b[461])，.c(c[461])，
.sel(sel))；
xtmux3b i462(.xtout(xtout[462])，.a(a[462])，.b(b[462])，.c(c[462])，
.sel(sel))；
xtmux3b i463(.xtout(xtout[463])，.a(a[463])，.b(b[463])，.c(c[463])，
.sel(sel))；
xtmux3b i464(.xtout(xtout[464])，.a(a[464])，.b(b[464])，.c(c[464])，
.sel(sel))；
xtmux3b i465(.xtout(xtout[465])，.a(a[465])，.b(b[465])，.c(c[465])，
.sel(sel))；
xtmux3b i466(.xtout(xtout[466])，.a(a[466])，.b(b[466])，.c(c[466])，
.sel(sel))；
xtmux3b i467(.xtout(xtout[467])，.a(a[467])，.b(b[467])，.c(c[467])，
.sel(sel))；
xtmux3b i468(.xtout(xtout[468])，.a(a[468])，.b(b[468])，.c(c[468])，
.sel(sel))；
xtmux3b i469(.xtout(xtout[469])，.a(a[469])，.b(b[469])，.c(c[469])，
.sel(sel))；
xtmux3b i470(.xtout(xtout[470])，.a(a[470])，.b(b[470])，.c(c[470])，
.sel(sel))；
xtmux3b i471(.xtout(xtout[471])，.a(a[471])，.b(b[471])，.c(c[471])，
.sel(sel))；
xtmux3b i472(.xtout(xtout[472])，.a(a[472])，.b(b[472])，.c(c[472])，
.sel(sel))；
xtmux3b i473(.xtout(xtout[473])，.a(a[473])，.b(b[473])，.c(c[473])，
.sel(sel))；
xtmux3b i474(.xtout(xtout[474])，.a(a[474])，.b(b[474])，.c(c[474])，
.sel(sel))；
xtmux3b i475(.xtout(xtout[475])，.a(a[475])，.b(b[475])，.c(c[475])，
.sel(sel))；
xtmux3b i476(.xtout(xtout[476])，.a(a[476])，.b(b[476])，.c(c[476])，
.sel(sel))；
xtmux3b i477(.xtout(xtout[477])，.a(a[477])，.b(b[477])，.c(c[477])，
.sel(sel))；
xtmux3b i478(.xtout(xtout[478])，.a(a[478])，.b(b[478])，.c(c[478])，
.sel(sel))；
xtmux3b i479(.xtout(xtout[479])，.a(a[479])，.b(b[479])，.c(c[479])，
.sel(sel))；
xtmux3b i480(.xtout(xtout[480])，.a(a[480])，.b(b[480])，.c(c[480])，
.sel(sel))；
xtmux3b i481(.xtout(xtout[481])，.a(a[481])，.b(b[481])，.c(c[481])，
.sel(sel))；
xtmux3b i482(.xtout(xtout[482])，.a(a[482])，.b(b[482])，.c(c[482])，
.sel(sel))；
xtmux3b i483(.xtout(xtout[483])，.a(a[483])，.b(b[483])，.c(c[483])，
.sel(sel))；
<dp n="d206"/>
xtmux3b i484(.xtout(xtout[484])，.a(a[484])，.b(b[484])，.c(c[484])，
.sel(sel))；
xtmux3b i485(.xtout(xtout[485])，.a(a[485])，.b(b[485])，.c(c[485])，
.sel(sel))；
xtmux3b i486(.xtout(xtout[486])，.a(a[486])，.b(b[486])，.c(c[486])，
.sel(sel))；
xtmux3b i487(.xtout(xtout[487])，.a(a[487])，.b(b[487])，.c(c[487])，
.sel(sel))；
xtmux3b i488(.xtout(xtout[488])，.a(a[488])，.b(b[488])，.c(c[488])，
.sel(sel))；
xtmux3b i489(.xtout(xtout[489])，.a(a[489])，.b(b[489])，.c(c[489])，
.sel(sel))；
xtmux3b i490(.xtout(xtout[490])，.a(a[490])，.b(b[490])，.c(c[490])，
.sel(sel))；
xtmux3b i491(.xtout(xtout[491])，.a(a[491])，.b(b[491])，.c(c[491])，
.sel(sel))；
xtmux3b i492(.xtout(xtout[492])，.a(a[492])，.b(b[492])，.c(c[492])，
.sel(sel))；
xtmux3b i493(.xtout(xtout[493])，.a(a[493])，.b(b[493])，.c(c[493])，
.sel(sel))；
xtmux3b i494(.xtout(xtout[494])，.a(a[494])，.b(b[494])，.c(c[494])，
.sel(sel))；
xtmux3b i495(.xtout(xtout[495])，.a(a[495])，.b(b[495])，.c(c[495])，
.sel(sel))；
xtmux3b i496(.xtout(xtout[496])，.a(a[496])，.b(b[496])，.c(c[496])，
.sel(sel))；
xtmux3b i497(.xtout(xtout[497])，.a(a[497])，.b(b[497])，.c(c[497])，
.sel(sel))；
xtmux3b i498(.xtout(xtout[498])，.a(a[498])，.b(b[498])，.c(c[498])，
.sel(sel))；
xtmux3b i499(.xtout(xtout[499])，.a(a[499])，.b(b[499])，.c(c[499])，
.sel(sel))；
xtmux3b i500(.xtout(xtout[500])，.a(a[500])，.b(b[500])，.c(c[500])，
.sel(sel))；
xtmux3b i501(.xtout(xtout[501])，.a(a[501])，.b(b[501])，.c(c[501])，
.sel(sel))；
xtmux3b i502(.xtout(xtout[502])，.a(a[502])，.b(b[502])，.c(c[502])，
.sel(sel))；
xtmux3b i503(.xtout(xtout[503])，.a(a[503])，.b(b[503])，.c(c[503])，
.sel(sel))；
xtmux3b i504(.xtout(xtout[504])，.a(a[504])，.b(b[504])，.c(c[504])，
.sel(sel))；
xtmux3b i505(.xtout(xtout[505])，.a(a[505])，.b(b[505])，.c(c[505])，
.sel(sel))；
xtmux3b i506(.xtout(xtout[506])，.a(a[506])，.b(b[506])，.c(c[506])，
.sel(sel))；
xtmux3b i507(.xtout(xtout[507])，.a(a[507])，.b(b[507])，.c(c[507])，
.sel(sel))；
xtmux3b i508(.xtout(xtout[508])，.a(a[508])，.b(b[508])，.c(c[508])，
.sel(sel))；
xtmux3b i509(.xtout(xtout[509])，.a(a[509])，.b(b[509])，.c(c[509])，
.sel(sel))；
xtmux3b i510(.xtout(xtout[510])，.a(a[510])，.b(b[510])，.c(c[510])，
.sel(sel))；
xtmux3b i511(.xtout(xtout[511])，.a(a[511])，.b(b[511])，.c(c[511])，
.sel(sel))；
xtmux3b i512(.xtout(xtout[512])，.a(a[512])，.b(b[512])，.c(c[512])，
.sel(sel))；
xtmux3b i513(.xtout(xtout[513])，.a(a[513])，.b(b[513])，.(c[513])，
.sel(sel))；
<dp n="d207"/>
xtmux3b i514(.xtout(xtout[514])，.a(a[514])，.b(b[514])，.c(c[514])，
.sel(sel))；
xtmux3b i515(.xtout(xtout[515])，.a(a[515])，.b(b[515])，.c(c[515])，
.sel(sel))；
xtmux3b i516(.xtout(xtout[516])，.a(a[516])，.b(b[516])，.c(c[516])，
.sel(sel))；
xtmux3b i517(.xtout(xtout[517])，.a(a[517])，.b(b[517])，.c(c[517])，
.sel(sel))；
xtmux3b i518(.xtout(xtout[518])，.a(a[518])，.b(b[518])，.c(c[518])，
.sel(sel))；
xtmux3b i519(.xtout(xtout[519])，.a(a[519])，.b(b[519])，.c(c[519])，
.sel(sel))；
xtmux3b i520(.xtout(xtout[520])，.a(a[520])，.b(b[520])，.c(c[520])，
.sel(sel))；
xtmux3b i521(.xtout(xtout[521])，.a(a[521])，.b(b[521])，.c(c[521])，
.sel(sel))；
xtmux3b i522(.xtout(xtout[522])，.a(a[522])，.b(b[522])，.c(c[522])，
.sel(sel))；
xtmux3b i523(.xtout(xtout[523])，.a(a[523])，.b(b[523])，.c(c[523])，
.sel(sel))；
xtmux3b i524(.xtout(xtout[524])，.a(a[524])，.b(b[524])，.c(c[524])，
.sel(sel))；
xtmux3b i525(.xtout(xtout[525])，.a(a[525])，.b(b[525])，.c(c[525])，
.sel(sel))；
xtmux3b i526(.xtout(xtout[526])，.a(a[526])，.b(b[526])，.c(c[526])，
.sel(sel))；
xtmux3b i527(.xtout(xtout[527])，.a(a[527])，.b(b[527])，.c(c[527])，
.sel(sel))；
xtmux3b i528(.xtout(xtout[528])，.a(a[528])，.b(b[528])，.c(c[528])，
.sel(sel))；
xtmux3b i529(.xtout(xtout[529])，.a(a[529])，.b(b[529])，.c(c[529])，
.sel(sel))；
xtmux3b i530(.xtout(xtout[530])，.a(a[530])，.b(b[530])，.c(c[530])，
.sel(sel))；
xtmux3b i531(.xtout(xtout[531])，.a(a[531])，.b(b[531])，.c(c[531])，
.sel(sel))；
xtmux3b i532(.xtout(xtout[532])，.a(a[532])，.b(b[532])，.c(c[532])，
.sel(sel))；
xtmux3b i533(.xtout(xtout[533])，.a(a[533])，.b(b[533])，.c(c[533])，
.sel(sel))；
xtmux3b i534(.xtout(xtout[534])，.a(a[534])，.b(b[534])，.c(c[534])，
.sel(sel))；
xtmux3b i535(.xtout(xtout[535])，.a(a[535])，.b(b[535])，.c(c[535])，
.sel(sel))；
xtmux3b i536(.xtout(xtout[536])，.a(a[536])，.b(b[536])，.c(c[536])，
.sel(sel))；
xtmux3b i537(.xtout(xtout[537])，.a(a[537])，.b(b[537])，.c(c[537])，
.sel(sel))；
xtmux3b i538(.xtout(xtout[538])，.a(a[538])，.b(b[538])，.c(c[538])，
.sel(sel))；
xtmux3b i539(.xtout(xtout[539])，.a(a[539])，.b(b[539])，.c(c[539])，
.sel(sel))；
xtmux3b i540(.xtout(xtout[540])，.a(a[540])，.b(b[540])，.c(c[540])，
.sel(sel))；
xtmux3b i541(.xtout(xtout[541])，.a(a[541])，.b(b[541])，.c(c[541])，
.sel(sel))；
xtmux3b i542(.xtout(xtout[542])，.a(a[542])，.b(b[542])，.c(c[542])，
.sel(sel))；
xtmux3b i543(.xtout(xtout[543])，.a(a[543])，.b(b[543])，.c(c[543])，
.sel(sel))；
<dp n="d208"/>
xtmux3b i544(.xtout(xtout[544])，.a(a[544])，.b(b[544])，.c(c[544])，
.sel(sel))；
xtmux3b i545(.xtout(xtout[545])，.a(a[545])，.b(b[545])，.c(c[545])，
.sel(sel))；
xtmux3b i546(.xtout(xtout[546])，.a(a[546])，.b(b[546])，.c(c[546])，
.sel(sel))；
xtmux3b i547(.xtout(xtout[547])，.a(a[547])，.b(b[547])，.c(c[547])，
.sel(sel))；
xtmux3b i548(.xtout(xtout[548])，.a(a[548])，.b(b[548])，.c(c[548])，
.sel(sel))；
xtmux3b i549(.xtout(xtout[549])，.a(a[549])，.b(b[549])，.c(c[549])，
.sel(sel))；
xtmux3b i550(.xtout(xtout[550])，.a(a[550])，.b(b[550])，.c(c[550])，
.sel(sel))；
xtmux3b i551(.xtout(xtout[551])，.a(a[551])，.b(b[551])，.c(c[551])，
.sel(sel))；
xtmux3b i552(.xtout(xtout[552])，.a(a[552])，.b(b[552])，.c(c[552])，
.sel(sel))；
xtmux3b i553(.xtout(xtout[553])，.a(a[553])，.b(b[553])，.c(c[553])，
.sel(sel))；
xtmux3b i554(.xtout(xtout[554])，.a(a[554])，.b(b[554])，.c(c[554])，
.sel(sel))；
xtmux3b i555(.xtout(xtout[555])，.a(a[555])，.b(b[555])，.c(c[555])，
.sel(sel))；
xtmux3b i556(.xtout(xtout[556])，.a(a[556])，.b(b[556])，.c(c[556])，
.sel(sel))；
xtmux3b i557(.xtout(xtout[557])，.a(a[557])，.b(b[557])，.c(c[557])，
.sel(sel))；
xtmux3b i558(.xtout(xtout[558])，.a(a[558])，.b(b[558])，.c(c[558])，
.sel(sel))；
xtmux3b i559(.xtout(xtout[559])，.a(a[559])，.b(b[559])，.c(c[559])，
.sel(sel))；
xtmux3b i560(.xtout(xtout[560])，.a(a[560])，.b(b[560])，.c(c[560])，
.sel(sel))；
xtmux3b i561(.xtout(xtout[561])，.a(a[561])，.b(b[561])，.c(c[561])，
.sel(sel))；
xtmux3b i562(.xtout(xtout[562])，.a(a[562])，.b(b[562])，.c(c[562])，
.sel(sel))；
xtmux3b i563(.xtout(xtout[563])，.a(a[563])，.b(b[563])，.c(c[563])，
.sel(sel))；
xtmux3b i564(.xtout(xtout[564])，.a(a[564])，.b(b[564])，.c(c[564])，
.sel(sel))；
xtmux3b i565(.xtout(xtout[565])，.a(a[565])，.b(b[565])，.c(c[565])，
.sel(sel))；
xtmux3b i566(.xtout(xtout[566])，.a(a[566])，.b(b[566])，.c(c[566])，
.sel(sel))；
xtmux3b i567(.xtout(xtout[567])，.a(a[567])，.b(b[567])，.c(c[567])，
.sel(sel))；
xtmux3b i568(.xtout(xtout[568])，.a(a[568])，.b(b[568])，.c(c[568])，
.sel(sel))；
xtmux3b i569(.xtout(xtout[569])，.a(a[569])，.b(b[569])，.c(c[569])，
.sel(sel))；
xtmux3b i570(.xtout(xtout[570])，.a(a[570])，.b(b[570])，.c(c[570])，
.sel(sel))；
xtmux3b i571(.xtout(xtout[571])，.a(a[571])，.b(b[571])，.c(c[571])，
.sel(sel))；
xtmux3b i572(.xtout(xtout[572])，.a(a[572])，.b(b[572])，.c(c[572])，
.sel(sel))；
xtmux3b i573(.xtout(xtout[573])，.a(a[573])，.b(b[573])，.c(c[573])，
.sel(sel))；
<dp n="d209"/>
xtmux3b i574(.xtout(xtout[574])，.a(a[574])，.b(b[574])，.c(c[574])，
.sel(sel))；
xtmux3b i575(.xtout(xtout[575])，.a(a[575])，.b(b[575])，.c(c[575])，
.sel(sel))；
xtmux3b i576(.xtout(xtout[576])，.a(a[576])，.b(b[576])，.c(c[576])，
.sel(sel))；
xtmux3b i577(.xtout(xtout[577])，.a(a[577])，.b(b[577])，.c(c[577])，
.sel(sel))；
xtmux3b i578(.xtout(xtout[578])，.a(a[578])，.b(b[578])，.c(c[578])，
.sel(sel))；
xtmux3b i579(.xtout(xtout[579])，.a(a[579])，.b(b[579])，.c(c[579])，
.sel(sel))；
xtmux3b i580(.xtout(xtout[580])，.a(a[580])，.b(b[580])，.c(c[580])，
.sel(sel))；
xtmux3b i581(.xtout(xtout[581])，.a(a[581])，.b(b[581])，.c(c[581])，
.sel(sel))；
xtmux3b i582(.xtout(xtout[582])，.a(a[582])，.b(b[582])，.c(c[582])，
.sel(sel))；
xtmux3b i583(.xtout(xtout[583])，.a(a[583])，.b(b[583])，.c(c[583])，
.sel(sel))；
xtmux3b i584(.xtout(xtout[584])，.a(a[584])，.b(b[584])，.c(c[584])，
.sel(sel))；
xtmux3b i585(.xtout(xtout[585])，.a(a[585])，.b(b[585])，.c(c[585])，
.sel(sel))；
xtmux3b i586(.xtout(xtout[586])，.a(a[586])，.b(b[586])，.c(c[586])，
.sel(sel))；
xtmux3b i587(.xtout(xtout[587])，.a(a[587])，.b(b[587])，.c(c[587])，
.sel(sel))；
xtmux3b i588(.xtout(xtout[588])，.a(a[588])，.b(b[588])，.c(c[588])，
.sel(sel))；
xtmux3b i589(.xtout(xtout[589])，.a(a[589])，.b(b[589])，.c(c[589])，
.sel(sel))；
xtmux3b i590(.xtout(xtout[590])，.a(a[590])，.b(b[590])，.c(c[590])，
.sel(sel))；
xtmux3b i591(.xtout(xtout[591])，.a(a[591])，.b(b[591])，.c(c[591])，
.sel(sel))；
xtmux3b i592(.xtout(xtout[592])，.a(a[592])，.b(b[592])，.c(c[592])，
.sel(sel))；
xtmux3b i593(.xtout(xtout[593])，.a(a[593])，.b(b[593])，.c(c[593])，
.sel(sel))；
xtmux3b i594(.xtout(xtout[594])，.a(a[594])，.b(b[594])，.c(c[594])，
.sel(sel))；
xtmux3b i595(.xtout(xtout[595])，.a(a[595])，.b(b[595])，.c(c[595])，
.sel(sel))；
xtmux3b i596(.xtout(xtout[596])，.a(a[596])，.b(b[596])，.c(c[596])，
.sel(sel))；
xtmux3b i597(.xtout(xtout[597])，.a(a[597])，.b(b[597])，.c(c[597])，
.sel(sel))；
xtmux3b i598(.xtout(xtout[598]). .a(a[598])，.b(b[598])，.c(c[598])，
.sel(sel))；
xtmux3b i599(.xtout(xtout[599])，.a(a[599])，.b(b[599])，.c(c[599])，
.sel(sel))；
xtmux3b i600(.xtout(xtout[600])，.a(a[600])，.b(b[600])，.c(c[600])，
.sel(sel))；
xtmux3b i601(.xtout(xtout[601])，.a(a[60l])，.b(b[601])，.c(c[601])，
.sel(sel))；
xtmux3b i602(.xtout(xtout[602])，.a(a[602])，.b(b[602])，.c(c[602])，
.sel(sel))；
xtmux3b i603(.xtout(xtout[603])，.a(a[603])，.b(b[603])，.c(c[603])，
.sel(sel))；
<dp n="d210"/>
xtmux3b i604(.xtout(xtout[604])，.a(a[604])，.b(b[604])，.c(c[604])，
.sel(sel))；
xtmux3b i605(.xtout(xtout[605])，.a(a[605])，.b(b[605])，.c(c[605])，
.sel(sel))；
xtmux3b i606(.xtout(xtout[606])，.a(a[606])，.b(b[606])，.c(c[606])，
.sel(sel))；
xtmux3b i607(.xtout(xtout[607])，.a(a[607])，.b(b[607])，.c(c[607])，
.sel(sel))；
xtmux3b i608(.xtout(xtout[608])，.a(a[608])，.b(b[608])，.c(c[608])，
.sel(sel))；
xtmux3b i609(.xtout(xtout[609])，.a(a[609])，.b(b[609])，.c(c[609])，
.sel(sel))；
xtmux3b i610(.xtout(xtout[610])，.a(a[610])，.b(b[610])，.c(c[610])，
.sel(sel))；
xtmux3b i611(.xtout(xtout[611])，.a(a[611])，.b(b[611])，.c(c[611])，
.sel(sel))；
xtmux3b i612(.xtout(xtout[612])，.a(a[612])，.b(b[612])，.c(c[612])，
.sel(sel))；
xtmux3b i613(.xtout(xtout[613])，.a(a[613])，.b(b[613])，.c(c[613])，
.sel(sel))；
xtmux3b i614(.xtout(xtout[614])，.a(a[614])，.b(b[614])，.c(c[614])，
.el(sel))；
xtmux3b i615(.xtout(xtout[615])，.a(a[615])，.b(b[615])，.c(c[615])，
.sel(sel))；
xtmux3b i616(.xtout(xtout[616])，.a(a[616])，.b(b[616])，.c(c[616])，
.sel(sel))；
xtmux3b i617(.xtout(xtout[617])，.a(a[617])，.b(b[617])，.c(c[617])，
.sel(sel))；
xtmux3b i618(.xtout(xtout[618])，.a(a[618])，.b(b[618])，.c(c[618])，
.sel(sel))；
xtmux3b i619(.xtout(xtout[619])，.a(a[619])，.b(b[619])，.c(c[619])，
.sel(sel))；
xtmux3b i620(.xtout(xtout[620])，.a(a[620])，.b(b[620])，.c(c[620])，
.sel(sel))；
xtmux3b i621(.xtout(xtout[621])，.a(a[621])，.b(b[621])，.c(c[621])，
.sel(sel))；
xtmux3b i622(.xtout(xtout[622])，.a(a[622])，.b(b[622])，.c(c[622])，
.sel(sel))；
xtmux3b i623(.xtout(xtout[623])，.a(a[623])，.b(b[623])，.c(c[623])，
.sel(sel))；
xtmux3b i624(.xtout(xtout[624])，.a(a[624])，.b(b[624])，.c(c[624])，
.sel(sel))；
xtmux3b i625(.xtout(xtout[625])，.a(a[625])，.b(b[625])，.c(c[625])，
.sel(sel))；
xtmux3b i626(.xtout(xtout[626])，.a(a[626])，.b(b[626])，.c(c[626])，
.sel(sel))；
xtmux3b i627(.xtout(xtout[627])，.a(a[627])，.b(b[627])，.c(c[627])，
.sel(sel))；
xtmux3b i628(.xtout(xtout[628])，.a(a[628])，.b(b[628])，.c(c[628])，
.sel(sel))；
xtmux3b i629(.xtout(xtout[629])，.a(a[629])，.b(b[629])，.c(c[629])，
.sel(sel))；
xtmux3b i630(.xtout(xtout[630])，.a(a[630])，.b(b[630])，.c(c[630])，
.sel(sel))；
xtmux3b i631(.xtout(xtout[631])，.a(a[631])，.b(b[631])，.c(c[631])，
.sel(sel))；
xtmux3b i632(.xtout(xtout[632])，.a(a[632])，.b(b[632])，.c(c[632])，
.sel(sel))；
xtmux3b i633(.xtout(xtout[633])，.a(a[633])，.b(b[633])，.c(c[633])，
.sel(sel))；
<dp n="d211"/>
xtmux3b i634(.xtout(xtout[634])，.a(a[634])，.b(b[634])，.c(c[634])，
.sel(sel))；
xtmux3b i635(.xtout(xtout[635])，.a(a[635])，.b(b[635])，.c(c[635])，
.sel(sel))；
xtmux3b i636(.xtout(xtout[636])，.a(a[636])，.b(b[636])，.c(c[636])，
.sel(sel))；
xtmux3b i637(.xtout(xtout[637])，.a(a[637])，.b(b[637])，.c(c[637])，
.sel(sel))；
xtmux3b i638(.xtout(xtout[638])，.a(a[638])，.b(b[638])，.c(c[638])，
.sel(sel))；
xtmux3b i639(.xtout(xtout[639])，.a(a[639])，.b(b[639])，.c(c[639])，
.sel(sel))；
xtmux3b i640(.xtout(xtout[640])，.a(a[640])，.b(b[640])，.c(c[640])，
.sel(sel))；
xtmux3b i641(.xtout(xtout[641])，.a(a[641])，.b(b[641])，.c(c[641])，
.sel(sel))；
xtmux3b i642(.xtout(xtout[642])，.a(a[642])，.b(b[642])，.c(c[642])，
.sel(sel))；
xtmux3b i643(.xtout(xtout[643])，.a(a[643])，.b(b[643])，.c(c[643])，
.sel(sel))；
xtmux3b i644(.xtout(xtout[644])，.a(a[644])，.b(b[644])，.c(c[644])，
.sel(sel))；
xtmux3b i645(.xtout(xtout[645])，.a(a[645])，.b(b[645])，.c(c[645])，
.sel(sel))；
xtmux3b i646(.xtout(xtout[646])，.a(a[646])，.b(b[646])，.c(c[646])，
.sel(sel))；
xtmux3b i647(.xtout(xtout[647])，.a(a[647])，.b(b[647])，.c(c[647])，
.sel(sel))；
xtmux3b i648(.xtout(xtout[648])，.a(a[648])，.b(b[648])，.c(c[648])，
.sel(sel))；
xtmux3b i649(.xtout(xtout[649])，.a(a[649])，.b(b[649])，.c(c[649])，
.sel(sel))；
xtmux3b i650(.xtout(xtout[650])，.a(a[650])，.b(b[650])，.c(c[650])，
.sel(sel))；
xtmux3b i651(.xtout(xtout[651])，.a(a[651])，.b(b[651])，.c(c[651])，
.sel(sel))；
xtmux3b i652(.xtout(xtout[652])，.a(a[652])，.b(b[652])，.c(c[652])，
.sel(sel))；
xtmux3b i653(.xtout(xtout[653])，.a(a[653])，.b(b[653])，.c(c[653])，
.sel(sel))；
xtmux3b i654(.xtout(xtout[654])，.a(a[654])，.b(b[654])，.c(c[654])，
.sel(sel))；
xtmux3b i655(.xtout(xtout[655])，.a(a[655])，.b(b[655])，.c(c[655])，
.sel(sel))；
xtmux3b i656(.xtout(xtout[656])，.a(a[656])，.b(b[656])，.c(c[656])，
.sel(sel))；
xtmux3b i657(.xtout(xtout[657])，.a(a[657])，.b(b[657])，.c(c[657])，
.sel(sel))；
xtmux3b i658(.xtout(xtout[658])，.a(a[658])，.b(b[658])，.c(c[658])，
.sel(sel))；
xtmux3b i659(.xtout(xtout[659])，.a(a[659])，.b(b[659])，.c(c[659])，
.sel(sel))；
xtmux3b i660(.xtout(xtout[660])，.a(a[660])，.b(b[660])，.c(c[660])，
.sel(sel))；
xtmux3b i661(.xtout(xtout[661])，.a(a[661])，.b(b[661])，.c(c[661])，
.sel(sel))；
xtmux3b i662(.xtout(xtout[662])，.a(a[662])，.b(b[662])，.c(c[662])，
.sel(sel))；
xtmux3b i663(.xtout(xtout[663])，.a(a[663])，.b(b[663])，.c(c[663])，
.sel(sel))；
<dp n="d212"/>
xtmux3b i664(.xtout(xtout[664])，.a(a[664])，.b(b[664])，.c(c[664])，
.sel(sel))；
xtmux3b i665(.xtout(xtout[665])，.a(a[665])，.b(b[665])，.c(c[665])，
.sel(sel))；
xtmux3b i666(.xtout(xtout[666])，.a(a[666])，.b(b[666])，.c(c[666])，
.sel(sel))；
xtmux3b i667(.xtout(xtout[667])，.a(a[667])，.b(b[667])，.c(c[667])，
.sel(sel))；
xtmux3b i668(.xtout(xtout[668])，.a(a[668])，.b(b[668])，.c(c[668])，
.sel(sel))；
xtmux3b i669(.xtout(xtout[669])，.a(a[669])，.b(b[669])，.c(c[669])，
.sel(sel))；
xtmux3b i670(.xtout(xtout[670])，.a(a[670])，.b(b[670])，.c(c[670])，
.sel(sel))；
xtmux3b i671(.xtout(xtout[671])，.a(a[671])，.b(b[671])，.c(c[671])，
.sel(sel))；
xtmux3b i672(.xtout(xtout[672])，.a(a[672])，.b(b[672])，.c(c[672])，
.sel(sel))；
xtmux3b i673(.xtout(xtout[673])，.a(a[673])，.b(b[673])，.c(c[673])，
.sel(sel))；
xtmux3b i674(.xtout(xtout[674])，.a(a[674])，.b(b[674])，.c(c[674])，
.sel(sel))；
xtmux3b i675(.xtout(xtout[675])，.a(a[675])，.b(b[675])，.c(c[675])，
.sel(sel))；
xtmux3b i676(.xtout(xtout[676])，.a(a[676])，.b(b[676])，.c(c[676])，
.sel(sel))；
xtmux3b i677(.xtout(xtout[677])，.a(a[677])，.b(b[677])，.c(c[677])，
.sel(sel))；
xtmux3b i678(.xtout(xtout[678])，.a(a[678])，.b(b[678])，.c(c[678])，
.sel(sel))；
xtmux3b i679(.xtout(xtout[679])，.a(a[679])，.b(b[679])，.c(c[679])，
.sel(sel))；
xtmux3b i680(.xtout(xtout[680])，.a(a[680])，.b(b[680])，.c(c[680])，
.sel(sel))；
xtmux3b i681(.xtout(xtout[681])，.a(a[681])，.b(b[681])，.c(c[681])，
.sel(sel))；
xtmux3b i682(.xtout(xtout[682])，.a(a[682])，.b(b[682])，.c(c[682])，
.sel(sel))；
xtmux3b i683(.xtout(xtout[683])，.a(a[683])，.b(b[683])，.c(c[683])，
.sel(sel))；
xtmux3b i684(.xtout(xtout[684])，.a(a[684])，.b(b[684])，.c(c[684])，
.sel(sel))；
xtmux3b i685(.xtout(xtout[685])，.a(a[685])，.b(b[685])，.c(c[685])，
.sel(sel))；
xtmux3b i686(.xtout(xtout[686])，.a(a[686])，.b(b[686])，.c(c[686])，
.sel(sel))；
xtmux3b i687(.xtout(xtout[687])，.a(a[687])，.b(b[687])，.c(c[687])，
.sel(sel))；
xtmux3b i688(.xtout(xtout[688])，.a(a[688])，.b(b[688])，.c(c[688])，
.sel(sel))；
xtmux3b i689(.xtout(xtout[689])，.a(a[689])，.b(b[689])，.c(c[689])，
.sel(sel))；
xtmux3b i690(.xtout(xtout[690])，.a(a[690])，.b(b[690])，.c(c[690])，
.sel(sel))；
xtmux3b i691(.xtout(xtout[691])，.a(a[691])，.b(b[691])，.c(c[691])，
.sel(sel))；
xtmux3b i692(.xtout(xtout[692])，.a(a[692])，.b(b[692])，.c(c[692])，
.sel(sel))；
xtmux3b i693(.xtout(xtout[693])，.a(a[693])，.b(b[693])，.c(c[693])，
.sel(sel))；
<dp n="d213"/>
xtmux3b i694(.xtout(xtout[694])，.a(a[694])，.b(b[694])，.c(c[694])，
.sel(sel))；
xtmux3b i695(.xtout(xtout[695])，.a(a[695])，.b(b[695])，.c(c[695])，
.sel(sel))；
xtmux3b i696(.xtout(xtout[696])，.a(a[696])，.b(b[696])，.c(c[696])，
.sel(sel))；
xtmux3b i697(.xtout(xtout[697])，.a(a[697])，.b(b[697])，.c(c[697])，
.sel(sel))；
xtmux3b i698(.xtout(xtout[698])，.a(a[698])，.b(b[698])，.c(c[698])，
.sel(sel))；
xtmux3b i699(.xtout(xtout[699])，.a(a[699])，.b(b[699])，.c(c[699])，
.sel(sel))；
xtmux3b i700(.xtout(xtout[700])，.a(a[700])，.b(b[700])，.c(c[700])，
.sel(sel))；
xtmux3b i701(.xtout(xtout[701])，.a(a[701])，.b(b[701])，.c(c[701])，
.sel(sel))；
xtmux3b i702(.xtout(xtout[702])，.a(a[702])，.b(b[702])，.c(c[702])，
.sel(sel))；
xtmux3b i703(.xtout(xtout[703])，.a(a[703])，.b(b[703])，.c(c[703])，
.sel(sel))；
xtmux3b i704(.xtout(xtout[704])，.a(a[704])，.b(b[704])，.c(c[704])，
.sel(sel))；
xtmux3b i705(.xtout(xtout[705])，.a(a[705])，.b(b[705])，.c(c[705])，
.sel(sel))；
xtmux3b i706(.xtout(xtout[706])，.a(a[706])，.b(b[706])，.c(c[706])，
.sel(sel))；
xtmux3b i707(.xtout(xtout[707])，.a(a[707])，.b(b[707])，.c(c[707])，
.sel(sel))；
xtmux3b i708(.xtout(xtout[708])，.a(a[708])，.b(b[708])，.c(c[708])，
.sel(sel))；
xtmux3b i709(.xtout(xtout[709])，.a(a[709])，.b(b[709])，.c(c[709])，
.sel(sel))；
xtmux3b i710(.xtout(xtout[710])，.a(a[710])，.b(b[710])，.c(c[710])，
.sel(sel))；
xtmux3b i711(.xtout(xtout[711])，.a(a[711])，.b(b[711])，.c(c[711])，
.sel(sel))；
xtmux3b i712(.xtout(xtout[712])，.a(a[712])，.b(b[712])，.c(c[712])，
.sel(sel))；
xtmux3b i713(.xtout(xtout[713])，.a(a[713])，.b(b[713])，.c(c[713])，
.sel(sel))；
xtmux3b i714(.xtout(xtout[714])，.a(a[714])，.b(b[714])，.c(c[714])，
.sel(sel))；
xtmux3b i715(.xtout(xtout[715])，.a(a[715])，.b(b[715])，.c(c[715])，
.sel(sel))；
xtmux3b i716(.xtout(xtout[716])，.a(a[716])，.b(b[716])，.c(c[716])，
.sel(sel))；
xtmux3b i717(.xtout(xtout[717])，.a(a[717])，.b(b[717])，.c(c[717])，
.sel(sel))；
xtmux3b i718(.xtout(xtout[718])，.a(a[718])，.b(b[718])，.c(c[718])，
.sel(sel))；
xtmux3b i719(.xtout(xtout[719])，.a(a[719])，.b(b[719])，.c(c[719])，
.sel(sel))；
xtmux3b i720(.xtout(xtout[720])，.a(a[720])，.b(b[720])，.c(c[720])，
.sel(sel))；
xtmux3b i721(.xtout(xtout[721])，.a(a[721])，.b(b[721])，.c(c[721])，
.sel(sel))；
xtmux3b i722(.xtout(xtout[722])，.a(a[722])，.b(b[722])，.c(c[722])，
.sel(sel))；
xtmux3b i723(.xtout(xtout[723])，.a(a[723])，.b(b[723])，.c(c[723])，
.sel(sel))；
<dp n="d214"/>
xtmux3b i724(.xtout(xtout[724])，.a(a[724])，.b(b[724])，.c(c[724])，
.sel(sel))；
xtmux3b i725(.xtout(xtout[725])，.a(a[725])，.b(b[725])，.c(c[725])，
.sel(sel))；
xtmux3b i726(.xtout(xtout[726])，.a(a[726])，.b(b[726])，.c(c[726])，
.sel(sel))；
xtmux3b i727(.xtout(xtout[727])，.a(a[727])，.b(b[727])，.c(c[727])，
.sel(sel))；
xtmux3b i728(.xtout(xtout[728])，.a(a[728])，.b(b[728])，.c(c[728])，
.sel(sel))；
xtmux3b i729(.xtout(xtout[729])，.a(a[729])，.b(b[729])，.c(c[729])，
.sel(sel))；
xtmux3b i730(.xtout(xtout[730])，.a(a[730])，.b(b[730])，.c(c[730])，
.sel(sel))；
xtmux3b i731(.xtout(xtout[731])，.a(a[731])，.b(b[731])，.c(c[731])，
.sel(sel))；
xtmux3b i732(.xtout(xtout[732])，.a(a[732])，.b(b[732])，.c(c[732])，
.sel(sel))；
xtmux3b i733(.xtout(xtout[733])，.a(a[733])，.b(b[733])，.c(c[733])，
.sel(sel))；
xtmux3b i734(.xtout(xtout[734])，.a(a[734])，.b(b[734])，.c(c[734])，
.sel(sel))；
xtmux3b i735(.xtout(xtout[735])，.a(a[735])，.b(b[735])，.c(c[735])，
.sel(sel))；
xtmux3b i736(.xtout(xtout[736])，.a(a[736])，.b(b[736])，.c(c[736])，
.sel(sel))；
xtmux3b i737(.xtout(xtout[737])，.a(a[737])，.b(b[737])，.c(c[737])，
.sel(sel))；
xtmux3b i738(.xtout(xtout[738])，.a(a[738])，.b(b[738])，.c(c[738])，
.sel(sel))；
xtmux3b i739(.xtout(xtout[739])，.a(a[739])，.b(b[739])，.c(c[739])，
.sel(sel))；
xtmux3b i740(.xtout(xtout[740])，.a(a[740])，.b(b[740])，.c(c[740])，
.sel(sel))；
xtmux3b i741(.xtout(xtout[741])，.a(a[741])，.b(b[741])，.c(c[741])，
.sel(sel))；
xtmux3b i742(.xtout(xtout[742])，.a(a[742])，.b(b[742])，.c(c[742])，
.sel(sel))；
xtmux3b i743(.xtout(xtout[743])，.a(a[743])，.b(b[743])，.c(c[743])，
.sel(sel))；
xtmux3b i744(.xtout(xtout[744])，.a(a[744])，.b(b[744])，.c(c[744])，
.sel(sel))；
xtmux3b i745(.xtout(xtout[745])，.a(a[745])，.b(b[745])，.c(c[745])，
.sel(sel))；
xtmux3b i746(.xtout(xtout[746])，.a(a[746])，.b(b[746])，.c(c[746])，
.sel(sel))；
xtmux3b i747(.xtout(xtout[747])，.a(a[747])，.b(b[747])，.c(c[747])，
.sel(sel))；
xtmux3b i748(.xtout(xtout[748])，.a(a[748])，.b(b[748])，.c(c[748])，
.sel(sel))；
xtmux3b i749(.xtout(xtout[749])，.a(a[749])，.b(b[749])，.c(c[749])，
.sel(sel))；
xtmux3b i750(.xtout(xtout[750])，.a(a[750])，.b(b[750])，.c(c[750])，
.sel(sel))；
xtmux3b i751(.xtout(xtout[751])，.a(a[751])，.b(b[751])，.c(c[751])，
.sel(sel))；
xtmux3b i752(.xtout(xtout[752])，.a(a[752])，.b(b[752])，.c(c[752])，
.sel(sel))；
xtmux3b i753(.xtout(xtout[753])，.a(a[753])，.b(b[753])，.c(c[753])，
.sel(sel))；
<dp n="d215"/>
xtmux3b i754(.xtout(xtout[754])，.a(a[754])，.b(b[754])，.c(c[754])，
.sel(sel))；
xtmux3b i755(.xtout(xtout[755])，.a(a[755])，.b(b[755])，.c(c[755])，
.sel(sel))；
xtmux3b i756(.xtout(xtout[756])，.a(a[756])，.b(b[756])，.c(c[756])，
.sel(sel))；
xtmux3b i757(.xtout(xtout[757])，.a(a[757])，.b(b[757])，.c(c[757])，
.sel(sel))；
xtmux3b i758(.xtout(xtout[758])，.a(a[758])，.b(b[758])，.c(c[758])，
.sel(sel))；
xtmux3b i759(.xtout(xtout[759])，.a(a[759])，.b(b[759])，.c(c[759])，
.sel(sel))；
xtmux3b i760(.xtout(xtout[760])，.a(a[760])，.b(b[760])，.c(c[760])，
.sel(sel))；
xtmux3b i761(.xtout(xtout[761])，.a(a[761])，.b(b[761])，.c(c[761])，
.sel(sel))；
xtmux3b i762(.xtout(xtout[762])，.a(a[762])，.b(b[762])，.c(c[762])，
.sel(sel))；
xtmux3b i763(.xtout(xtout[763])，.a(a[763])，.b(b[763])，.c(c[763])，
.sel(sel))；
xtmux3b i764(.xtout(xtout[764])，.a(a[764])，.b(b[764])，.c(c[764])，
.sel(sel))；
xtmux3b i765(.xtout(xtout[765])，.a(a[765])，.b(b[765])，.c(c[765])，
.sel(sel))；
xtmux3b i766(.xtout(xtout[766])，.a(a[766])，.b(b[766])，.c(c[766])，
.sel(sel))；
xtmux3b i767(.xtout(xtout[767])，.a(a[767])，.b(b[767])，.c(c[767])，
.sel(sel))；
xtmux3b i768(.xtout(xtout[768])，.a(a[768])，.b(b[768])，.c(c[768])，
.sel(sel))；
xtmux3b i769(.xtout(xtout[769])，.a(a[769])，.b(b[769])，.c(c[769])，
.sel(sel))；
xtmux3b i770(.xtout(xtout[770])，.a(a[770])，.b(b[770])，.c(c[770])，
.sel(sel))；
xtmux3b i771(.xtout(xtout[771])，.a(a[771])，.b(b[771])，.c(c[771])，
.sel(sel))；
xtmux3b i772(.xtout(xtout[772])，.a(a[772])，.b(b[772])，.c(c[772])，
.sel(sel))；
xtmux3b i773(.xtout(xtout[773])，.a(a[773])，.b(b[773])，.c(c[773])，
.sel(sel))；
xtmux3b i774(.xtout(xtout[774])，.a(a[774])，.b(b[774])，.c(c[774])，
.sel(sel))；
xtmux3b i775(.xtout(xtout[775])，.a(a[775])，.b(b[775])，.c(c[775])，
.sel(sel))；
xtmux3b i776(.xtout(xtout[776])，.a(a[776])，.b(b[776])，.c(c[776])，
.sel(sel))；
xtmux3b i777(.xtout(xtout[777])，.a(a[777])，.b(b[777])，.c(c[777])，
.sel(sel))；
xtmux3b i778(.xtout(xtout[778])，.a(a[778])，.b(b[778])，.c(c[778])，
.sel(sel))；
xtmux3b i779(.xtout(xtout[779])，.a(a[779])，.b(b[779])，.c(c[779])，
.sel(sel))；
xtmux3b i780(.xtout(xtout[780])，.a(a[780])，.b(b[780])，.c(c[780])，
.sel(sel))；
xtmux3b i781(.xtout(xtout[781])，.a(a[781])，.b(b[781])，.c(c[781])，
.sel(sel))；
xtmux3b i782(.xtout(xtout[782])，.a(a[782])，.b(b[782])，.c(c[782])，
.sel(sel))；
xtmux3b i783(.xtout(xtout[783])，.a(a[783])，.b(b[783])，.c(c[783])，
.sel(sel))；
<dp n="d216"/>
xtmux3b i784(.xtout(xtout[784])，.a(a[784])，.b(b[784])，.c(c[784])，
.sel(sel))；
xtmux3b i785(.xtout(xtout[785])，.a(a[785])，.b(b[785])，.c(c[785])，
.sel(sel))；
xtmux3b i786(.xtout(xtout[786])，.a(a[786])，.b(b[786])，.c(c[786])，
.sel(sel))；
xtmux3b i787(.xtout(xtout[787])，.a(a[787])，.b(b[787])，.c(c[787])，
.sel(sel))；
xtmux3b i788(.xtout(xtout[788])，.a(a[788])，.b(b[788])，.c(c[788])，
.sel(sel))；
xtmux3b i789(.xtout(xtout[789])，.a(a[789])，.b(b[789])，.c(c[789])，
.sel(sel))；
xcmux3b i790(.xtout(xtout[790])，.a(a[790])，.b(b[790])，.c(c[790])，
.sel(sel))；
xtmux3b i791(.xtout(xtout[791])，.a(a[791])，.b(b[791])，.c(c[791])，
.sel(sel))；
xtmux3b i792(.xtout(xtout[792])，.a(a[792])，.b(b[792])，.c(c[792])，
.sel(sel))；
xtmux3b i793(.xtout(xtout[793])，.a(a[793])，.b(b[793])，.c(c[793])，
.sel(sel))；
xtmux3b i794(.xtout(xtout[794])，.a(a[794])，.b(b[794])，.c(c[794])，
.sel(sel))；
xtmux3b i795(.xtout(xtout[795])，.a(a[795])，.b(b[795])，.c(c[795])，
.sel(sel))；
xtmux3b i796(.xtout(xtout[796])，.a(a[796])，.b(b[796])，.c(c[796])，
.sel(sel))；
xtmux3b i797(.xtout(xtout[797])，.a(a[797])，.b(b[797])，.c(c[797])，
.sel(sel))；
xtmux3b i798(.xtout(xtout[798])，.a(a[798])，.b(b[798])，.c(c[798])，
.sel(sel))；
xtmux3b i799(.xtout(xtout[799])，.a(a[799])，.b(b[799])，.c(c[799])，
.sel(sel))；
xtmux3b i800(.xtout(xtout[800])，.a(a[800])，.b(b[800])，.c(c[800])，
.sel(sel))；
xtmux3b i801(.xtout(xtout[801])，.a(a[801])，.b(b[801])，.c(c[801])，
.sel(sel))；
xtmux3b i802(.xtout(xtout[802])，.a(a[802])，.b(b[802])，.c(c[802])，
.sel(sel))；
xtmux3b i803(.xtout(xtout[803])，.a(a[803])，.b(b[803])，.c(c[803])，
.sel(sel))；
xtmux3b i804(.xtout(xtout[804])，.a(a[804])，.b(b[804])，.c(c[804])，
.sel(sel))；
xtmux3b i805(.xtout(xtout[805])，.a(a[805])，.b(b[805])，.c(c[805])，
.sel(sel))；
xtmux3b i806(.xtout(xtout[806])，.a(a[806])，.b(b[806])，.c(c[806])，
.sel(sel))；
xtmux3b i807(.xtout(xtout[807])，.a(a[807])，.b(b[807])，.c(c[807])，
.sel(sel))；
xtmux3b i808(.xtout(xtout[808])，.a(a[808])，.b(b[808])，.c(c[808])，
.sel(sel))；
xtmux3b i809(.xtout(xtout[809])，.a(a[809])，.b(b[809])，.c(c[809])，
.sel(sel))；
xtmux3b i810(.xtout(xtout[810])，.a(a[810])，.b(b[810])，.c(c[810])，
.sel(sel))；
xtmux3b i811(.xtout(xtout[811])，.a(a[811])，.b(b[811])，.c(c[811])，
.sel(sel))；
xtmux3b i812(.xtout(xtout[812])，.a(a[812])，.b(b[812])，.c(c[812])，
.sel(sel))；
xtmux3b i813(.xtout(xtout[813])，.a(a[813])，.b(b[813])， c(c[813])，
.sel(sel))；
<dp n="d217"/>
xtmux3b i814(.xtout(xtout[814])，.a(a[814])，.b(b[814])，.c(c[814])，
.sel(sel))；
xtmux3b i815(.xtout(xtout[815])，.a(a[815])，.b(b[815])，.c(c[815])，
.sel(sel))；
xtmux3b i816(.xtout(xtout[816])，.a(a[816])，.b(b[816])，.c(c[816])，
.sel(sel))；
xtmux3b i817(.xtout(xtout[817])，.a(a[817])，.b(b[817])，.c(c[817])，
.sel(sel))；
xtmux3b i818(.xtout(xtout[818])，.a(a[818])，.b(b[818])，.c(c[818])，
.sel(sel))；
xtmux3b i819(.xtout(xtout[819])，.a(a[819])，.b(b[819])，.c(c[819])，
.sel(sel))；
xtmux3b i820(.xtout(xtout[820])，.a(a[820])，.b(b[820])，.c(c[820])，
.sel(sel))；
xtmux3b i821(.xtout(xtout[821])，.a(a[821])，.b(b[821])，.c(c[821])，
.sel(sel))；
xtmux3b i822(.xtout(xtout[822])，.a(a[822])，.b(b[822])，.c(c[822])，
.sel(sel))；
xtmux3b i823(.xtout(xtout[823])，.a(a[823])，.b(b[823])，.c(c[823])，
.sel(sel))；
xtmux3b i824(.xtout(xtout[824])，.a(a[824])，.b(b[824])，.c(c[824])，
.sel(sel))；
xtmux3b i825(.xtout(xtout[825])，.a(a[825])，.b(b[825])，.c(c[825])，
.sel(sel))；
xtmux3b i826(.xtout(xtout[826])，.a(a[826])，.b(b[826])，.c(c[826])，
.sel(sel))；
xtmux3b i827(.xtout(xtout[827])，.a(a[827])，.b(b[827])，.c(c[827])，
.sel(sel))；
xtmux3b i828(.xtout(xtout[828])，.a(a[828])，.b(b[828])，.c(c[828])，
.sel(sel))；
xtmux3b i829(.xtout(xtout[829])，.a(a[829])，.b(b[829])，.c(c[829])，
.sel(sel))；
xtmux3b i830(.xtout(xtout[830])，.a(a[830])，.b(b[830])，.c(c[830])，
.sel(sel))；
xtmux3b i831(.xtout(xtout[831])，.a(a[831])，.b(b[831])，.c(c[831])，
.sel(sel))；
xtmux3b i832(.xtout(xtout[832])，.a(a[832])，.b(b[832])，.c(c[832])，
.sel(sel))；
xtmux3b i833(.xtout(xtout[833])，.a(a[833])，.b(b[833])，.c(c[833])，
.sel(sel))；
xtmux3b i834(.xtout(xtout[834])，.a(a[834])，.b(b[834])，.c(c[834])，
.sel(sel))；
xtmux3b i835(.xtout(xtout[835])，.a(a[835])，.b(b[835])，.c(c[835])，
.sel(sel))；
xtmux3b i836(.xtout(xtout[836])，.a(a[836])，.b(b[836])，.c(c[836])，
.sel(sel))；
xtmux3b i837(.xtout(xtout[837])，.a(a[837])，.b(b[837])，.c(c[837])，
.sel(sel))；
xtmux3b i838(.xtout(xtout[838])，.a(a[838])，.b(b[838])，.c(c[838])，
.sel(sel))；
xtmux3b i839(.xtout(xtout[839])，.a(a[839])，.b(b[839])，.c(c[839])，
.sel(sel))；
xtmux3b i840(.xtout(xtout[840])，.a(a[840])，.b(b[840])，.c(c[840])，
.sel(sel))；
xtmux3b i841(.xtout(xtout[841])，.a(a[841])，.b(b[841])，.c(c[841])，
.sel(sel))；
xtmux3b i842(.xtout(xtout[842])，.a(a[842])，.b(b[842])，.c(c[842])，
.sel(sel))；
xtmux3b i843(.xtout(xtout[843])，.a(a[843])，.b(b[843])，.c(c[843])，
.sel(sel))；
<dp n="d218"/>
xtmux3b i844(.xtout(xtout[844])，.a(a[844])，.b(b[844])，.c(c[844])，
.sel(sel))；
xtmux3b i845(.xtout(xtout[845])，.a(a[845])，.b(b[845])，.c(c[845])，
.sel(sel))；
xtmux3b i846(.xtout(xtout[846])，.a(a[846])，.b(b[846])，.c(c[846])，
.sel(sel))；
xtmux3b i847(.xtout(xtout[847])，.a(a[847])，.b(b[847])，.c(c[847])，
.sel(sel))；
xtmux3b i848(.xtout(xtout[848])，.a(a[848])，.b(b[848])，.c(c[848])，
.sel(sel))；
xtmux3b i849(.xtout(xtout[849])，.a(a[849])，.b(b[849])，.c(c[849])，
.sel(sel))；
xtmux3b i850(.xtout(xtout[850])，.a(a[850])，.b(b[850])，.c(c[850])，
.sel(sel))；
xtmux3b i851(.xtout(xtout[851])，.a(a[851])，.b(b[851])，.c(c[851])，
.sel(sel))；
xtmux3b i852(.xtout(xtout[852])，.a(a[852])，.b(b[852])，.c(c[852])，
.sel(sel))；
xtmux3b i853(.xtout(xtout[853])，.a(a[853])，.b(b[853])，.c(c[853])，
.sel(sel))；
xtmux3b i854(.xtout(xtout[854])，.a(a[854])，.b(b[854])，.c(c[854])，
.sel(sel))；
xtmux3b i855(.xtout(xtout[855])，.a(a[855])，.b(b[855])，.c(c[855])，
.sel(sel))；
xtmux3b i856(.xtout(xtout[856])，.a(a[856])，.b(b[856])，.c(c[856])，
.sel(sel))；
xtmux3b i857(.xtout(xtout[857])，.a(a[857])，.b(b[857])，.c(c[857])，
.sel(sel))；
xtmux3b i858(.xtout(xtout[858])，.a(a[858])，.b(b[858])，.c(c[858])，
.sel(sel))；
xtmux3b i859(.xtout(xtout[859])，.a(a[859])，.b(b[859])，.c(c[859])，
.sel(sel))；
xtmux3b i860(.xtout(xtout[860])，.a(a[860])，.b(b[860])，.c(c[860])，
.sel(sel))；
xtmux3b i861(.xtout(xtout[861])，.a(a[861])，.b(b[861])，.c(c[861])，
.sel(sel))；
xtmux3b i862(.xtout(xtout[862])，.a(a[862])，.b(b[862])，.c(c[862])，
.sel(sel))；
xtmux3b i863(.xtout(xtout[863])，.a(a[863])，.b(b[863])，.c(c[863])，
.sel(sel))；
xtmux3b i864(.xtout(xtout[864])，.a(a[864])，.b(b[864])，.c(c[864])，
.sel(sel))；
xtmux3b i865(.xtout(xtout[865])，.a(a[865])，.b(b[865])，.c(c[865])，
.sel(sel))；
xtmux3b i866(.xtout(xtout[866])，.a(a[866])，.b(b[866])，.c(c[866])，
.sel(sel))；
xtmux3b i867(.xtout(xtout[867])，.a(a[867])，.b(b[867])，.c(c[867])，
.sel(sel))；
xtmux3b i868(.xtout(xtout[868])，.a(a[868])，.b(b[868])，.c(c[868])，
.sel(sel))；
xtmux3b i869(.xtout(xtout[869])，.a(a[869])，.b(b[869])，.c(c[869])，
.sel(sel))；
xtmux3b i870(.xtout(xtout[870])，.a(a[870])，.b(b[870])，.c(c[870])，
.sel(sel))；
xtmux3b i871(.xtout(xtout[871])，.a(a[871])，.b(b[871])，.c(c[871])，
.sel(sel))；
xtmux3b i872(.xtout(xtout[872])，.a(a[872])，.b(b[872])，.c(c[872])，
.sel(sel))；
xtmux3b i873(.xtout(xtout[873])，.a(a[873])，.b(b[873])，.c(c[873])，
.sel(sel))；
<dp n="d219"/>
xtmux3b i874(.xtout(xtout[874])，.a(a[874])，.b(b[874])，.c(c[874])，
.sel(sel))；
xtmux3b i875(.xtout(xtout[875])，.a(a[875])，.b(b[875])，.c(c[875])，
.sel(sel))；
xtmux3b i876(.xtout(xtout[876])，.a(a[876])，.b(b[876])，.c(c[876])，
.sel(sel))；
xtmux3b i877(.xtout(xtout[877])，.a(a[877])，.b(b[877])，.c(c[877])，
.sel(sel))；
xtmux3b i878(.xtout(xtout[878])，.a(a[878])，.b(b[878])，.c(c[878])，
.sel(sel))；
xtmux3b i879(.xtout(xtout[879])，.a(a[879])，.b(b[879])，.c(c[879])，
.sel(sel))；
xtmux3b i880(.xtout(xtout[880])，.a(a[880])，.b(b[880])，.c(c[880])，
.sel(sel))；
xtmux3b i881(.xtout(xtout[881])，.a(a[881])，.b(b[881])，.c(c[881])，
.sel(sel))；
xtmux3b i882(.xtout(xtout[882])，.a(a[882])，.b(b[882])，.c(c[882])，
.sel(sel))；
xtmux3b i883(.xtout(xtout[883])，.a(a[883])，.b(b[883])，.c(c[883])，
.sel(sel))；
xtmux3b i884(.xtout(xtout[884])，.a(a[884])，.b(b[884])，.c(c[884])，
.sel(sel))；
xtmux3b i885(.xtout(xtout[885])，.a(a[885])，.b(b[885])，.c(c[885])，
.sel(sel))；
xtmux3b i886(.xtout(xtout[886])，.a(a[886])，.b(b[886])，.c(c[886])，
.sel(sel))；
xtmux3b i887(.xtout(xtout[887])，.a(a[887])，.b(b[887])，.c(c[887])，
.sel(sel))；
xtmux3b i888(.xtout(xtout[888])，.a(a[888])，.b(b[888])，.c(c[888])，
.sel(sel))；
xtmux3b i889(.xtout(xtout[889])，.a(a[889])，.b(b[889])，.c(c[889])，
.sel(sel))；
xtmux3b i890(.xtout(xtout[890])，.a(a[890])，.b(b[890])，.c(c[890])，
.sel(sel))；
xtmux3b i891(.xtout(xtout[891])，.a(a[891])，.b(b[891])，.c(c[891])，
.sel(sel))；
xtmux3b i892(.xtout(xtout[892])，.a(a[892])，.b(b[892])，.c(c[892])，
.sel(sel))；
xtmux3b i893(.xtout(xtout[893])，.a(a[893])，.b(b[893])，.c(c[893])，
.sel(sel))；
xtmux3b i894(.xtout(xtout[894])，.a(a[894])，.b(b[894])，.c(c[894])，
.sel(sel))；
xtmux3b i895(.xtout(xtout[895])，.a(a[895])，.b(b[895])，.c(c[895])，
.sel(sel))；
xtmux3b i896(.xtout(xtout[896])，.a(a[896])，.b(b[896])，.c(c[896])，
.sel(sel))；
xtmux3b i897(.xtout(xtout[897])，.a(a[897])，.b(b[897])，.c(c[897])，
.sel(sel))；
xtmux3b i898(.xtout(xtout[898])，.a(a[898])，.b(b[898])，.c(c[898])，
.sel(sel))；
xtmux3b i899(.xtout(xtout[899])，.a(a[899])，.b(b[899])，.c(c[899])，
.sel(sel))；
xtmux3b i900(.xtout(xtout[900])，.a(a[900])，.b(b[900])，.c(c[900])，
.sel(sel))；
xtmux3b i901(.xtout(xtout[901])，.a(a[901])，.b(b[901])，.c(c[901])，
.sel(sel))；
xtmux3b i902(.xtout(xtout[902])，.a(a[902])，.b(b[902])，.c(c[902])，
.sel(sel))；
xtmux3b i903(.xtout(xtout[903])，.a(a[903])，.b(b[903])，.c(c[903])，
.sel(sel))；
<dp n="d220"/>
xtmux3b i904(.xtout(xtout[904])，.a(a[904])，.b(b[904])，.c(c[904])，
.sel(sel))；
xtmux3b i905(.xtout(xtout[905])，.a(a[905])，.b(b[905])，.c(c[905])，
.sel(sel))；
xtmux3b i906(.xtout(xtout[906])，.a(a[906])，.b(b[906])，.c(c[906])，
.sel(sel))；
xtmux3b i907(.xtout(xtout[907])，.a(a[907])，.b(b[907])，.c(c[907])，
.sel(sel))；
xtmux3b i908(.xtout(xtout[908])，.a(a[908])，.b(b[908])，.c(c[908])，
.sel(sel))；
xtmux3b i909(.xtout(xtout[909])，.a(a[909])，.b(b[909])，.c(c[909])，
.sel(sel))；
xtmux3b i910(.xtout(xtout[910])，.a(a[910])，.b(b[910])，.c(c[910])，
.sel(sel))；
xtmux3b i911(.xtout(xtout[911])，.a(a[911])，.b(b[911])，.c(c[911])，
.sel(sel))；
xtmux3b i912(.xtout(xtout[912])，.a(a[912])，.b(b[912])，.c(c[912])，
.sel(sel))；
xtmux3b i913(.xtout(xtout[913])，.a(a[913])，.b(b[913])，.c(c[913])，
.sel(sel))；
xtmux3b i914(.xtout(xtout[914])，.a(a[914])，.b(b[914])，.c(c[914])，
.sel(sel))；
xtmux3b i915(.xtout(xtout[915])，.a(a[915])，.b(b[915])，.c(c[915])，
.sel(sel))；
xtmux3b i916(.xtout(xtout[916])，.a(a[916])，.b(b[916])，.c(c[916])，
.sel(sel))；
xtmux3b i917(.xtout(xtout[917])，.a(a[917])，.b(b[917])，.c(c[917])，
.sel(sel))；
xtmux3b i918(.xtout(xtout[918])，.a(a[918])，.b(b[918])，.c(c[918])，
.sel(sel))；
xtmux3b i919(.xtout(xtout[919])，.a(a[919])，.b(b[919])，.c(c[919])，
.sel(sel))；
xtmux3b i920(.xtout(xtout[920])，.a(a[920])，.b(b[920])，.c(c[920])，
.sel(sel))；
xtmux3b i921(.xtout(xtout[921])，.a(a[921])，.b(b[921])，.c(c[921])，
.sel(sel))；
xtmux3b i922(.xtout(xtout[922])，.a(a[922])，.b(b[922])，.c(c[922])，
.sel(sel))；
xtmux3b i923(.xtout(xtout[923])，.a(a[923])，.b(b[923])，.c(c[923])，
.sel(sel))；
xtmux3b i924(.xtout(xtout[924])，.a(a[924])，.b(b[924])，.c(c[924])，
.sel(sel))；
xtmux3b i925(.xtout(xtout[925])，.a(a[925])，.b(b[925])，.c(c[925])，
.sel(sel))；
xtmux3b i926(.xtout(xtout[926])，.a(a[926])，.b(b[926])，.c(c[926])，
.sel(sel))；
xtmux3b i927(.xtout(xtout[927])，.a(a[927])，.b(b[927])，.c(c[927])，
.sel(sel))；
xtmux3b i928(.xtout(xtout[928])，.a(a[928])，.b(b[928])，.c(c[928])，
.sel(sel))；
xtmux3b i929(.xtout(xtout[929])，.a(a[929])，.b(b[929])，.c(c[929])，
.sel(sel))；
xtmux3b i930(.xtout(xtout[930])，.a(a[930])，.b(b[930])，.c(c[930])，
.sel(sel))；
xtmux3b i931(.xtout(xtout[931])，.a(a[931])，.b(b[931])，.c(c[931])，
.sel(sel))；
xtmux3b i932(.xtout(xtout[932])，.a(a[932])，.b(b[932])，.c(c[932])，
.sel(sel))；
xtmux3b i933(.xtout(xtout[933])，.a(a[933])，.b(b[933])，.c(c[933])，
.sel(sel))；
<dp n="d221"/>
xtmux3b i934(.xtout(xtout[934])，.a(a[934])，.b(b[934])，.c(c[934])，
.sel(sel))；
xtmux3b i935(.xtout(xtout[935])，.a(a[935])，.b(b[935])，.c(c[935])，
.sel(sel))；
xtmux3b i936(.xtout(xtout[936])，.a(a[936])，.b(b[936])，.c(c[936])，
.sel(sel))；
xtmux3b i937(.xtout(xtout[937])，.a(a[937])，.b(b[937])，.c(c[937])，
.sel(sel))；
xtmux3b i938(.xtout(xtout[938])，.a(a[938])，.b(b[938])，.c(c[938])，
.sel(sel))；
xtmux3b i939(.xtout(xtout[939])，.a(a[939])，.b(b[939])，.c(c[939])，
.sel(sel))；
xtmux3b i940(.xtout(xtout[940])，.a(a[940])，.b(b[940])，.c(c[940])，
.sel(sel))；
xtmux3b i941(.xtout(xtout[941])，.a(a[941])，.b(b[941])，.c(c[941])，
.sel(sel))；
xtmux3b i942(.xtout(xtout[942])，.a(a[942])，.b(b[942])，.c(c[942])，
.sel(sel))；
xtmux3b i943(.xtout(xtout[943])，.a(a[943])，.b(b[943])，.c(c[943])，
.sel(sel))；
xtmux3b i944(.xtout(xtout[944])，.a(a[944])，.b(b[944])，.c(c[944])，
.sel(sel))；
xtmux3b i945(.xtout(xtout[945])，.a(a[945])，.b(b[945])，.c(c[945])，
.sel(sel))；
xtmux3b i946(.xtout(xtout[946])，.a(a[946])，.b(b[946])，.c(c[946])，
.sel(sel))；
xtmux3b i947(.xtout(xtout[947])，.a(a[947])，.b(b[947])，.c(c[947])，
.sel(sel))；
xtmux3b i948(.xtout(xtout[948])，.a(a[948])，.b(b[948])，.c(c[948])，
.sel(sel))；
xtmux3b i949(.xtout(xtout[949])，.a(a[949])，.b(b[949])，.c(c[949])，
.sel(sel))；
xtmux3b i950(.xtout(xtout[950])，.a(a[950])，.b(b[950])，.c(c[950])，
.sel(sel))；
xtmux3b i951(.xtout(xtout[951])，.a(a[951])，.b(b[951])，.c(c[951])，
.sel(sel))；
xtmux3b i952(.xtout(xtout[952])，.a(a[952])，.b(b[952])，.c(c[952])，
.sel(sel))；
xtmux3b i953(.xtout(xtout[953])，.a(a[953])，.b(b[953])，.c(c[953])，
.sel(sel))；
xtmux3b i954(.xtout(xtout[954])，.a(a[954])，.b(b[954])，.c(c[954])，
.sel(sel))；
xtmux3b i955(.xtout(xtout[955])，.a(a[955])，.b(b[955])，.c(c[955])，
.sel(sel))；
xtmux3b i956(.xtout(xtout[956])，.a(a[956])，.b(b[956])，.c(c[956])，
.sel(sel))；
xtmux3b i957(.xtout(xtout[957])，.a(a[957])，.b(b[957])，.c(c[957])，
.sel(sel))；
xtmux3b i958(.xtout(xtout[958])，.a(a[958])，.b(b[958])，.c(c[958])，
.sel(sel))；
xtmux3b i959(.xtout(xtout[959])，.a(a[959])，.b(b[959])，.c(c[959])，
.sel(sel))；
xtmux3b i960(.xtout(xtout[960])，.a(a[960])，.b(b[960])，.c(c[960])，
.sel(sel))；
xtmux3b i961(.xtout(xtout[961])，.a(a[961])，.b(b[961])，.c(c[961])，
.sel(sel))；
xtmux3b i962(.xtout(xtout[962])，.a(a[962])，.b(b[962])，.c(c[962])，
.sel(sel))；
xtmux3b i963(.xtout(xtout[963])，.a(a[963])，.b(b[963])，.c(c[963])，
.sel(sel))；
<dp n="d222"/>
xtmux3b i964(.xtout(xtout[964])，.a(a[964])，.b(b[964])，.c(c[964])，
.sel(sel)；
xtmux3b i965(.xtout(xtout[965])，.a(a[965])，.b(b[965])，.c(c[965])，
.sel(sel))；
xtmux3b i966(.xtout(xtout[966])，.a(a[966])，.b(b[966])，.c(c[966])，
.sel(sel))；
xtmux3b i967(.xtout(xtout[967])，.a(a[967])，.b(b[967])，.c(c[967])，
.sel(sel))；
xtmux3b i968(.xtout(xtout[968])，.a(a[968])，.b(b[968])，.c(c[968])，
.sel(sel))；
xtmux3b i969(.xtout(xtout[969])，.a(a[969])，.b(b[969])，.c(c[969])，
.sel(sel))；
xtmux3b i970(.xtout(xtout[970])，.a(a[970])，.b(b[970])，.c(c[970])，
.sel(sel))；
xtmux3b i971(.xtout(xtout[971])，.a(a[971])，.b(b[971])，.c(c[971])，
.sel(sel))；
xtmux3b i972(.xtout(xtout[972])，.a(a[972])，.b(b[972])，.c(c[972])，
.sel(sel))；
xtmux3b i973(.xtout(xtout[973])，.a(a[973])，.b(b[973])，.c(c[973])，
.sel(sel))；
xtmux3b i974(.xtout(xtout[974])，.a(a[974])，.b(b[974])，.c(c[974])，
.sel(sel))；
xtmux3b i975(.xtout(xtout[975])，.a(a[975])，.b(b[975])，.c(c[975])，
.sel(sel))；
xtmux3b i976(.xtout(xtout[976])，.a(a[976])，.b(b[976])，.c(c[976])，
.sel(sel))；
xtmux3b i977(.xtout(xtout[977])，.a(a[977])，.b(b[977])，.c(c[977])，
.sel(sel))；
xtmux3b i978(.xtout(xtout[978])，.a(a[978])，.b(b[978])，.c(c[978])，
.sel(sel))；
xtmux3b i979(.xtout(xtout[979])，.a(a[979])，.b(b[979])，.c(c[979])，
.sel(sel))；
xtmux3b i980(.xtout(xtout[980])，.a(a[980])，.b(b[980])，.c(c[980])，
.sel(sel))；
xtmux3b i981(.xtout(xtout[981])，.a(a[981])，.b(b[981])，.c(c[981])，
.sel(sel))；
xtmux3b i982(.xtout(xtout[982])，.a(a[982])，.b(b[982])，.c(c[982])，
.sel(sel))；
xtmux3b i983(.xtout(xtout[983])，.a(a[983])，.b(b[983])，.c(c[983])，
.sel(sel))；
xtmux3b i984(.xtout(xtout[984])，.a(a[984])，.b(b[984])，.c(c[984])，
.sel(sel))；
xtmux3b i985(.xtout(xtout[985])，.a(a[985])，.b(b[985])，.c(c[985])，
.sel(sel))；
xtmux3b i986(.xtout(xtout[986])，.a(a[986])，.b(b[986])，.c(c[986])，
.sel(sel))；
xtmux3b i987(.xtout(xtout[987])，.a(a[987])，.b(b[987])，.c(c[987])，
.sel(sel))；
xtmux3b i988(.xtout(xtout[988])，.a(a[988])，.b(b[988])，.c(c[988])，
.sel(sel))；
xtmux3b i989(.xtout(xtout[989])，.a(a[989])，.b(b[989])，.c(c[989])，
.sel(sel))；
xtmux3b i990(.xtout(xtout[990])，.a(a[990])，.b(b[990])，.c(c[990])，
.sel(sel))；
xtmux3b i991(.xtout(xtout[991])，.a(a[991])，.b(b[991])，.c(c[991])，
.sel(sel))；
xtmux3b i992(.xtout(xtout[992])，.a(a[992])，.b(b[992])，.c(c[992])，
.sel(sel))；
xtmux3b i993(.xtout(xtout[993])，.a(a[993])，.b(b[993])，.c(c[993])，
.sel(sel))；
<dp n="d223"/>
xtmux3b i994(.xtout(xtout[994])，.a(a[994])，.b(b[994])，.c(c[994])，
.sel(sel))；
xtmux3b i995(.xtout(xtout[995])，.a(a[995])，.b(b[995])，.c(c[995])，
.sel(sel))；
xtmux3b i996(.xtout(xtout[996])，.a(a[996])，.b(b[996])，.c(c[996])，
.sel(sel))；
xtmux3b i997(.xtout(xtout[997])，.a(a[997])，.b(b[997])，.c(c[997])，
.sel(sel))；
xtmux3b i998(.xtout(xtout[998])，.a(a[998])，.b(b[998])，.c(c[998])，
.sel(sel))；
xtmux3b i999(.xtout(xtout[999])，.a(a[999])，.b(b[999])，.c(c[999])，
.sel(sel))；
xtmux3b i1000(.xtout(xtout[1000])，.a(a[1000])，.b(b[1000])，
.c(c[1000])，.sel(sel))；
xtmux3b i1001(.xtout(xtout[1001])，.a(a[1001])，.b(b[1001])，
.c(c[1001])，.sel(sel))；
xtmux3b i1002(.xtout(xtout[1002])，.a(a[1002])，.b(b[1002])，
.c(c[1002])，.sel(sel))；
xtmux3b i1003(.xtout(xtout[1003])，.a(a[1003])，.b(b[1003])，
.c(c[1003])，.sel(sel))；
xtmux3b i1004(.xtout(xtout[1004])，.a(a[1004])，.b(b[1004])，
.c(c[1004])，.sel(sel))；
xtmux3b i1005(.xtout(xtout[1005])，.a(a[1005])，.b(b[1005])，
.c(c[1005])，.sel(sel))；
xtmux3b i1006(.xtout(xtout[1006])，.a(a[1006])，.b(b[1006])，
.c(c[1006])，.sel(sel))；
xtmux3b i1007(.xtout(xtout[1007])，.a(a[1007])，.b(b[1007])，
.c(c[1007])，.sel(sel))；
xtmux3b i1008(.xtout(xtout[1008])，.a(a[1008])，.b(b[1008])，
.c(c[1008])，.sel(sel))；
xtmux3b i1009(.xtout(xtout[1009])，.a(a[1009])，.b(b[1009])，
.c(c[1009])，.sel(sel))；
xtmux3b i1010(.xtout(xtout[1010])，.a(a[1010])，.b(b[1010])，
.c(c[1010])，.sel(sel))；
xtmux3b i1011(.xtout(xtout[1011])，.a(a[1011])，.b(b[1011])，
.c(c[1011])，.sel(sel))；
xtmux3b i1012(.xtout(xtout[1012])，.a(a[1012])，.b(b[1012])，
.c(c[1012])，.sel(sel))；
xtmux3b i1013(.xtout(xtout[1013])，.a(a[1013])，.b(b[1013])，
.c(c[1013])，.sel(sel))；
xtmux3b i1014(.xtout(xtout[1014])，.a(a[1014])，.b(b[1014])，
.c(c[1014])，.sel(sel))；
xtmux3b i1015(.xtout(xtout[1015])，.a(a[1015])，.b(b[1015])，
.c(c[1015])，.sel(sel))；
xtmux3b i1016(.xtout(xtout[1016])，.a(a[1016])，.b(b[1016])，
.c(c[1016])，.sel(sel))；
xtmux3b i1017(.xtout(xtout[1017])，.a(a[1017])，.b(b[1017])，
.c(c[1017])，.sel(sel))；
xtmux3b i1018(.xtout(xtout[1018])，.a(a[1018])，.b(b[1018])，
.c(c[1018])，.sel(sel))；
xtmux3b i1019(.xtout(xtout[1019])，.a(a[1019])，.b(b[1019])，
.c(c[1019])，.sel(sel))；
xtmux3b i1020(.xtout(xtout[1020])，.a(a[1020])，.b(b[1020])，
.c(c[1020])，.sel(sel))；
xtmux3b i1021(.xtout(xtout[1021])，.a(a[1021])，.b(b[1021])，
.c(c[1021])，.sel(sel))；
xtmux3b i1022(.xtout(xtout[1022])，.a(a[1022])，.b(b[1022])，
.c(c[1022])，.sel(sel))；
xtmux3b i1023(.xtout(xtout[1023])，.a(a[1023])，.b(b[1023])，
.c(c[1023])，.sel(sel))；
<dp n="d224"/>
endmodule
module xtmux4e_1024(xtout，a，b，c，d，sel)；
output [1023：0] xtout；
input [1023：0] a，b，c，d；
input [1：0] sel；
xtmux4b i0(.xtout(xtout[0])，.a(a[0])，.b(b[0])，.c(c 0])，.d(d[0])，
.sel(sel))；
xtmux4b i1(.xtout(xtout[1])，.a(a[1])，.b(b[1])，.c(c[1])，.d(d[1])，
.sel(sel))；
xtmux4b i2(.xtout(xtout[2])，.a(a[2])，.b(b[2])，.c(c[2])，.d(d[2])，
.sel(sel))；
xtmux4b i3(.xtout(xtout[3])，.a(a[3])，.b(b[3])，.c(c[3])，.d(d[3])，
.sel(sel))；
xtmux4b i4(.xtout(xtout[4])，.a(a[4])，.b(b[4])，.c(c[4])，.d(d[4])，
.sel(sel))；
xtmux4b i5(.xtout(xtout[5])，.a(a[5])，.b(b[5])，.c(c[5])，.d(d[5])，
.sel(sel))；
xtmux4b i6(.xtout(xtout[6])，.a(a[6])，.b(b[6])，.c(c[6])，.d(d[6])，
.sel(sel))；
xtmux4b i7(.xtout(xtout[7])，.a(a[7])，.b(b[7])，.c(c[7])，.d(d[7])，
.sel(sel))；
xtmux4b i8(.xtout(xtout[8])，.a(a[8])，.b(b[8])，.c(c[8])，.d(d[8])，
.sel(sel))；
xtmux4b i9(.xtout(xtout[9])，.a(a[9])，.b(b[9])，.c(c[9])，.d(d[9])，
.sel(sel))；
xtmux4b i10(.xtout(xtout[10])，.a(a[10])，.b(b[10])，.c(c[10])，
.d(d[10])，.sel(sel))；
xtmux4b i11(.xtout(xtout[11])，.a(a[11])，.b(b[11])，.c(c[11])，
.d(d[11])，.sel(sel))；
xtmux4b i12(.xtout(xtout[12])，.a(a[12])，.b(b[12])，.c(c[12])，
.d(d[12])，.sel(sel))；
xtmux4b i13(.xtout(xtout[13])，.a(a[13])，.b(b[13])，.c(c[13])，
.d(d[13])，.sel(sel))；
xtmux4b i14(.xtout(xtout[14])，.a(a[14])，.b(b[14])，.c(c[14])，
.d(d[14])，.sel(sel))；
xtmux4b i15(.xtout(xtout[15])，.a(a[15])，.b(b[15])，.c(c[15])，
.d(d[15])，.sel(sel))；
xtmux4b i16(.xtout(xtout[16])，.a(a[16])，.b(b[16])，.c(c[16])，
.d(d[16])，.sel(sel))；
xtmux4b i17(.xtout(xtout[17])，.a(a[17])，.b(b[17])，.c(c[17])，
.d(d[17])，.sel(sel))；
xtmux4b i18(.xtout(xtout[18])，.a(a[18])，.b(b[18])，.c(c[18])，
.d(d[18])，.sel(sel))；
xtmux4b i19(.xtout(xtout[19])，.a(a[19])，.b(b[19])，.c(c[19])，
.d(d[19])，.sel(sel))；
xtmux4b i20(.xtout(xtout[20])，.a(a[20])，.b(b[20])，.c(c[20])，
.d(d[20])，.sel(sel))；
xtmux4b i21(.xtout(xtout[21])，.a(a[21])，.b(b[21])，.c(c[21])，
.d(d[21])，.sel(sel))；
xtmux4b i22(.xtout(xtout[22])，.a(a[22])，.b(b[22])，.c(c[22])，
.d(d[22])，.sel(sel))；
xtmux4b i23(.xtout(xtout[23])，.a(a[23])，.b(b[23])，.c(c[23])，
.d(d[23])，.sel(sel))；
xtmux4b i24(.xtout(xtout[24])，.a(a[24])，.b(b[24])，.c(c[24])，
.d(d[24])，.sel(sel))；
xtmux4b i25(.xtout(xtout[25])，.a(a[25])，.b(b[25])，.c(c[25])，
.d(d[25])，.sel(sel))；
xtmux4b i26(.xtout(xtout[26])，.a(a[26])，.b(b[26])，.c(c[26])，
.d(d[26])，.sel(sel))；
<dp n="d225"/>
xtmux4b i27(.xtout(xtout[27])，.a(a[27])，.b(b[27])，.c(c[27])，
.d(d[27])，.sel(sel))；
xtmux4b i28(.xtout(xtout[28])，.a(a[28])，.b(b[28])，.c(c[28])，
.d(d[28])，.sel(sel))；
xtmux4b i29(.xtout(xtout[29])，.a(a[29])，.b(b[29])，.c(c[29])，
.d(d[29])，.sel(sel))；
xtmux4b i30(.xtout(xtout[30])，.a(a[30])，.b(b[30])，.c(c[30])，
.d(d[30])，.sel(sel))；
xtmux4b i31(.xtout(xtout[31])，.a(a[31])，.b(b[31])，.c(c[31])，
.d(d[31])，.sel(sel))；
xtmux4b i32(.xtout(xtout[32])，.a(a[32])，.b(b[32])，.c(c[32])，
.d(d[32])，.sel(sel))；
xtmux4b i33(.xtout(xtout[33])，.a(a[33])，.b(b[33])，.c(c[33])，
.d(d[33])，.sel(sel))；
xtmux4b i34(.xtout(xtout[34])，.a(a[34])，.b(b[34])，.c(c[34])，
.d(d[34])，.sel(sel))；
xtmux4b i35(.xtout(xtout[35])，.a(a[35])，.b(b[35])，.c(c[35])，
.d(d[35])，.sel(sel))；
xtmux4b i36(.xtout(xtout[36])，.a(a[36])，.b(b[36])，.c(c[36])，
.d(d[36])，.sel(sel))；
xtmux4b i37(.xtout(xtout[37])，.a(a[37])，.b(b[37])，.c(c[37])，
.d(d[37])，.sel(sel))；
xtmux4b i38(.xtout(xtout[38])，.a(a[38])，.b(b[38])，.c(c[38])，
.d(d[38])，.sel(sel))；
xtmux4b i39(.xtout(xtout[39])，.a(a[39])，.b(b[39])，.c(c[39])，
.d(d[39])，.sel(sel))；
xtmux4b i40(.xtout(xtout[40])，.a(a[40])，.b(b[40])，.c(c[40])，
.d(d[40])，.sel(sel))；
xtmux4b i41(.xtout(xtout[41])，.a(a[41])，.b(b[41])，.c(c[41])，
.d(d[41])，.sel(sel))；
xtmux4b i42(.xtout(xtout[42])，.a(a[42])，.b(b[42])，.c(c[42])，
.d(d[42])，.sel(sel))；
xtmux4b i43(.xtout(xtout[43])，.a(a[43])，.b(b[43])，.c(c[43])，
.d(d[43])，.sel(sel))；
xtmux4b i44(.xtout(xtout[44])，.a(a[44])，.b(b[44])，.c(c[44])，
.d(d[44])，.sel(sel))；
xtmux4b i45(.xtout(xtout[45])，.a(a[45])，.b(b[45])，.c(c[45])，
.d(d[45])，.sel(sel))；
xtmux4b i46(.xtout(xtout[46])，.a(a[46])，.b(b[46])，.c(c[46])，
.d(d[46])，.sel(sel))；
xtmux4b i47(.xtout(xtout[47])，.a(a[47])，.b(b[47])，.c(c[47])，
.d(d[47])，.sel(sel))；
xtmux4b i48(.xtout(xtout[48])，.a(a[48])，.b(b[48])，.c(c[48])，
.d(d[48])，.sel(sel))；
xtmux4b i49(.xtout(xtout[49])，.a(a[49])，.b(b[49])，.c(c[49])，
.d(d[49])，.sel(sel))；
xtmux4b i50(.xtout(xtout[50])，.a(a[50])，.b(b[50])，.c(c[50])，
.d(d[50])，.sel(sel))；
xtmux4b i51(.xtout(xtout[51])，.a(a[51])，.b(b[51])，.c(c[51])，
.d(d[51])，.sel(sel))；
xtmux4b i52(.xtout(xtout[52])，.a(a[52])，.b(b[52])，.c(c[52])，
.d(d[52])，.sel(sel))；
xtmux4b i53(.xtout(xtout[53])，.a(a[53])，.b(b[53])，.c(c[53])，
.d(d[53])，.sel(sel))；
xtmux4b i54(.xtout(xtout[54])，.a(a[54])，.b(b[54])，.c(c[54])，
.d(d[54])，.sel(sel))；
xtmux4b i55(.xtout(xtout[55])，.a(a[55])，.b(b[55])，.c(c[55])，
.d(d[55])，.sel(sel))；
xtmux4b i56(.xtout(xtout[56])，.a(a[56])，.b(b[56])，.c(c[56])，
.d(d[56])，.sel(sel))；
<dp n="d226"/>
xtmux4b i57(.xtout(xtout[57])，.a(a[57])，.b(b[57])，.c(c[57])，
.d(d[57])，.sel(sel))；
xtmux4b i58(.xtout(xtout[58])，.a(a[58])，.b(b[58])，.c(c[58])，
.d(d[58])，.sel(sel))；
xtmux4b i59(.xtout(xtout[59])，.a(a[59])，.b(b[59])，.c(c[59])，
.d(d[59])，.sel(sel))；
xtmux4b i60(.xtout(xtout[60])，.a(a[60])，.b(b[60])，.c(c[60])，
.d(d[60])，.sel(sel))；
xtmux4b i61(.xtout(xtout[61])，.a(a[61])，.b(b[61])，.c(c[61])，
.d(d[61])，.sel(sel))；
xtmux4b i62(.xtout(xtout[62])，.a(a[62])，.b(b[62])，.c(c[62])，
.d(d[62])，.sel(sel))；
xtmux4b i63(.xtout(xtout[63])，.a(a[63])，.b(b[63])，.c(c[63])，
.d(d[63])，.sel(sel))；
xtmux4b i64(.xtout(xtout[64])，.a(a[64])，.b(b[64])，.c(c[64])，
.d(d[64])，.sel(sel))；
xtmux4b i65(.xtout(xtout[65])，.a(a[65])，.b(b[65])，.c(c[65])，
.d(d[65])，.sel(sel))；
xtmux4b i66(.xtout(xtout[66])，.a(a[66])，.b(b[66])，.c(c[66])，
.d(d[66])，.sel(sel))；
xtmux4b i67(.xtout(xtout[67])，.a(a[67])，.b(b[67])，.c(c[67])，
.d(d[67])，.sel(sel))；
xtmux4b i68(.xtout(xtout[68])，.a(a[68])，.b(b[68])，.c(c[68])，
.d(d[68])，.sel(sel))；
xtmux4b i69(.xtout(xtout[69])，.a(a[69])，.b(b[69])，.c(c[69])，
.d(d[69])，.sel(sel))；
xtmux4b i70(.xtout(xtout[70])，.a(a[70])，.b(b[70])，.c(c[70])，
.d(d[70])，.sel(sel))；
xtmux4b i71(.xtout(xtout[71])，.a(a[71])，.b(b[71])，.c(c[71])，
.d(d[71])，.sel(sel))；
xtmux4b i72(.xtout(xtout[72])，.a(a[72])，.b(b[72])，.c(c[72])，
.d(d[72])，.sel(sel))；
xtmux4b i73(.xtout(xtout[73])，.a(a[73])，.b(b[73])，.c(c[73])，
.d(d[73])，.sel(sel))；
xtmux4b i74(.xtout(xtout[74])，.a(a[74])，.b(b[74])，.c(c[74])，
.d(d[74])，.sel(sel))；
xtmux4b i75(.xtout(xtout[75])，.a(a[75])，.b(b[75])，.c(c[75])，
.d(d[75])，.sel(sel))；
xtmux4b i76(.xtout(xtout[76])，.a(a[76])，.b(b[76])，.c(c[76])，
.d(d[76])，.sel(sel))；
xtmux4b i77(.xtout(xtout[77])，.a(a[77])，.b(b[77])，.c(c[77])，
.d(d[77])，.sel(sel))；
xtmux4b i78(.xtout(xtout[78])，.a(a[78])，.b(b[78])，.c(c[78])，
.d(d[78])，.sel(sel))；
xtmux4b i79(.xtout(xtout[79])，.a(a[79])，.b(b[79])，.c(c[79])，
.d(d[79])，.sel(sel))；
xtmux4b i80(.xtout(xtout[80])，.a(a[80])，.b(b[80])，.c(c[80])，
.d(d[80])，.sel(sel))；
xtmux4b i81(.xtout(xtout[81])，.a(a[81])，.b(b[81])，.c(c[81])，
.d(d[81])，.sel(sel))；
xtmux4b i82(.xtout(xtout[82])，.a(a[82])，.b(b[82])，.c(c[82])，
.d(d[82])，.sel(sel))；
xtmux4b i83(.xtout(xtout[83])，.a(a[83])，.b(b[83])，.c(c[83])，
.d(d[83])，.sel(sel))；
xtmux4b i84(.xtout(xtout[84])，.a(a[84])，.b(b[84])，.c(c[84])，
.d(d[84])，.sel(sel))；
xtmux4b i85(.xtout(xtout[85])，.a(a[85])，.b(b[85])，.c(c[85])，
.d(d[85])，.sel(sel))；
xtmux4b i86(.xtout(xtout[86])，.a(a[86])，.b(b[86])，.c(c[86])，
.d(d[86])，.sel(sel))；
<dp n="d227"/>
xtmux4b i87(.xtout(xtout[87])，.a(a[87])，.b(b[87])，.c(c[87])，
.d(d[87])，sel(sel))；
xtmux4b i88(.xtout(xtout[88])，.a(a[88])，.b(b[88])，.c(c[88])，
.d(d[88])，sel(sel))；
xtmux4b i89(.xtout(xtout[89])，.a(a[89])，.b(b[89])，.c(c[89])，
.d(d[89])，sel(sel))；
xtmux4b i90(.xtout(xtout[90])，.a(a[90])，.b(b[90])，.c(c[90])，
.d(d[90])，sel(sel))；
xtmux4b i91(.xtout(xtout[91])，.a(a[91])，.b(b[91])，.c(c[91])，
.d(d[91])，sel(sel))；
xtmux4b i92(.xtout(xtout[92])，.a(a[92])，.b(b[92])，.c(c[92])，
.d(d[92])，sel(sel))；
xtmux4b i93(.xtout(xtout[93])，.a(a[93])，.b(b[93])，.c(c[93])，
.d(d[93])，sel(sel))；
xtmux4b i94(.xtout(xtout[94])，.a(a[94])，.b(b[94])，.c(c[94])，
.d(d[94])，sel(sel))；
xtmux4b i95(.xtout(xtout[95])，.a(a[95])，.b(b[95])，.c(c[95])，
.d(d[95])，sel(sel))；
xtmux4b i96(.xtout(xtout[96])，.a(a[96])，.b(b[96])，.c(c[96])，
.d(d[96])，sel(sel))；
xtmux4b i97(.xtout(xtout[97])，.a(a[97])，.b(b[97])，.c(c[97])，
.d(d[97])，sel(sel))；
xtmux4b i98(.xtout(xtout[98])，.a(a[98])，.b(b[98])，.c(c[98])，
.d(d[98])，.sel(sel))；
xtmux4b i99(.xtout(xtout[99])，.a(a[99])，.b(b[99])，.c(c[99])，
.d(d[99])，.sel(sel))；
xtmux4b i100(.xtout(xtout[100])，.a(a[100])，.b(b[100])，.c(c[100])，
.d(d[100])，.sel(sel))；
xtmux4b i101(.xtout(xtout[101])，.a(a[101])，.b(b[101])，.c(c[101])，
.d(d[101])，.sel(sel))；
xtmux4b i102(.xtout(xtout[102])，.a(a[102])，.b(b[102])，.c(c[102])，
.d(d[102])，.sel(sel))；
xtmux4b i103(.xtout(xtout[103])，.a(a[103])，.b(b[103])，.c(c[103])，
.d(d[103])，.sel(sel))；
xtmux4b i104(.xtout(xtout[104])，.a(a[104])，.b(b[104])，.c(c[104])，
.d(d[104])，.sel(sel))；
xtmux4b i105(.xtout(xtout[105])，.a(a[105])，.b(b[105])，.c(c[105])，
.d(d[105])，.sel(sel))；
xtmux4b i106(.xtout(xtout[106])，.a(a[106])，.b(b[106])，.c(c[106])，
.d(d[106])，.sel(sel))；
xtmux4b i107(.xtout(xtout[107])，.a(a[107])，.b(b[107])，.c(c[107])，
.d(d[107])，.sel(sel))；
xtmux4b i108(.xtout(xtout[108])，.a(a[108])，.b(b[108])，.c(c[108])，
.d(d[108])，.sel(sel))；
xtmux4b i109(.xtout(xtout[109])，.a(a[109])，.b(b[109])，.c(c[109])，
.d(d[109])，.sel(sel))；
xtmux4b i110(.xtout(xtout[110])，.a(a[110])，.b(b[110])，.c(c[110])，
.d(d[110])，.sel(sel))；
xtmux4b i111(.xtout(xtout[111])，.a(a[111])，.b(b[111])，.c(c[111])，
.d(d[111])，.sel(sel))；
xtmux4b i112(.xtout(xtout[112])，.a(a[112])，.b(b[112])，.c(c[112])，
.d(d[112])，.el(sel))；
xtmux4b i113(.xtout(xtout[113])，.a(a[113])，.b(b[113])，.c(c[113])，
.d(d[113])，.sel(sel))；
xtmux4b i114(.xtout(xtout[114])，.a(a[114])，.b(b[114])，.c(c[114])，
.d(d[114])，.sel(sel))；
xtmux4b i115(.xtout(xtout[115])，.a(a[115])，.b(b[115])，.c(c[115])，
.d(d[115])，.sel(sel))；
xtmux4b i116(.xtout(xtout[116])，.a(a[116])，.b(b[116])，.c(c[116])，
.d(d[116])，.sel(sel))；
<dp n="d228"/>
xtmux4b i117(.xtout(xtout[117])，.a(a[117])，.b(b[117])，.c(c[117])，
.d(d[117])，.sel(sel))；
xtmux4b i118(.xtout(xtout[118])，.a(a[118])，.b(b[118])，.c(c[118])，
.d(d[118])，.sel(sel))；
xtmux4b i119(.xtout(xtout[119])，.a(a[119])，.b(b[119])，.c(c[119])，
.d(d[119])， .sel(sel))；
xtmux4b i120(.xtout(xtout[120])，.a(a[120])，.b(b[120])，.c(c[120])，
.d(d[120])，.sel(sel))；
xtmux4b i121(.xtout(xtout[121])，.a(a[121])，.b(b[121])，.c(c[121])，
.d(d[121])，.sel(sel))；
xtmux4b i122(.xtout(xtout[122])，.a(a[122])，.b(b[122])，.c(c[122])，
.d(d[122])，.sel(sel))；
xtmux4b i123(.xtout(xtout[123])，.a(a[123])，.b(b[123])，.c(c[123])，
.d(d[123])，.sel(sel))；
xtmux4b i124(.xtout(xtout[124])，.a(a[124])，.b(b[124])，.c(c[124])，
.d(d[124])，.sel(sel))；
xtmux4b i125(.xtout(xtout[125])，.a(a[125])，.b(b[125])，.c(c[125])，
.d(d[125])，.sel(sel) )；
xtmux4b i126(.xtout(xtout[126])，.a(a[126])，.b(b[126])，.c(c[126])，
.d(d[126])，.sel(sel))；
xtmux4b i127(.xtout(xtout[127])，.a(a[127])，.b(b[127])，.c(c[127])，
.d(d[127])，.sel(sel))；
xtmux4b i128(.xtout(xtout[128])，.a(a[128])，.b(b[128])，.c(c[128])，
.d(d[128])，.sel(sel))；
xtmux4b i129(.xtout(xtout[129])，.a(a[129])，.b(b[129])，.c(c[129])，
.d(d[129])，.sel(sel))；
xtmux4b i130(.xtout(xtout[130])，.a(a[130])，.b(b[130])，.c(c[130])，
.d(d[130])，.sel(sel))；
xtmux4b i131(.xtout(xtout[131])，.a(a[131])，.b(b[131])，.c(c[131])，
.d(d[131])，.sel(sel))；
xtmux4b i132(.xtout(xtout[132])，.a(a[132])，.b(b[132])，.c(c[132])，
.d(d[132])，.sel(sel))；
xtmux4b i133(.xtout(xtout[133])，.a(a[133])，.b(b[133])，.c(c[133])，
.d(d[133])，.sel(sel))；
xtmux4b i134(.xtout(xtout[134])，.a(a[134])，.b(b[134])，.c(c[134])，
.d(d[134])，.sel(sel))；
xtmux4b i135(.xtout(xtout[135])，.a(a[135])，.b(b[135])，.c(c[135])，
.d(d[135])，.sel(sel))；
xtmux4b i136(.xtout(xtout[136])，.a(a[136])，.b(b[136])，.c(c[136])，
.d(d[136])，.sel(sel))；
xtmux4b i137(.xtout(xtout[137])，.a(a[137])，.b(b[137])，.c(c[137])，
.d(d[137])，.sel(sel))；
xtmux4b i138(.xtout(xtout[138])，.a(a[138])，.b(b[138])，.c(c[138])，
.d(d[138])，.sel(sel))；
xtmux4b i139(.xtout(xtout[139])，.a(a[139])，.b(b[139])，.c(c[139])，
.d(d[139])，.sel(sel))；
xtmux4b i140(.xtout(xtout[140])，.a(a[140])，.b(b[140])，.c(c[140])，
.d(d[140])，.sel(sel))；
xtmux4b i141(.xtout(xtout[141])，.a(a[141])，.b(b[141])，.c(c[141])，
.d(d[141])，.sel(sel))；
xtmux4b i142(.xtout(xtout[142])，.a(a[142])，.b(b[142])，.c(c[142])，
.d(d[142])，.sel(sel))；
xtmux4b i143(.xtout(xtout[143])，.a(a[143])，.b(b[143])，.c(c[143])，
.d(d[143])，.sel(sel))；
xtmux4b i144(.xtout(xtout[144])，.a(a[144])，.b(b[144])，.c(c[144])，
.d(d[144])， .sel(sel))；
xtmux4b i145(.xtout(xtout[145])，.a(a[145])，.b(b[145])，.c(c[145])，
.d(d[145])，.sel(sel))；
xtmux4b i146(.xtout(xtout[146])，.a(a[146])，.b(b[146])，.c(c[146])，
.d(d[146])，.sel(sel))；
<dp n="d229"/>
xtmux4b i147(.xtout(xtout[147])，.a(a[147])，.b(b[147])，.c(c[147])，
.d(d[147])，.sel(sel))；
xtmux4b i148(.xtout(xtout[148])，.a(a[148])，.b(b[148])，.c(c[148])，
.d(d[148])，.sel(sel))；
xtmux4b i149(.xtout(xtout[149])，.a(a[149])，.b(b[149])，.c(c[149])，
.d(d[149])，.sel(sel))；
xtmux4b i150(.xtout(xtout[150])，.a(a[150])，.b(b[150])，.c(c[150])，
.d(d[150])，.sel(sel))；
xtmux4b i151(.xtout(xtout[151])，.a(a[151])，.b(b[151])，.c(c[151])，
.d(d[151])，.sel(sel))；
xtmux4b i152(.xtout(xtout[152])，.a(a[152])，.b(b[152])，.c(c[152])，
.d(d[152])，.sel(sel))；
xtmux4b i153(.xtout(xtout[153])，.a(a[153])，.b(b[153])，.c(c[153])，
.d(d[153])，.sel(sel))；
xtmux4b i154(.xtout(xtout[154])，.a(a[154])，.b(b[154])，.c(c[154])，
.d(d[154])，.sel(sel))；
xtmux4b i155(.xtout(xtout[155])，.a(a[155])，.b(b[155])，.c(c[155])，
.d(d[155])，.sel(sel))；
xtmux4b i156(.xtout(xtout[156])，.a(a[156])，.b(b[156])，.c(c[156])，
.d(d[156])，.sel(sel))；
xtmux4b i157(.xtout(xtout[157])，.a(a[157])，.b(b[157])，.c(c[157])，
.d(d[157])，.sel(sel))；
xtmux4b i158(.xtout(xtout[158])，.a(a[158])，.b(b[158])，.c(c[158])，
.d(d[158])，.sel(sel))；
xtmux4b i159(.xtout(xtout[159])，.a(a[159])，.b(b[159])，.c(c[159])，
.d(d[159])，.sel(sel))；
xtmux4b i160(.xtout(xtout[160])，.a(a[160])，.b(b[160])，.c(c[160])，
.d(d[160])，.sel(sel))；
xtmux4b i161(.xtout(xtout[161])，.a(a[161])，.b(b[161])，.c(c[161])，
.d(d[161])，.sel(sel))；
xtmux4b i162(.xtout(xtout[162])，.a(a[162])，.b(b[162])，.c(c[162])，
.d(d[162])，.sel(sel))；
xtmux4b i163(.xtout(xtout[163])，.a(a[163])，.b(b[163])，.c(c[163])，
.d(d[163])，.sel(sel))；
xtmux4b i164(.xtout(xtout[164])，.a(a[164])，.b(b[164])，.c(c[164])，
.d(d[164])，.sel(sel))；
xtmux4b i165(.xtout(xtout[165])，.a(a[165])，.b(b[165])，.c(c[165])，
.d(d[165])，.sel(sel))；
xtmux4b i166(.xtout(xtout[166])，.a(a[166])，.b(b[166])，.c(c[166])，
.d(d[166])，.sel(sel))；
xtmux4b i167(.xtout(xtout[167])，.a(a[167])，.b(b[167])，.c(c[167])，
.d(d[167])，.sel(sel))；
xtmux4b i168(.xtout(xtout[168])，.a(a[168])，.b(b[168])，.c(c[168])，
.d(d[168])，.sel(sel))；
xtmux4b i169(.xtout(xtout[169])，.a(a[169])，.b(b[169])，.c(c[169])，
.d(d[169])，.sel(sel))；
xtmux4b i170(.xtout(xtout[170])，.a(a[170])，.b(b[170])，.c(c[170])，
.d(d[170])，.sel(sel))；
xtmux4b i171(.xtout(xtout[171])，.a(a[171])，.b(b[171])，.c(c[171])，
.d(d[171])，.sel(sel))；
xtmux4b i172(.xtout(xtout[172])，.a(a[172])，.b(b[172])，.c(c[172])，
.d(d[172])，.sel(sel))；
xtmux4b i173(.xtout(xtout[173])，.a(a[173])，.b(b[173])，.c(c[173])，
.d(d[173])，.sel(sel))；
xtmux4b i174(.xtout(xtout[174])，.a(a[174])，.b(b[174])，.c(c[174])，
.d(d[174])，.sel(sel))；
xtmux4b i175(.xtout(xtout[175])，.a(a[175])，.b(b[175])，.c(c[175])，
.d(d[175])，.sel(sel))；
xtmux4b i176(.xtout(xtout[176])，.a(a[176])，.b(b[176])，.c(c[176])，
.d(d[176])，.sel(sel))；
<dp n="d230"/>
xtmux4b i177(.xtout(xtout[177])，.a(a[177])，.b(b[177])，.c(c[177])，
.d(d[177])，.sel(sel))；
xtmux4b i178(.xtout(xtout[178])，.a(a[178])，.b(b[178])，.c(c[178])，
.d(d[178])，.sel(sel))；
xtmux4b i179(.xtout(xtout[179])，.a(a[179])，.b(b[179])，.c(c[179])，
.d(d[179])，.sel(sel))；
xtmux4b i180(.xtout(xtout[180])，.a(a[180])，.b(b[180])，.c(c[180])，
.d(d[180])，.sel(sel))；
xtmux4b i181(.xtout(xtout[181])，.a(a[181])，.b(b[181])，.c(c[181])，
.d(d[181])，.sel(sel))；
xtmux4b i182(.xtout(xtout[182])，.a(a[182])，.b(b[182])，.c(c[182])，
.d(d[182])，.sel(sel))；
xtmux4b i183(.xtout(xtout[183])，.a(a[183])，.b(b[183])，.c(c[183])，
.d(d[183])，.sel(sel))；
xtmux4b i184(.xtout(xtout[184])，.a(a[184])，.b(b[184])，.c(c[184])，
.d(d[184])，.sel(sel))；
xtmux4b i185(.xtout(xtout[185])，.a(a[185])，.b(b[185])，.c(c[185])，
.d(d[185])，.sel(sel))；
xtmux4b i186(.xtout(xtout[186])，.a(a[186])，.b(b[186])，.c(c[186])，
.d(d[186])，.sel(sel))；
xtmux4b i187(.xtout(xtout[187])，.a(a[187])，.b(b[187])，.c(c[187])，
.d(d[187])，.sel(sel))；
xtmux4b i188(.xtout(xtout[188])，.a(a[188])，.b(b[188])，.c(c[188])，
.d(d[188])，.sel(sel))；
xtmux4b i189(.xtout(xtout[189])，.a(a[189])，.b(b[189])，.c(c[189])，
.d(d[189])，.sel(sel))；
xtmux4b i190(.xtout(xtout[190])，.a(a[190])，.b(b[190])，.c(c[190])，
.d(d[190])，.sel(sel))；
xtmux4b i191(.xtout(xtout[191])，.a(a[191])，.b(b[191])，.c(c[191])，
.d(d[191])，.sel(sel))；
xtmux4b i192(.xtout(xtout[192])，.a(a[192])，.b(b[192])，.c(c[192])，
.d(d[192])，.sel(sel))；
xtmux4b i193(.xtout(xtout[193])，.a(a[193])，.b(b[193])，.c(c[193])，
.d(d[193])，.sel(sel))；
xtmux4b i194(.xtout(xtout[194])，.a(a[194])，.b(b[194])，.c(c[194])，
.d(d[194])，.sel(sel))；
xtmux4b i195(.xtout(xtout[195])，.a(a[195])，.b(b[195])，.c(c[195])，
.d(d[195])，.sel(sel))；
xtmux4b i196(.xtout(xtout[196])，.a(a[196])，.b(b[196])，.c(c[196])，
.d(d[196])，.sel(sel))；
xtmux4b i197(.xtout(xtout[197])，.a(a[197])，.b(b[197])，.c(c[197])，
.d(d[197])，.sel(sel))；
xtmux4b i198(.xtout(xtout[198])，.a(a[198])，.b(b[198])，.c(c[198])，
.d(d[198])，.sel(sel))；
xtmux4b i199(.xtout(xtout[199])，.a(a[199])，.b(b[199])，.c(c[199])，
.d(d[199])，.sel(sel))；
xtmux4b i200(.xtout(xtout[200])，.a(a[200])，.b(b[200])，.c(c[200])，
.d(d[200])，.sel(sel))；
xtmux4b i201(.xtout(xtout[201])，.a(a[201])，.b(b[201])，.c(c[201])，
.d(d[201])，.sel(sel))；
xtmux4b i202(.xtout(xtout[202])，.a(a[202])，.b(b[202])，.c(c[202])，
.d(d[202])，.sel(sel))；
xtmux4b i203(.xtout(xtout[203])，.a(a[203])，.b(b[203])，.c(c[203])，
.d(d[203])，.sel(sel))；
xtmux4b i204(.xtout(xtout[204])，.a(a[204])，.b(b[204])，.c(c[204])，
.d(d[204])，.sel(sel))；
xtmux4b i205(.xtout(xtout[205])，.a(a[205])，.b(b[205])，.c(c[205])，
.d(d[205])，.sel(sel))；
xtmux4b i206(.xtout(xtout[206])，.a(a[206])，.b(b[206])，.c(c[206])，
.d(d[206])，.sel(sel))；
<dp n="d231"/>
xtmux4b i207(.xtout(xtout[207])，.a(a[207])，.b(b[207])，.c(c[207])，
.d(d[207])，.sel(sel))；
xtmux4b i208(.xtout(xtout[208])，.a(a[208])，.b(b[208])，.c(c[208])，
.d(d[208])，.sel(sel))；
xtmux4b i209(.xtout(xtout[209])，.a(a[209])，.b(b[209])，.c(c[209])，
.d(d[209])，.sel(sel))；
xtmux4b i210(.xtout(xtout[210])，.a(a[210])，.b(b[210])，.c(c[210])，
.d(d[210])，.sel(sel))；
xtmux4b i211(.xtout(xtout[211])，.a(a[211])，.b(b[211])，.c(c[211])，
.d(d[211])，.sel(sel))；
xtmux4b i212(.xtout(xtout[212])，.a(a[212])，.b(b[212])，.c(c[212])，
.d(d[212])，.sel(sel))；
xtmux4b i213(.xtout(xtout[213])，.a(a[213])，.b(b[213])，.c(c[213])，
.d(d[213])，.sel(sel))；
xtmux4b i214(.xtout(xtout[214])，.a(a[214])，.b(b[214])，.c(c[214])，
.d(d[214])，.sel(sel))；
xtmux4b i215(.xtout(xtout[215])，.a(a[215])，.b(b[215])，.c(c[215])，
.d(d[215])，.sel(sel))；
xtmux4b i216(.xtout(xtout[216])，.a(a[216])，.b(b[216])，.c(c[216])，
.d(d[216])，.sel(sel))；
xtmux4b i217(.xtout(xtout[217])，.a(a[217])，.b(b[217])，.c(c[217])，
.d(d[217])，.sel(sel))；
xtmux4b i218(.xtout(xtout[218])，.a(a[218])，.b(b[218])，.c(c[218])，
.d(d[218])，.sel(sel))；
xtmux4b i219(.xtout(xtout[219])，.a(a[219])，.b(b[219])，.c(c[219])，
.d(d[219])，.sel(sel))；
xtmux4b i220(.xtout(xtout[220])，.a(a[220])，.b(b[220])，.c(c[220])，
.d(d[220])，.sel(sel))；
xtmux4b i221(.xtout(xtout[221])，.a(a[221])，.b(b[221])，.c(c[221])，
.d(d[221])，.sel(sel))；
xtmux4b i222(.xtout(xtout[222])，.a(a[222])，.b(b[222])，.c(c[222])，
.d(d[222])，.sel(sel))；
xtmux4b i223(.xtout(xtout[223])，.a(a[223])，.b(b[223])，.c(c[223])，
.d(d[223])，.sel(sel))；
xtmux4b i224(.xtout(xtout[224])，.a(a[224])，.b(b[224])，.c(c[224])，
.d(d[224])，.sel(sel))；
xtmux4b i225(.xtout(xtout[225])，.a(a[225])，.b(b[225])，.c(c[225])，
.d(d[225])，.sel(sel))；
xtmux4b i226(.xtout(xtout[226])，.a(a[226])，.b(b[226])，.c(c[226])，
.d(d[226])，.sel(sel))；
xtmux4b i227(.xtout(xtout[227])，.a(a[227])，.b(b[227])，.c(c[227])，
.d(d[227])，.sel(sel))；
xtmux4b i228(.xtout(xtout[228])，.a(a[228])，.b(b[228])，.c(c[228])，
.d(d[228])，.sel(sel))；
xtmux4b i229(.xtout(xtout[229])，.a(a[229])，.b(b[229])，.c(c[229])，
.d(d[229])，.sel(sel))；
xtmux4b i230(.xtout(xtout[230])，.a(a[230])，.b(b[230])，.c(c[230])，
.d(d[230])，.sel(sel))；
xtmux4b i231(.xtout(xtout[231])，.a(a[231])，.b(b[231])，.c(c[231])，
.d(d[231])，.sel(sel))；
xtmux4b i232(.xtout(xtout[232])，.a(a[232])，.b(b[232])，.c(c[232])，
.d(d[232])，.sel(sel))；
xtmux4b i233(.xtout(xtout[233])，.a(a[233])，.b(b[233])，.c(c[233])，
.d(d[233])，.sel(sel))；
xtmux4b i234(.xtout(xtout[234])，.a(a[234])，.b(b[234])，.c(c[234])，
.d(d[234])，.sel(sel))；
xtmux4b i235(.xtout(xtout[235])，.a(a[235])，.b(b[235])，.c(c[235])，
.d(d[235])，.sel(sel))；
xtmux4b i236(.xtout(xtout[236])，.a(a[236])，.b(b[236])，.c(c[236])，
.d(d[236])，.sel(sel))；
<dp n="d232"/>
xtmux4b i237(.xtout(xtout[237])，.a(a[237])，.b(b[237])，.c(c[237])，
.d(d[237])，.sel(sel))；
xtmux4b i238(.xtout(xtout[238])，.a(a[238])，.b(b[238])，.c(c[238])，
.d(d[238])，.sel(sel))；
xtmux4b i239(.xtout(xtout[239])，.a(a[239])，.b(b[239])，.c(c[239])，
.d(d[239])，.sel(sel))；
xtmux4b i240(.xtout(xtout[240])，.a(a[240])，.b(b[240])，.c(c[240])，
.d(d[240])，.sel(sel))；
xtmux4b i241(.xtout(xtout[241])，.a(a[241])，.b(b[241])，.c(c[241])，
.d(d[241])，.sel(sel))；
xtmux4b i242(.xtout(xtout[242])，.a(a[242])，.b(b[242])，.c(c[242])，
.d(d[242])，.sel(sel))；
xtmux4b i243(.xtout(xtout[243])，.a(a[243])，.b(b[243])，.c(c[243])，
.d(d[243])，.sel(sel))；
xtmux4b i244(.xtout(xtout[244])，.a(a[244])，.b(b[244])，.c(c[244])，
.d(d[244])，.sel(sel))；
xtmux4b i245(.xtout(xtout[245])，.a(a[245])，.b(b[245])，.c(c[245])，
.d(d[245])，.sel(sel))；
xtmux4b i246(.xtout(xtout[246])，.a(a[246])，.b(b[246])，.c(c[246])，
.d(d[246])，.sel(sel))；
xtmux4b i247(.xtout(xtout[247])，.a(a[247])，.b(b[247])，.c(c[247])，
.d(d[247])，.sel(sel) )；
xtmux4b i248(.xtout(xtout[248])，.a(a[248])，.b(b[248])，.c(c[248])，
.d(d[248])，.sel(sel))；
xtmux4b i249(.xtout(xtout[249])，.a(a[249])，.b(b[249])，.c(c[249])，
.d(d[249])，.sel(sel))；
xtmux4b i250(.xtout(xtout[250])，.a(a[250])，.b(b[250])，.c(c[250])，
.d(d[250])，.sel(sel))；
xtmux4b i251(.xtout(xtout[251])，.a(a[251])，.b(b[251])，.c(c[251])，
.d(d[251])，.sel(sel))；
xtmux4b i252(.xtout(xtout[252])，.a(a[252])，.b(b[252])，.c(c[252])，
.d(d[252])，.sel(sel))；
xtmux4b i253(.xtout(xtout[253])，.a(a[253])，.b(b[253])，.c(c[253])，
.d(d[253])，.sel(sel))；
xtmux4b i254(.xtout(xtout[254])，.a(a[254])，.b(b[254])，.c(c[254])，
.d(d[254])，.sel(sel))；
xtmux4b i255(.xtout(xtout[255])，.a(a[255])，.b(b[255])，.c(c[255])，
.d(d[255])，.sel(sel))；
xtmux4b i256(.xtout(xtout[256])，.a(a[256])，.b(b[256])，.c(c[256])，
.d(d[256])，.sel(sel))；
xtmux4b i257(.xtout(xtout[257])，.a(a[257])，.b(b[257])，.c(c[257])，
.d(d[257])，.sel(sel))；
xtmux4b i258(.xtout(xtout[258])，.a(a[258])，.b(b[258])，.c(c[258])，
.d(d[258])，.sel(sel))；
xtmux4b i259(.xtout(xtout[259])，.a(a[259])，.b(b[259])，.c(c[259])，
.d(d[259])，.sel(sel))；
xtmux4b i260(.xtout(xtout[260])，.a(a[260])，.b(b[260])，.c(c[260])，
.d(d[260])，.sel(sel))；
xtmux4b i261(.xtout(xtout[261])，.a(a[261])，.b(b[261])，.c(c[261])，
.d(d[261])，.sel(sel))；
xtmux4b i262(.xtout(xtout[262])，.a(a[262])，.b(b[262])，.c(c[262])，
.d(d[262])，.sel(sel))；
xtmux4b i263(.xtout(xtout[263])，.a(a[263])，.b(b[263])，.c(c[263])，
.d(d[263])，.sel(sel))；
xtmux4b i264(.xtout(xtout[264])，.a(a[264])，.b(b[264])，.c(c[264])，
.d(d[264])，.sel(sel))；
xtmux4b i265(.xtout(xtout[265])，.a(a[265])，.b(b[265])，.c(c[265])，
.d(d[265])，.sel(sel))；
xtmux4b i266(.xtout(xtout[266])，.a(a[266])，.b(b[266])，.c(c[266])，
.d(d[266])，.sel(sel))；
<dp n="d233"/>
xtmux4b i267(.xtout(xtout[267])，.a(a[267])，.b(b[267])，.c(c[267])，
.d(d[267])，.sel(sel))；
xtmux4b i268(.xtout(xtout[268])，.a(a[268])，.b(b[268])，.c(c[268])，
.d(d[268])，.sel(sel))；
xtmux4b i269(.xtout(xtout[269])，.a(a[269])，.b(b[269])，.c(c[269])，
.d(d[269])，.sel(sel))；
xtmux4b i270(.xtout(xtout[270])，.a(a[270])，.b(b[270])，.c(c[270])，
.d(d[270])，.sel(sel))；
xtmux4b i271(.xtout(xtout[271])，.a(a[271])，.b(b[271])，.c(c[271])，
.d(d[271])，.sel(sel))；
xtmux4b i272(.xtout(xtout[272])，.a(a[272])，.b(b[272])，.c(c[272])，
.d(d[272])，.sel(sel))；
xtmux4b i273(.xtout(xtout[273])，.a(a[273])，.b(b[273])，.c(c[273])，
.d(d[273])，.sel(sel))；
xtmux4b i274(.xtout(xtout[274])，.a(a[274])，.b(b[274])，.c(c[274])，
.d(d[274])，.sel(sel))；
xtmux4b i275(.xtout(xtout[275])，.a(a[275])，.b(b[275])，.c(c[275])，
.d(d[275])，.sel(sel))；
xtmux4b i276(.xtout(xtout[276])，.a(a[276])，.b(b[276])，.c(c[276])，
.d(d[276])，.sel(sel))；
xtmux4b i277(.xtout(xtout[277])，.a(a[277])，.b(b[277])，.c(c[277])，
.d(d[277])，.sel(sel))；
xtmux4b i278(.xtout(xtout[278])，.a(a[278])，.b(b[278])，.c(c[278])，
.d(d[278])，.sel(sel))；
xtmux4b i279(.xtout(xtout[279])，.a(a[279])，.b(b[279])，.c(c[279])，
.d(d[279])，.sel(sel))；
xtmux4b i280(.xtout(xtout[280])，.a(a[280])，.b(b[280])，.c(c[280])，
.d(d[280])，.sel(sel))；
xtmux4b i281(.xtout(xtout[281])，.a(a[281])，.b(b[281])，.c(c[281])，
.d(d[281])，.sel (sel))；
xtmux4b i282(.xtout(xtout[282])，.a(a[282])，.b(b[282])，.c(c[282])，
.d(d[282])，.sel(sel))；
xtmux4b i283(.xtout(xtout[283])，.a(a[283])，.b(b[283])，.c(c[283])，
.d(d[283])，.sel(sel))；
xtmux4b i284(.xtout(xtout[284])，.a(a[284])，.b(b[284])，.c(c[284])，
.d(d[284])，.sel(sel))；
xtmux4b i285(.xtout(xtout[285])，.a(a[285])，.b(b[285])，.c(c[285])，
.d(d[285])，.sel(sel))；
xtmux4b i286(.xtout(xtout[286])，.a(a[286])，.b(b[286])，.c(c[286])，
.d(d[286])，.sel(sel))；
xtmux4b i287(.xtout(xtout[287])，.a(a[287])，.b(b[287])，.c(c[287])，
.d(d[287])，.sel(sel))；
xtmux4b i288(.xtout(xtout[288])，.a(a[288])，.b(b[288])，.c(c[288])，
.d(d[288])，.sel(sel))；
xtmux4b i289(.xtout(xtout[289])，.a(a[289])，.b(b[289])，.c(c[289])，
.d(d[289])，.sel(sel))；
xtmux4b i290(.xtout(xtout[290])，.a(a[290])，.b(b[290])，.c(c[290])，
.d(d[290])，.sel(sel))；
xtmux4b i291(.xtout(xtout[291])，.a(a[291])，.b(b[291])，.c(c[291])，
.d(d[291])，.sel(sel))；
xtmux4b i292(.xtout(xtout[292])，.a(a[292])，.b(b[292])，.c(c[292])，
.d(d[292])，.sel(sel))；
xtmux4b i293(.xtout(xtout[293])，.a(a[293])，.b(b[293])，.c(c[293])，
.d(d[293])，.sel(sel))；
xtmux4b i294(.xtout(xtout[294])，.a(a[294])，.b(b[294])，.c(c[294])，
.d(d[294])，.sel(sel))；
xtmux4b i295(.xtout(xtout[295])，.a(a[295])，.b(b[295])，.c(c[295])，
.d(d[295])，.sel(sel))；
xtmux4b i296(.xtout(xtout[296])，.a(a[296])，.b(b[296])，.c(c[296])，
.d(d[296])，.sel(sel))；
<dp n="d234"/>
xtmux4b i297(.xtout(xtout[297])，.a(a[297])，.b(b[297])，.c(c[297])，
.d(d[297])，.sel(sel))；
xtmux4b i298(.xtout(xtout[298])，.a(a[298])，.b(b[298])，.c(c[298])，
.d(d[298])，.sel(sel))；
xtmux4b i299(.xtout(xtout[299])，.a(a[299])，.b(b[299])，.c(c[299])，
.d(d[299])，.sel(sel))；
xtmux4b i300(.xtout(xtout[300])，.a(a[300])，.b(b[300])，.c(c[300])，
.d(d[300])，.sel(sel))；
xtmux4b i301(.xtout(xtout[301])，.a(a[301])，.b(b[301])，.c(c[301])，
.d(d[301])，.sel(sel))；
xtmux4b i302(.xtout(xtout[302])，.a(a[302])，.b(b[302])，.c(c[302])，
.d(d[302])，.sel(sel))；
xtmux4b i303(.xtout(xtout[303])，.a(a[303])，.b(b[303])，.c(c[303])，
.d(d[303])，.sel(sel))；
xtmux4b i304(.xtout(xtout[304])，.a(a[304])，.b(b[304])，.c(c[304])，
.d(d[304])，.sel(sel))；
xtmux4b i305(.xtout(xtout[305])，.a(a[305])，.b(b[305])，.c(c[305])，
.d(d[305])，.sel(sel))；
xtmux4b i306(.xtout(xtout[306])，.a(a[306])，.b(b[306])，.c(c[306])，
.d(d[306])，.sel(sel))；
xtmux4b i307(.xtout(xtout[307])，.a(a[307])，.b(b[307])，.c(c[307])，
.d(d[307])，.sel(sel))；
xtmux4b i308(.xtout(xtout[308])，.a(a[308])，.b(b[308])，.c(c[308])，
.d(d[308])，.sel(sel))；
xtmux4b i309(.xtout(xtout[309])，.a(a[309])，.b(b[309])，.c(c[309])，
.d(d[309])，.sel(sel))；
xtmux4b i310(.xtout(xtout[310])，.a(a[310])，.b(b[310])，.c(c[310])，
.d(d[310])，.sel(sel))；
xtmux4b i311(.xtout(xtout[311])，.a(a[311])，.b(b[311])，.c(c[311])，
.d(d[311])，.sel(sel))；
xtmux4b i312(.xtout(xtout[312])，.a(a[312])，.b(b[312])，.c(c[312])，
.d(d[312])，.sel(sel))；
xtmux4b i313(.xtout(xtout[313])，.a(a[313])，.b(b[313])，.c(c[313])，
.d(d[313])，.sel(sel))；
xtmux4b i314(.xtout(xtout[314])，.a(a[314])，.b(b[314])，.c(c[314])，
.d(d[314])，.sel(sel))；
xtmux4b i315(.xtout(xtout[315])，.a(a[315])，.b(b[315])，.c(c[315])，
.d(d[315])，.sel(sel))；
xtmux4b i316(.xtout(xtout[316])，.a(a[316])，.b(b[316])，.c(c[316])，
.d(d[316])，.sel(sel))；
xtmux4b i317(.xtout(xtout[317])，.a(a[317])，.b(b[317])，.c(c[317])，
.d(d[317])，.sel(sel))；
xtmux4b i318(.xtout(xtout[318])，.a(a[318])，.b(b[318])，.c(c[318])，
.d(d[318])，.sel(sel))；
xtmux4b i319(.xtout(xtout[319])，.a(a[319])，.b(b[319])，.c(c[319])，
.d(d[319])，.sel(sel))；
xtmux4b i320(.xtout(xtout[320])，.a(a[320])，.b(b[320])，.c(c[320])，
.d(d[320])，.sel(sel))；
xtmux4b i321(.xtout(xtout[321])，.a(a[321])，.b(b[321])，.c(c[321])，
.d(d[321])，.sel(sel))；
xtmux4b i322(.xtout(xtout[322])，.a(a[322])，.b(b[322])，.c(c[322])，
.d(d[322])，.sel(sel))；
xtmux4b i323(.xtout(xtout[323])，.a(a[323])，.b(b[323])，.c(c[323])，
.d(d[323])，.sel(sel))；
xtmux4b i324(.xtout(xtout[324])，.a(a[324])，.b(b[324])，.c(c[324])，
.d(d[324])，.sel(sel))；
xtmux4b i325(.xtout(xtout[325])，.a(a[325])，.b(b[325])，.c(c[325])，
.d(d[325])，.sel(sel))；
xtmux4b i326(.xtout(xtout[326])，.a(a[326])，.b(b[326])，.c(c[326])，
.d(d[326])，.sel(sel))；
<dp n="d235"/>
xtmux4b i327(.xtout(xtout[327])，.a(a[327])，.b(b[327])，.c(c[327])，
.d(d[327])，.sel(sel))；
xtmux4b i328(.xtout(xtout[328])，.a(a[328])，.b(b[328])，.c(c[328])，
.d(d[328])，.sel(sel))；
xtmux4b i329(.xtout(xtout[329])，.a(a[329])，.b(b[329])，.c(c[329])，
.d(d[329])，.sel(sel))；
xtmux4b i330(.xtout(xtout[330])，.a(a[330])，.b(b[330])，.c(c[330])，
.d(d[330])，.sel(sel))；
xtmux4b i331(.xtout(xtout[331])，.a(a[331])，.b(b[331])，.c(c[331])，
.d(d[331])，.sel(sel))；
xtmux4b i332(.xtout(xtout[332])，.a(a[332])，.b(b[332])，.c(c[332])，
.d(d[332])，.sel(sel))；
xtmux4b i333(.xtout(xtout[333])，.a(a[333])，.b(b[333])，.c(c[333])，
.d(d[333])，.sel(sel))；
xtmux4b i334(.xtout(xtout[334])，.a(a[334])，.b(b[334])，.c(c[334])，
.d(d[334])，.sel(sel))；
xtmux4b i335(.xtout(xtout[335])，.a(a[335])，.b(b[335])，.c(c[335])，
.d(d[335])，.sel(sel))；
xtmux4b i336(.xtout(xtout[336])，.a(a[336])，.b(b[336])，.c(c[336])，
.d(d[336])，.sel(sel))；
xtmux4b i337(.xtout(xtout[337])，.a(a[337])，.b(b[337])，.c(c[337])，
.d(d[337])，.sel(sel))；
xtmux4b i338(.xtout(xtout[338])，.a(a[338])，.b(b[338])，.c(c[338])，
.d(d[338])，.sel(sel))；
xtmux4b i339(.xtout(xtout[339])，.a(a[339])，.b(b[339])，.c(c[339])，
.d(d[339])，.sel(sel))；
xtmux4b i340(.xtout(xtout[340])，.a(a[340])，.b(b[340])，.c(c[340])，
.d(d[340])，.sel(sel))；
xtmux4b i341(.xtout(xtout[341])，.a(a[341])，.b(b[341])，.c(c[341])，
.d(d[341])，.sel(sel))；
xtmux4b i342(.xtout(xtout[342])，.a(a[342])，.b(b[342])，.c(c[342])，
.d(d[342])，.sel(sel))；
xtmux4b i343(.xtout(xtout[343])，.a(a[343])，.b(b[343])，.c(c[343])，
.d(d[343])，.sel(sel))；
xtmux4b i344(.xtout(xtout[344])，.a(a[344])，.b(b[344])，.c(c[344])，
.d(d[344])，.sel(sel))；
xtmux4b i345(.xtout(xtout[345])，.a(a[345])，.b(b[345])，.c(c[345])，
.d(d[345])，.sel(sel))；
xtmux4b i346(.xtout(xtout[346])，.a(a[346])，.b(b[346])，.c(c[346])，
.d(d[346])，.sel(sel))；
xtmux4b i347(.xtout(xtout[347])，.a(a[347])，.b(b[347])，.c(c[347])，
.d(d[347])，.sel(sel))；
xtmux4b i348(.xtout(xtout[348])，.a(a[348])，.b(b[348])，.c(c[348])，
.d(d[348])，.sel(sel))；
xtmux4b i349(.xtout(xtout[349])，.a(a[349])，.b(b[349])，.c(c[349])，
.d(d[349])，.sel(sel))；
xtmux4b i350(.xtout(xtout[350])，.a(a[350])，.b(b[350])，.c(c[350])，
.d(d[350])，.sel(sel))；
xtmux4b i351(.xtout(xtout[351])，.a(a[351])，.b(b[351])，.c(c[351])，
.d(d[351])，.sel(sel))；
xtmux4b i352(.xtout(xtout[352])，.a(a[352])，.b(b[352])，.c(c[352])，
.d(d[352])，.sel(sel))；
xtmux4b i353(.xtout(xtout[353])，.a(a[353])，.b(b[353])，.c(c[353])，
.d(d[353])，.sel(sel))；
xtmux4b i354(.xtout(xtout[354])，.a(a[354])，.b(b[354])，.c(c[354])，
.d(d[354])，.sel(sel))；
xtmux4b i355(.xtout(xtout[355])，.a(a[355])，.b(b[355])，.c(c[355])，
.d(d[355])，.sel(sel))；
xtmux4b i356(.xtout(xtout[356])，.a(a[356])，.b(b[356])，.c(c[356])，
.d(d[356])，.sel(sel))；
<dp n="d236"/>
xtmux4b i357(.xtout(xtout[357])，.a(a[357])，.b(b[357])，.c(c[357])，
.d(d[357])，.sel(sel))；
xtmux4b i358(.xtout(xtout[358])，.a(a[358])，.b(b[358])，.c(c[358])，
.d(d[358])，.sel(sel))；
xtmux4b i359(.xtout(xtout[359])，.a(a[359])，.b(b[359])，.c(c[359])，
.d(d[359])，.sel(sel))；
xtmux4b i360(.xtout(xtout[360])，.a(a[360])，.b(b[360])，.c(c[360])，
.d(d[360])，.sel(sel))；
xtmux4b i361(.xtout(xtout[361])，.a(a[361])，.b(b[361])，.c(c[361])，
.d(d[361])，.sel(sel))；
xtmux4b i362(.xtout(xtout[362])，.a(a[362])，.b(b[362])，.c(c[362])，
.d(d[362])，.sel(sel))；
xtmux4b i363(.xtout(xtout[363])，.a(a[363])，.b(b[363])，.c(c[363])，
.d(d[363])，.sel(sel))；
xtmux4b i364(.xtout(xtout[364])，.a(a[364])，.b(b[364])，.c(c[364])，
.d(d[364])，.sel(sel))；
xtmux4b i365(.xtout(xtout[365])，.a(a[365])，.b(b[365])，.c(c[365])，
.d(d[365])，.sel(sel))；
xtmux4b i366(.xtout(xtout[366])，.a(a[366])，.b(b[366])，.c(c[366])，
.d(d[366])，.sel(sel))；
xtmux4b i367(.xtout(xtout[367])，.a(a[367])，.b(b[367])，.c(c[367])，
.d(d[367])，.sel(sel))；
xtmux4b i368(.xtout(xtout[368])，.a(a[368])，.b(b[368])，.c(c[368])，
.d(d[368])，.sel(sel))；
xtmux4b i369(.xtout(xtout[369])，.a(a[369])，.b(b[369])，.c(c[369])，
.d(d[369])，.sel(sel))；
xtmux4b i370(.xtout(xtout[370])，.a(a[370])，.b(b[370])，.c(c[370])，
.d(d[370])，.sel(sel))；
xtmux4b i371(.xtout(xtout[371])，.a(a[371])，.b(b[371])，.c(c[371])，
.d(d[371])，.sel(sel))；
xtmux4b i372(.xtout(xtout[372])，.a(a[372])，.b(b[372])，.c(c[372])，
.d(d[372])，.sel(sel))；
xtmux4b i373(.xtout(xtout[373])，.a(a[373])，.b(b[373])，.c(c[373])，
.d(d[373])，.sel(sel))；
xtmux4b i374(.xtout(xtout[374])，.a(a[374])，.b(b[374])，.c(c[374])，
.d(d[374])，.sel(sel))；
xtmux4b i375(.xtout(xtout[375])，.a(a[375])，.b(b[375])，.c(c[375])，
.d(d[375])，.sel(sel))；
xtmux4b i376(.xtout(xtout[376])，.a(a[376])，.b(b[376])，.c(c[376])，
.d(d[376])，.sel(sel))；
xtmux4b i377(.xtout(xtout[377])，.a(a[377])，.b(b[377])，.c(c[377])，
.d(d[377])，.sel(sel))；
xtmux4b i378(.xtout(xtout[378])，.a(a[378])，.b(b[378])，.c(c[378])，
.d(d[378])，.sel(sel))；
xtmux4b i379(.xtout(xtout[379])，.a(a[379])，.b(b[379])，.c(c[379])，
.d(d[379])，.sel(sel))；
xtmux4b i380(.xtout(xtout[380])，.a(a[380])，.b(b[380])，.c(c[380])，
.d(d[380])，.sel(sel))；
xtmux4b i381(.xtout(xtout[381])，.a(a[381])，.b(b[381])，.c(c[381])，
.d(d[381])，.sel(sel))；
xtmux4b i382(.xtout(xtout[382])，.a(a[382])，.b(b[382])，.c(c[382])，
.d(d[382])，.sel(sel))；
xtmux4b i383(.xtout(xtout[383])，.a(a[383])，.b(b[383])，.c(c[383])，
.d(d[383])，.sel(sel))；
xtmux4b i384(.xtout(xtout[384])，.a(a[384])，.b(b[384])，.c(c[384])，
.d(d[384])，.sel(sel))；
xtmux4b i385(.xtout(xtout[385])，.a(a[385])，.b(b[385])，.c(c[385])，
.d(d[385])，.sel(sel))；
xtmux4b i386(.xtout(xtout[386])，.a(a[386])，.b(b[386])，.c(c[386])，
.d(d[386])，.sel(sel))；
<dp n="d237"/>
xtmux4b i387(.xtout(xtout[387])，.a(a[387])，.b(b[387])，.c(c[387])，
.d(d[387])，.sel(sel))；
xtmux4b i388(.xtout(xtout[388])，.a(a[388])，.b(b[388])，.c(c[388])，
.d(d[388])，.sel(sel))；
xtmux4b i389(.xtout(xtout[389])，.a(a[389])，.b(b[389])，.c(c[389])，
.d(d[389])，.sel(sel))；
xtmux4b i390(.xtout(xtout[390])，.a(a[390])，.b(b[390])，.c(c[390])，
.d(d[390])，.sel(sel))；
xtmux4b i391(.xtout(xtout[391])，.a(a[391])，.b(b[391])，.c(c[391])，
.d(d[391])，.sel(sel))；
xtmux4b i392(.xtout(xtout[392])，.a(a[392])，.b(b[392])，.c(c[392])，
.d(d[392])，.sel(sel))；
xtmux4b i393(.xtout(xtout[393])，.a(a[393])，.b(b[393])，.c(c[393])，
.d(d[393])，.sel(sel))；
xtmux4b i394(.xtout(xtout[394])，.a(a[394])，.b(b[394])，.c(c[394])，
.d(d[394])，.sel(sel))；
xtmux4b i395(.xtout(xtout[395])，.a(a[395])，.b(b[395])，.c(c[395])，
.d(d[395])，.sel(sel))；
xtmux4b i396(.xtout(xtout[396])，.a(a[396])，.b(b[396])，.c(c[396])，
.d(d[396])，.sel(sel))；
xtmux4b i397(.xtout(xtout[397])，.a(a[397])，.b(b[397])，.c(c[397])，
.d(d[397])，.sel(sel))；
xtmux4b i398(.xtout(xtout[398])，.a(a[398])，.b(b[398])，.c(c[398])，
.d(d[398])，.sel(sel))；
xtmux4b i399(.xtout(xtout[399])，.a(a[399])，.b(b[399])，.c(c[399])，
.d(d[399])，sel(sel))；
xtmux4b i400(.xtout(xtout[400])，.a(a[400])，.b(b[400])，.c(c[400])，
.d(d[400])，.sel(sel))；
xtmux4b i401(.xtout(xtout[401])，.a(a[401])，.b(b[401])，.c(c[401])，
.d(d[401])，.sel(sel))；
xtmux4b i402(.xtout(xtout[402])，.a(a[402])，.b(b[402])，.c(c[402])，
.d(d[402])，.sel(sel))；
xtmux4b i403(.xtout(xtout[403])，.a(a[403])，.b(b[403])，.c(c[403])，
.d(d[403])，.sel(sel))；
xtmux4b i404(.xtout(xtout[404])，.a(a[404])，.b(b[404])，.c(c[404])，
.d(d[404])，.sel(sel))；
xtmux4b i405(.xtout(xtout[405])，.a(a[405])，.b(b[405])，.c(c[405])，
.d(d[405])，.sel(sel))；
xtmux4b i406(.xtout(xtout[406])，.a(a[406])，.b(b[406])，.c(c[406])，
.d(d[406])，.sel(sel))；
xtmux4b i407(.xtout(xtout[407])，.a(a[407])，.b(b[407])，.c(c[407])，
.d(d[407])，.sel(sel))；
xtmux4b i408(.xtout(xtout[408])，.a(a[408])，.b(b[408])，.c(c[408])，
.d(d[408])，.sel(sel))；
xtmux4b i409(.xtout(xtout[409])，.a(a[409])，.b(b[409])，.c(c[409])，
.d(d[409])，.sel(sel))；
xtmux4b i410(.xtout(xtout[410])，.a(a[410])，.b(b[410])，.c(c[410])，
.d(d[410])，.sel(sel))；
xtmux4b i411(.xtout(xtout[411])，.a(a[411])，.b(b[411])，.c(c[411])，
.d(d[411])，sel(sel))；
xtmux4b i412(.xtout(xtout[412])，.a(a[412])，.b(b[412])，.c(c[412])，
.d(d[412])，.sel(sel))；
xtmux4b i413(.xtout(xtout[413])，.a(a[413])，.b(b[413])，.c(c[413])，
.d(d[413])，.sel(sel))；
xtmux4b i414(.xtout(xtout[414])，.a(a[414])，.b(b[414])，.c(c[414])，
.d(d[414])，.sel(sel))；
xtmux4b i415(.xtout(xtout[415])，.a(a[415])，.b(b[415])，.c(c[415])，
.d(d[415])，.sel(sel))；
xtmux4b i416(.xtout(xtout[416])，.a(a[416])，.b(b[416])，.c(c[416])，
.d(d[416])，.sel(sel))；
<dp n="d238"/>
xtmux4b i417(.xtout(xtout[417])，.a(a[417])，.b(b[417])，.c(c[417])，
.d(d[417])，.sel(sel))；
xtmux4b i418(.xtout(xtout[418])，.a(a[418])，.b(b[418])，.c(c[418])，
.d(d[418])，.sel(sel))；
xtmux4b i419(.xtout(xtout[419])，.a(a[419])，.b(b[419])，.c(c[419])，
.d(d[419])，.sel(sel))；
xtmux4b i420(.xtout(xtout[420])，.a(a[420])，.b(b[420])，.c(c[420])，
.d(d[420])，.sel(sel))；
xtmux4b i421(.xtout(xtout[421])，.a(a[421])，.b(b[421])，.c(c[421])，
.d(d[421])，.sel(sel))；
xtmux4b i422(.xtout(xtout[422])，.a(a[422])，.b(b[422])，.c(c[422])，
.d(d[422])，.sel(sel))；
xtmux4b i423(.xtout(xtout[423])，.a(a[423])，.b(b[423])，.c(c[423])，
.d(d[423])，.sel(sel))；
xtmux4b i424(.xtout(xtout[424])，.a(a[424])，.b(b[424])，.c(c[424])，
.d(d[424])，.sel(sel))；
xtmux4b i425(.xtout(xtout[425])，.a(a[425])，.b(b[425])，.c(c[425])，
.d(d[425])，.sel(sel))；
xtmux4b i426(.xtout(xtout[426])，.a(a[426])，.b(b[426])，.c(c[426])，
.d(d[426])，.sel(sel))；
xtmux4b i427(.xtout(xtout[427])，.a(a[427])，.b(b[427])，.c(c[427])，
.d(d[427])，.sel(sel))；
xtmux4b i428(.xtout(xtout[428])，.a(a[428])，.b(b[428])，.c(c[428])，
.d(d[428])，.sel(sel))；
xtmux4b i429(.xtout(xtout[429])，.a(a[429])，.b(b[429])，.c(c[429])，
.d(d[429])，.sel(sel))；
xtmux4b i430(.xtout(xtout[430])，.a(a[430])，.b(b[430])，.c(c[430])，
.d(d[430])，.sel(sel))；
xtmux4b i431(.xtout(xtout[431])，.a(a[431])，.b(b[431])，.c(c[431])，
.d(d[431])，.sel(sel))；
xtmux4b i432(.xtout(xtout[432])，.a(a[432])，.b(b[432])，.c(c[432])，
.d(d[432])，.sel(sel))；
xtmux4b i433(.xtout(xtout[433])，.a(a[433])，.b(b[433])，.c(c[433])，
.d(d[433])，.sel(sel))；
xtmux4b i434(.xtout(xtout[434])，.a(a[434])，.b(b[434])，.c(c[434])，
.d(d[434])，.sel(sel))；
xtmux4b i435(.xtout(xtout[435])，.a(a[435])，.b(b[435])，.c(c[435])，
.d(d[435])，.sel(sel))；
xtmux4b i436(.xtout(xtout[436])，.a(a[436])，.b(b[436])，.c(c[436])，
.d(d[436])，.sel(sel))；
xtmux4b i437(.xtout(xtout[437])，.a(a[437])，.b(b[437])，.c(c[437])，
.d(d[437])，.sel(sel))；
xtmux4b i438(.xtout(xtout[438])，.a(a[438])，.b(b[438])，.c(c[438])，
.d(d[438])，.sel(sel))；
xtmux4b i439(.xtout(xtout[439])，.a(a [439])，.b(b[439])，.c(c[439])，
.d(d[439])，.sel(sel))；
xtmux4b i440(.xtout(xtout[440])，.a(a[440])，.b(b[440])，.c(c[440])，
.d(d[440])，.sel(sel))；
xtmux4b i441(.xtout(xtout[441])，.a(a[441])，.b(b[441])，.c(c[441])，
.d(d[441])，.sel(sel))；
xtmux4b i442(.xtout(xtout[442])，.a(a[442])，.b(b[442])，.c(c[442])，
.d(d[442])，.sel(sel))；
xtmux4b i443(.xtout(xtout[443])，.a(a[443])，.b(b[443])，.c(c[443])，
.d(d[443])，.sel(sel))；
xtmux4b i444(.xtout(xtout[444])，.a(a[444])，.b(b[444])，.c(c[444])，
.d(d[444])，.sel(sel))；
xtmux4b i445(.xtout(xtout[445])，.a(a[445])，.b(b[445])，.c(c[445])，
.d(d[445])，.sel(sel))；
xtmux4b i446(.xtout(xtout[446])，.a(a[446])，.b(b[446])，.c(c[446])，
.d(d[446])，.sel(sel))；
<dp n="d239"/>
xtmux4b i447(.xtout(xtout[447])，.a(a[447])，.b(b[447])，.c(c[447])，
.d(d[447])，.sel(sel))；
xtmux4b i448(.xtout(xtout[448])，.a(a[448])，.b(b[448])，.c(c[448])，
.d(d[448])，.sel(sel))；
xtmux4b i449(.xtout(xtout[449])，.a(a[449])，.b(b[449])，.c(c[449])，
.d(d[449])，.sel(sel))；
xtmux4b i450(.xtout(xtout[450])，.a(a[450])，.b(b[450])，.c(c[450])，
.d(d[450])，.sel(sel))；
xtmux4b i451(.xtout(xtout[451])，.a(a[451])，.b(b[451])，.c(c[451])，
.d(d[451])，.sel(sel))；
xtmux4b i452(.xtout(xtout[452])，.a(a[452])，.b(b[452])，.c(c[452])，
.d(d[452])，.sel(sel))；
xtmux4b i453(.xtout(xtout[453])，.a(a[453])，.b(b[453])，.c(c[453])，
.d(d[453])，.sel(sel))；
xtmux4b i454(.xtout(xtout[454])，.a(a[454])，.b(b[454])，.c(c[454])，
.d(d[454])，.sel(sel))；
xtmux4b i455(.xtout(xtout[455])，.a(a[455])，.b(b[455])，.c(c[455])，
.d(d[455])，.sel(sel))；
xtmux4b i456(.xtout(xtout[456])，.a(a[456])，.b(b[456])，.c(c[456])，
.d(d[456])，.sel(sel))；
xtmux4b i457(.xtout(xtout[457])，.a(a[457])，.b(b[457])，.c(c[457])，
.d(d[457])，.sel(sel))；
xtmux4b i458(.xtout(xtout[458])，.a(a[458])，.b(b[458])，.c(c[458])，
.d(d[458])，.sel(sel))；
xtmux4b i459(.xtout(xtout[459])，.a(a[459])，.b(b[459])，.c(c[459])，
.d(d[459])，.sel(sel))；
xtmux4b i460(.xtout(xtout[460])，.a(a[460])，.b(b[460])，.c(c[460])，
.d(d[460])，.sel(sel))；
xtmux4b i461(.xtout(xtout[461])，.a(a[461])，.b(b[461])，.c(c[461])，
.d(d[461])，.sel(sel))；
xtmux4b i462(.xtout(xtout[462])，.a(a[462])，.b(b[462])，.c(c[462])，
.d(d[462])，.sel(sel))；
xtmux4b i463(.xtout(xtout[463])，.a(a[463])，.b(b[463])，.c(c[463])，
.d(d[463])，.sel(sel))；
xtmux4b i464(.xtout(xtout[464])，.a(a[464])，.b(b[464])，.c(c[464])，
.d(d[464])，.sel(sel))；
xtmux4b i465(.xtout(xtout[465])，.a(a[465])，.b(b[465])，.c(c[465])，
.d(d[465])，.sel(sel))；
xtmux4b i466(.xtout(xtout[466])，.a(a[466])，.b(b[466])，.c(c[466])，
.d(d[466])，.sel(sel))；
xtmux4b i467(.xtout(xtout[467])，.a(a[467])，.b(b[467])，.c(c[467])，
.d(d[467])，.sel(sel))；
xtmux4b i468(.xtout(xtout[468])，.a(a[468])，.b(b[468])，.c(c[468])，
.d(d[468])，.sel(sel))；
xtmux4b i469(.xtout(xtout[469])，.a(a[469])，.b(b[469])，.c(c[469])，
.d(d[469])，.sel(sel))；
xtmux4b i470(.xtout(xtout[470])，.a(a[470])，.b(b[470])，.c(c[470])，
.d(d[470])，.sel(sel))；
xtmux4b i471(.xtout(xtout[471])，.a(a[471])，.b(b[471])，.c(c[471])，
.d(d[471])，.sel(sel))；
xtmux4b i472(.xtout(xtout[472])，.a(a[472])，.b(b[472])，.c(c[472])，
.d(d[472])，.sel(sel))；
xtmux4b i473(.xtout(xtout[473])，.a(a[473])，.b(b[473])，.c(c[473])，
.d[d[473])，.sel(sel))；
xtmux4b i474(.xtout(xtout[474])，.a(a[474])，.b(b[474])，.c(c[474])，
.d(d[474])，.sel(sel))；
xtmux4b i475(.xtout(xtout[475])，.a(a[475])，.b(b[475])，.c(c[475])，
.d(d[475])，.sel(sel))；
xtmux4b i476(.xtout(xtout[476])，.a(a[476])，.b(b[476])，.c(c[476])，
.d(d[476])，.sel(sel))；
<dp n="d240"/>
xtmux4b i477(.xtout(xtout[477])，.a(a[477])，.b(b[477])，.c(c[477])，
.d(d[477])，.sel(sel))；
xtmux4b i478(.xtout(xtout[478])，.a(a[478])，.b(b[478])，.c(c[478])，
.d(d[478])，.sel(sel))；
xtmux4b i479(.xtout(xtout[479])，.a(a[479])，.b(b[479])，.c(c[479])，
.d(d[479])，.sel(sel))；
xtmux4b i480(.xtout(xtout[480])，.a(a[480])，.b(b[480])，.c(c[480])，
.d(d[480])，.sel(sel))；
xtmux4b i481(.xtout(xtout[481])，.a(a[481])，.b(b[481])，.c(c[481])，
.d(d[481])，.sel(sel))；
xtmux4b i482(.xtout(xtout[482])，.a(a[482])，.b(b[482])，.c(c[482])，
.d(d[482])，.sel(sel))；
xtmux4b i483(.xtout(xtout[483])，.a(a[483])，.b(b[483])，.c(c[483])，
.d(d[483])，.sel(sel))；
xtmux4b i484(.xtout(xtout[484])，.a(a[484])，.b(b[484])，.c(c[484])，
.d(d[484])，.sel(sel))；
xtmux4b i485(.xtout(xtout[485])，.a(a[485])，.b(b[485])，.c(c[485])，
.d(d[485])，.sel(sel))；
xtmux4b i486(.xtout(xtout[486])，.a(a[486])，.b(b[486])，.c(c[486])，
.d(d[486])，.sel(sel))；
xtmux4b i487(.xtout(xtout[487])，.a(a[487])，.b(b[487])，.c(c[487])，
.d(d[487])，.sel(sel))；
xtmux4b i488(.xtout(xtout[488])，.a(a[488])，.b(b[488])，.c(c[488])，
.d(d[488])，.sel(sel))；
xtmux4b i489(.xtout(xtout[489])，.a(a[489])，.b(b[489])，.c(c[489])，
.d(d[489])，.sel(sel))；
xtmux4b i490(.xtout(xtout[490])，.a(a[490])，.b(b[490])，.c(c[490])，
.d(d[490])，.sel(sel))；
xtmux4b i491(.xtout(xtout[491])，.a(a[491])，.b(b[491])，.c(c[491])，
.d(d[491])，.sel(sel))；
xtmux4b i492(.xtout(xtout[492])，.a(a[492])，.b(b[492])，.c(c[492])，
.d(d[492])，.sel(sel))；
xtmux4b i493(.xtout(xtout[493])，.a(a[493])，.b(b[493])，.c(c[493])，
.d(d[493])，.sel(sel))；
xtmux4b i494(.xtout(xtout[494])，.a(a[494])，.b(b[494])，.c(c[494])，
.d(d[494])，.sel(sel))；
xtmux4b i495(.xtout(xtout[495])，.a(a[495])，.b(b[495])，.c(c[495])，
.d(d[495])，.sel(sel))；
xtmux4b i496(.xtout(xtout[496])，.a(a[496])，.b(b[496])，.c(c[496])，
.d(d[496])，.sel(sel))；
xtmux4b i497(.xtout(xtout[497])，.a(a[497])，.b(b[497])，.c(c[497])，
.d(d[497])，.sel(sel))；
xtmux4b i498(.xtout(xtout[498])，.a(a[498])，.b(b[498])，.c(c[498])，
.d(d[498])，.sel(sel))；
xtmux4b i499(.xtout(xtout[499])，.a(a[499])，.b(b[499])，.c(c[499])，
.d(d[499])，.sel(sel))；
xtmux4b i500(.xtout(xtout[500])，.a(a[500])，.b(b[500])，.c(c[500])，
.d(d[500])，.sel(sel))；
xtmux4b i501(.xtout(xtout[501])，.a(a[501])，.b(b[501])，.c(c[501])，
.d(d[501])，.sel(sel))；
xtmux4b i502(.xtout(xtout[502])，.a(a[502])，.b(b[502])，.c(c[502])，
.d(d[502])，.sel(sel))；
xtmux4b i503(.xtout(xtout[503])，.a(a[503])，.b(b[503])，.c(c[503])，
.d(d[503])，.sel(sel))；
xtmux4b i504(.xtout(xtout[504])，.a(a[504])，.b(b[504])，.c(c[504])，
.d(d[504])，.sel(sel))；
xtmux4b i505(.xtout(xtout[505])，.a(a[505])，.b(b[505])，.c(c[505])，
.d(d[505])，.sel(sel))；
xtmux4b i506(.xtout(xtout[506])，.a(a[506])，.b(b[506])，.c(c[506])，
.d(d[506])，.sel(sel))；
<dp n="d241"/>
xtmux4b i507(.xtout(xtout[507])，.a(a[507])，.b(b[507])，.c(c[507])，
.d(d[507])，.sel(sel))；
xtmux4b i508(.xtout(xtout[508])，.a(a[508])，.b(b[508])，.c(c[508])，
.d(d[508])，.sel(sel))；
xtmux4b i509(.xtout(xtout[509])，.a(a[509])，.b(b[509])，.c(c[509])，
.d(d[509])，.sel(sel))；
xtmux4b i510(.xtout(xtout[510])，.a(a[510])，.b(b[510])，.c(c[510])，
.d(d[510])，.sel(sel))；
xtmux4b i511(.xtout(xtout[511])，.a(a[511])，.b(b[511])，.c(c[511])，
.d(d[511])，.sel(sel))；
xtmux4b i512(.xtout(xtout[512])，.a(a[512])，.b(b[512])，.c(c[512])，
.d(d[512])，.sel(sel))；
xtmux4b i513(.xtout(xtout[513])，.a(a[513])，.b(b[513])，.c(c[513])，
.d(d[513])，.sel(sel))；
xtmux4b i514(.xtout(xtout[514])，.a(a[514])，.b(b[514])，.c(c[514])，
.d(d[514])，.sel(sel))；
xtmux4b i515(.xtout(xtout[515])，.a(a[515])，.b(b[515])，.c(c[515])，
.d(d[515])，.sel(sel))；
xtmux4b i516(.xtout(xtout[516])，.a(a[516])，.b(b[516])，.c(c[516])，
.d(d[516])，.sel(sel))；
xtmux4b i517(.xtout(xtout[517])，.a(a[517])，.b(b[517])，.c(c[517])，
.d(d[517])，.sel(sel))；
xtmux4b i518(.xtout(xtout[518])，.a(a[518])，.b(b[518])，.c(c[518])，
.d(d[518])，.sel(sel))；
xtmux4b i519(.xtout(xtout[519])，.a(a[519])，.b(b[519])，.c(c[519])，
.d(d[519])，.sel(sel))；
xtmux4b i520(.xtout(xtout[520])，.a(a[520])，.b(b[520])，.c(c[520])，
.d(d[520])，.sel(sel))；
xtmux4b i521(.xtout(xtout[521])，.a(a[521])，.b(b[521])，.c(c[521])，
.d(d[521])，.sel(sel))；
xtmux4b i522(.xtout(xtout[522])，.a(a[522])，.b(b[522])，.c(c[522])，
.d(d[522])，.sel(sel))；
xtuux4b i523(.xtout(xtout[523])，.a(a[523])，.b(b[523])，.c(c[523])，
.d(d[523])，.sel(sel))；
xtmux4b i524(.xtout(xtout[524])，.a(a[524])，.b(b[524])，.c(c[524])，
.d(d[524])，.sel(sel))；
xtmux4b i525(.xtout(xtout[525])，.a(a[525])，.b(b[525])，.c(c[525])，
.d(d[525])，.sel(sel))；
xtmux4b i526(.xtout(xtout[526])，.a(a[526])，.b(b[526])，.c(c[526])，
.d(d[526])，.sel(sel))；
xtmux4b i527(.xtout(xtout[527])，.a(a[527])，.b(b[527])，.c(c[527])，
.d(d[527])，.sel(sel))；
xtmux4b i528(.xtout(xtout[528])，.a(a[528])，.b(b[528])，.c(c[528])，
.d(d[528])，.sel(sel))；
xtmux4b i529(.xtout(xtout[529])，.a(a[529])，.b(b[529])，.c(c[529])，
.d(d[529])，.sel(sel))；
xtmux4b i530(.xtout(xtout[530])，.a(a[530])，.b(b[530])，.c(c[530])，
.d(d[530])，.sel(sel))；
xtmux4b i531(.xtout(xtout[531])，.a(a[531])，.b(b[531])，.c(c[531])，
.d(d[531])，.sel(sel))；
xtmux4b i532(.xtout(xtout[532])，.a(a[532])，.b(b[532])，.c(c[532])，
.d(d[532])，.sel(sel))；
xtmux4b i533(.xtout(xtout[533])，.a(a[533])，.b(b[533])，.c(c[533])，
.d(d[533])，.sel(sel))；
xtmux4b i534(.xtout(xtout[534])，.a(a[534])，.b(b[534])，.c(c[534])，
.d(d[534])，.sel(sel))；
xtmux4b i535(.xtout(xtout[535])，.a(a[535])，.b(b[535])，.c(c[535])，
.d(d[535])，.sel(sel))；
xtmux4b i536(.xtout(xtout[536])，.a(a[536])，.b(b[536])，.c(c[536])，
.d(d[536])，.sel(sel))；
<dp n="d242"/>
xtmux4b i537(.xtout(xtout[537])，.a(a[537])，.b(b[537])，.c(c[537])，
.d(d[537])，.sel(sel))；
xtmux4b i538(.xtout(xtout[538])，.a(a[538])，.b(b[538])，.c(c[538])，
.d(d[538])，.sel(sel))；
xtmux4b i539(.xtout(xtout[539])，.a(a[539])，.b(b[539])，.c(c[539])，
.d(d[539])，.sel(sel))；
xtmux4b i540(.xtout(xtout[540])，.a(a[540])，.b(b[540])，.c(c[540])，
.d(d[540])，.sel(sel))；
xtmux4b i541(.xtout(xtout[541])，.a(a[541])，.b(b[541])，.c(c[541])，
.d(d[541])，.sel(sel))；
xtmux4b i542(.xtout(xtout[542])，.a(a[542])，.b(b[542])，.c(c[542])，
.d(d[542])，.sel(sel))；
xtmux4b i543(.xtout(xtout[543])，.a(a[543])，.b(b[543])，.c(c[543])，
.d(d[543])，.sel(sel))；
xtmux4b i544(.xtout(xtout[544])，.a(a[544])，.b(b[544])，.c(c[544])，
.d(d[544])，.sel(sel))；
xtmux4b i545(.xtout(xtout[545])，.a(a[545])，.b(b[545])，.c(c[545])，
.d(d[545])，.sel(sel))；
xtmux4b i546(.xtout(xtout[546])，.a(a[546])，.b(b[546])，.c(c[546])，
.d(d [546])，.sel(sel))；
xtmux4b i547(.xtout(xtout[547])，.a(a[547])，.b(b[547])，.c(c[547])，
.d(d[547])，.sel(sel))；
xtmux4b i548(.xtout(xtout[548])，.a(a[548])，.b(b[548])，.c(c[548])，
.d(d[548])，.sel(sel))；
xtmux4b i549(.xtout(xtout[549])，.a(a[549])，.b(b[549])，.c(c[549])，
.d(d[549])，.sel(sel))；
xtmux4b i550(.xtout(xtout[550])，.a(a[550])，.b(b[550])，.c(c[550])，
.d(d[550])，.sel(sel))；
xtmux4b i551(.xtout(xtout[551])，.a(a[551])，.b(b[551])，.c(c[551])，
.d(d[551])，.sel(sel))；
xtmux4b i552(.xtout(xtout[552])，.a(a[552])，.b(b[552])，.c(c[552])，
.d(d[552])，.sel(sel))；
xtmux4b i553(.xtout(xtout[553])，.a(a[553])，.b(b[553])，.c(c[553])，
.d(d[553])，.sel(sel))；
xtmux4b i554(.xtout(xtout[554])，.a(a[554])，.b(b[554])，.c(c[554])，
.d(d[554])，.sel(sel))；
xtmux4b i555(.xtout(xtout[555])，.a(a[555])，.b(b[555])，.c(c[555])，
.d(d[555])，.sel(sel))；
xtmux4b i556(.xtout(xtout[556])，.a(a[556])，.b(b[556])，.c(c[556])，
.d(d[556])，.sel(sel))；
xtmux4b i557(.xtout(xtout[557])，.a(a[557])，.b(b[557])，.c(c[557])，
.d(d[557])，.sel(sel))；
xtmux4b i558(.xtout(xtout[558])，.a(a[558])，.b(b[558])，.c(c[558])，
.d(d[558])，.sel(sel))；
xtmux4b i559(.xtout(xtout[559])，.a(a[559])，.b(b[559])，.c(c[559])，
.d(d[559])，.sel(sel))；
xtmux4b i560(.xtout(xtout[560])，.a(a[560])，.b(b[560])，.c(c[560])，
.d(d[560])，.sel(sel))；
xtmux4b i561(.xtout(xtout[561])，.a(a[561])，.b(b[561])，.c(c[561])，
.d(d[561])，.sel(sel))；
xtmux4b i562(.xtout(xtout[562])，.a(a[562])，.b(b[562])，.c(c[562])，
.d(d[562])，.sel(sel))；
xtmux4b i563(.xtout(xtout[563])，.a(a[563])，.b(b[563])，.c(c[563])，
.d(d[563])，.sel(sel))；
xtmux4b i564(.xtout(xtout[564])，.a(a[564])，.b(b[564])，.c(c[564])，
.d(d[564])，.sel(sel))；
xtmux4b i565(.xtout(xtout[565])，.a(a[565])，.b(b[565])，.c(c[565])，
.d(d[565])，.sel(sel))；
xtmux4b i566(.xtout(xtout[566])，.a(a[566])，.b(b[566])，.c(c[566])，
.d(d[566])，.sel(sel))；
<dp n="d243"/>
xtmux4b i567(.xtout(xtout[567])，.a(a[567])，.b(b[567])，.c(c[567])，
.d(d[567])，.sel(sel))；
xtmttx4b i568(.xtout(xtout[568])，.a(a[568])，.b(b[568])，.c(c[568])，
.d(d[568])，.sel(sel))；
xtmux4b i569(.xtout(xtout[569])，.a(a[569])，.b(b[569])，.c(c[569])，
.d(d[569])，.sel(sel))；
xtmux4b i570(.xtout(xtout[570])，.a(a[570])，.b(b[570])，.c(c[570])，
.d(d[570])，.sel(sel))；
xtmux4b i571(.xtout(xtout[571])，.a(a[571])，.b(b[571])，.c(c[571])，
.d(d[571])，.sel(sel))；
xtmux4b i572(.xtout(xtout[572])，.a(a[572])，.b(b[572])，.c(c[572])，
.d(d[572])，.sel(sel))；
xtmux4b i573(.xtout(xtout[573])，.a(a[573])，.b(b[573])，.c(c[573])，
.d(d[573])，.sel(sel))；
xtmux4b i574(.xtout(xtout[574])，.a(a[574])，.b(b[574])，.c(c[574])，
.d(d[574])，.sel(sel))；
xtmux4b i575(.xtout(xtout[575])，.a(a[575])，.b(b[575])，.c(c[575])，
.d(d[575])，.sel(sel))；
xtmux4b i576(.xtout(xtout[576])，.a(a[576])，.b(b[576])，.c(c[576])，
.d(d[576]]，.sel(sel))；
xtmux4b i577(.xtout(xtout[577])，.a(a[577])，.b(b[577])，.c(c[577])，
.d(d[577])，.sel(sel))；
xtmux4b i578(.xtout(xtout[578])，.a(a[578])，.b(b[578])，.c(c[578])，
.d(d[578])，.sel(sel))；
xtmux4b i579(.xtout(xtout[579])，.a(a[579])，.b(b[579])，.c(c[579])，
.d(d[579])，.sel(sel))；
xtmux4b i580(.xtout(xtout[580])，.a(a[580])，.b(b[580])，.c(c[580])，
.d(d[580]]，.sel(sel))；
xtmux4b i581(.xtout(xtout[581])，.a(a[581])，.b(b[581])，.c(c[581])，
.d(d[581])，.sel(sel))；
xtmux4b i582(.xtout(xtout[582])，.a(a[582])，.b(b[582])，.c(c[582])，
.d(d[582])，.sel(sel))；
xtmux4b i583(.xtout(xtout[583])，.a(a[583])，.b(b[583])，.c(c[583])，
.d(d[583])，.sel(sel))；
xtmux4b i584(.xtout(xtout[584])，.a(a[584])，.b(b[584])，.c(c[584])，
.d(d[584])，.sel(sel))；
xtmux4b i585(.xtout(xtout[585])，.a(a[585])，.b(b[585])，.c(c[585])，
.d(d[585])，.sel(sel))；
xtmux4b i586(.xtout(xtout[586])，.a(a[586])，.b(b[586])，.c(c[586])，
.d(d[586])，.sel(8el))；
xtmux4b i587(.xtout(xtout[587])，.a(a[587])，.b(b[587])，.c(c[587])，
.d(d[587])，.sel(sel))；
xtmux4b i588(.xtout(xtout[588])，.a(a[588])，.b(b[588])，.c(c[588])，
.d(d[588])，.sel(sel))；
xtmux4b i589(.xtout(xtout[589])，.a(a[589])，.b(b[589])，.c(c[589])，
.d(d[589])，.sel(sel))；
xtmtx4b i590(.xtout(xtout[590])，.a(a[590])，.b(b[590])，.c(c[590])，
.d(d[590])，.sel(sel))；
xtmux4b i591(.xtout(xtout[591])，.a(a[591])，.b(b[591])，.c(c[591])，
.d(d[591])，.sel(sel))；
xtmux4b i592(.xtout(xtout[592])，.a(a[592])，.b(b[592])，.c(c[592])，
.d(d[592])，.sel(sel))；
xtmux4b i593(.xtout(xtout[593])，.a(a[593])，.b(b[593])，.c(c[593])，
.d(d[593])，.sel(sel))；
xtmux4b i594(.xtout(xtout[594])，.a(a[594])，.b(b[594])，.c(c[594])，
.d(d[594])，.sel(sel))；
xtmux4b i595(.xtout(xtout[595])，.a(a[595])，.b(b[595])，.c(c[595])，
.d(d[595])，.sel(sel))；
xtmux4b i596(.xtout(xtout[596])，.a(a[596])，.b(b[596])，.c(c[596])，
.d(d[596])，.sel(sel))；
<dp n="d244"/>
xtmux4b i597(.xtout(xtout[597])，.a(a[597])，.b(b[597])，.c(c[597])，
.d(d[597])，.sel(sel))；
xtmux4b i598(.xtout(xtout[598])，.a(a[598])，.b(b[598])，.c(c[598])，
.d(d[598])，.sel(sel))；
xtmux4b i599(.xtout(xtout[599])，.a(a[599])，.b(b[599])，.c(c[599])，
.d(d[599])，.sel(sel))；
xtmux4b i600(.xtout(xtout[600])，.a(a[600])，.b(b[600])，.c(c[600])，
.d(d[600])，.sel(sel))；
xtmux4b i601(.xtout(xtout[601])，.a(a[601])，.b(b[601])，.c(c[601])，
.d(d[601])，.sel(sel))；
xtmux4b i602(.xtout(xtout[602])，.a(a[602])，.b(b[602])，.c(c[602])，
.d(d[602])，.sel(sel))；
xtmux4b i603(.xtout(xtout[603])，.a(a[603])，.b(b[603])，.c(c[603])，
.d(d[603])，.sel(sel))；
xtmux4b i604(.xtout(xtout[604])，.a(a[604])，.b(b[604])，.c(c[604])，
.d(d[604])，.sel(sel))；
xtmux4b i605(.xtout(xtout[605])，.a(a[605])，.b(b[605])，.c(c[605])，
.d(d[605])，.sel(sel))；
xtmux4b i606(.xtout(xtout[606])，.a(a[606])，.b(b[606])，.c(c[606])，
.d(d[606])，.sel(sel))；
xtmux4b i607(.xtout(xtout[607])，.a(a[607])，.b(b[607])，.c(c[607])，
.d(d[607])，.sel(sel))；
xtmux4b i608(.xtout(xtout[608])，.a(a[608])，.b(b[608])，.c(c[608])，
.d(d[608])，.sel(sel))；
xtmux4b i609(.xtout(xtout[609])，.a(a[609])，.b(b[609])，.c(c[609])，
.d(d[609])，.sel(sel))；
xtmux4b i610(.xtout(xtout[610])，.a(a[610])，.b(b[610])，.c(c[610])，
.d(d[610])，.sel(sel))；
xtmux4b i611(.xtout(xtout[611])，.a(a[611])，.b(b[611])，.c(c[611])，
.d(d[611])，.sel(sel))；
xtmux4b i612(.xtout(xtout[612])，.a(a[612])，.b(b[612])，.c(c[612])，
.d(d[612])，.sel(sel))；
xtmux4b i613(.xtout(xtout[613])，.a(a[613])，.b(b[613])，.c(c[613])，
.d(d[613])，.sel(sel))；
xtmux4b i614(.xtout(xtout[614])，.a(a[614])，.b(b[614])，.c(c[614])，
.d(d[614])，.sel(sel))；
xtmux4b i615(.xtout(xtout[615])，.a(a[615])，.b(b[615])，.c(c[615])，
.d(d[615])，.sel(sel))；
xtmux4b i616(.xtout(xtout[616])，.a(a[616])，.b(b[616])，.c(c[616])，
.d(d[616])，.sel(sel))；
xtmux4b i617(.xtout(xtout[617])，.a(a[617])，.b(b[617])，.c(c[617])，
.d(d[617])，.sel(sel))；
xtmux4b i618(.xtout(xtout[618])，.a(a[618])，.b(b[618])，.c(c[618])，
.d(d[618])，.sel(sel))；
xtmux4b i619(.xtout(xtout[619])，.a(a[619])，.b(b[619])，.c(c[619])，
.d(d[619])，.sel(sel))；
xtmux4b i620(.xtout(xtout[620])，.a(a[620])，.b(b[620])，.c(c[620])，
.d(d[620])，.sel(sel))；
xtmux4b i621(.xtout(xtout[621])，.a(a[621])，.b(b[621])，.c(c[621])，
.d(d[621])，.sel(sel))；
xtmux4b i622(.xtout(xtout[622])，.a(a[622])，.b(b[622])，.c(c[622])，
.d(d[622])，.sel(sel))；
xtmux4b i623(.xtout(xtout[623])，.a(a[623])，.b(b[623])，.c(c[623])，
.d(d[623])，.sel(sel))；
xtmux4b i624(.xtout(xtout[624])，.a(a[624])，.b(b[624])，.c(c[624])，
.d(d[624])，.sel(sel))；
xtmux4b i625(.xtout(xtout[625])，.a(a[625])，.b(b[625])，.c(c[625])，
.d(d[625])，.sel(sel))；
xtmux4b i626(.xtout(xtout[626])，.a(a[626])，.b(b[626])，.c(c[626])，
.d(d[626])，.sel(sel))；
<dp n="d245"/>
xtmux4b i627(.xtout(xtout[627])，.a(a[627])，.b(b[627])，.c(c[627])，
.d(d[627])，.sel(sel))；
xtmux4b i628(.xtout(xtout[628])，.a(a[628])，.b(b[628])，.c(c[628])，
.d(d[628])，.sel(sel))；
xtmux4b i629(.xtout(xtout[629])，.a(a[629])，.b(b[629])，.c(c[629])，
.d(d[629])，.sel(sel))；
xtmux4b i630(.xtout(xtout[630])，.a(a[630])，.b(b[630])，.c(c[630])，
.d(d[630])，.sel(sel))；
xtmux4b i631(.xtout(xtout[631])，.a(a[631])，.b(b[631])，.c(c[631])，
.d(d[631])，.sel(sel))；
xtmux4b i632(.xtout(xtout[632])，.a(a[632])，.b(b[632])，.c(c[632])，
.d(d[632])，.sel(sel))；
xtmux4b i633(.xtot(xtout[633])，.a(a[633])，.b(b[633])，.c(c[633])，
.d(d[633])，.sel(sel))；
xtmux4b i634(.xtout(xtout[634])，.a(a[634])，.b(b[634])，.c(c[634])，
.d(d[634])，.sel(sel))；
xtmux4b i635(.xtout(xtout[635])，.a(a[635])，.b(b[635])，.c(c[635])，
.d(d[635])，.sel(sel))；
xtmux4b i636(.xtout(xtout[636])，.a(a[636])，.b(b[636])，.c(c[636])，
.d(d[636])，.sel(sel))；
xtmux4b i637(.xtout(xtout[637])，.a(a[637])，.b(b[637])，.c(c[637])，
.d(d[637])，.sel(sel))；
xtmux4b i638(.xtout(xtout[638])，.a(a[638])，.b(b[638])，.c(c[638])，
.d(d[638])，.sel(sel))；
xtmux4b i639(.xtout(xtout[639])，.a(a[639])，.b(b[639])，.c(c[639])，
.d(d[639])，.sel(sel))；
xtmux4b i640(.xtout(xtout[640])，.a(a[640])，.b(b[640])，.c(c[640])，
.d(d[640])，.sel(sel))；
xtmux4b i641(.xtout(xtout[641])，.a(a[641])，.b(b[641])，.c(c[641])，
.d(d[641])，.sel(sel))；
xtmux4b i642(.xtout(xtout[642])，.a(a[642])，.b(b[642])，.c(c[642])，
.d(d[642])，.sel(sel))；
xtmux4b i643(.xtout(xtout[643])，.a(a[643])，.b(b[643])，.c(c[643])，
.d(d[643])，.sel(sel))；
xtmux4b i644(.xtout(xtout[644])，.a(a[644])，.b(b[644])，.c(c[644])，
.d(d[644])，.sel(sel))；
xtmux4b i645(.xtout(xtout[645])，.a(a[645])，.b(b[645])，.c(c[645])，
.d(d[645])，.sel(sel))；
xtmux4b i646(.xtout(xtout[646])，.a(a[646])，.b(b[646])，.c(c[646])，
.d(d[646])，.sel(sel))；
xtmux4b i647(.xtout(xtout[647])，.a(a[647])，.b(b[647])，.c(c[647])，
.d(d[647])，.sel(sel))；
xtmux4b i648(.xtout(xtout[648])，.a(a[648])，.b(b[648])，.c(c[648])，
.d(d[648])，.sel(sel))；
xtmux4b i649(.xtout(xtout[649])，.a(a[649])，.b(b[649])，.c(c[649])，
.d(d[649])，.sel(sel))；
xtmux4b i650(.xtout(xtout[650])，.a(a[650])，.b(b[650])，.c(c[650])，
.d(d[650])，.sel(sel))；
xtmux4b i651(.xtout(xtout[651])，.a(a[651])，.b(b[651])，.c(c[651])，
.d(d[651])，.sel(sel))；
xtmux4b i652(.xtout(xtout[652])，.a(a[652])，.b(b[652])，.c[c[652])，
.d(d[652])，.sel(sel))；
xtmux4b i653(.xtout(xtout[653])，.a(a[653])，.b(b[653])，.c(c[653])，
.d(d[653])，.sel(sel))；
xtmux4b i654(.xtout(xtout[654])，.a(a[654])，.b(b[654])，.c(c[654])，
.d(d[654])，.sel(sel))；
xtmux4b i655(.xtout(xtout[655])，.a(a[655])，.b(b[655])，.c(c[655])，
.d(d[655])，.sel(sel))；
xtmux4b i656(.xtout(xtout[656])，.a(a[656])，.b(b[656])，.c(c[656])，
.d(d[656])，.sel(sel))；
<dp n="d246"/>
xtmux4b i657(.xtout(xtout[657])，.a(a[657])，.b(b[657])，.c(c[657])，
.d(d[657])，.sel(sel))；
xtmux4b i658(.xtout(xtout[658])，.a(a[658])，.b(b[658])，.c(c[658])，
.d(d[658])，.sel(sel))；
xtmnx4b i659(.xtout(xtout[659])，.a(a[659])，.b(b[659])，.c(c[659])，
.d(d[659])，.sel(sel))；
xtmux4b i660(.xtout(xtout[660])，.a(a[660])，.b(b[660])，.c(c[660])，
.d(d[660])，.sel(sel))；
xtmux4b i661(.xtout(xtout[661])，.a(a[66l])，.b(b[661])，.c(c[661])，
.d(d[661])，.sel(sel))；
xtmux4b i662(.xtout(xtout[662])，.a(a[662])，.b(b[662])，.c(c[662])，
.d(d[662])，.sel(sel))；
xtmux4b i663(.xtout(xtout[663])，.a(a[663])，.b(b[663])，.c(c[663])，
.d(d[663])，.sel(sel))；
xtmux4b i664(.xtout(xtout[664])，.a(a[664])，.b(b[664])，.c(c[664])，
.d(d[664])，.sel(sel))；
xtmux4b i665(.xtout(xtout[665])，.a(a[665])，.b(b[665])，.c(c[665])，
.d(d[665])，.sel(sel))；
xtmux4b i666(.xtout(xtot[666])，.a(a[666])，.b(b[666])，.c(c[666])，
.d(d[666])，.sel(sel))；
xtmux4b i667(.xtout(xtout[667])，.a(a[667])，.b(b[667])，.c(c[667])，
.d(d[667])，.sel(sel))；
xtmux4b i668(.xtout(xtout[668])，.a(a[668])，.b(b[668])，.c(c[668])，
.d(d[668])，.sel(sel))；
xtmux4b i669(.xtout(xtout[669])，.a(a[669])，.b(b[669])，.c(c[669])，
.d(d[669])，.sel(sel))；
xtmux4b i670(.xtout(xtout[670])，.a(a[670])，.b(b[670])，.c(c[670])，
.d(d[670])，.sel(sel))；
xtmux4b i671(.xtout(xtout[671])，.a(a[671])，.b(b[671])，.c(c[671])，
.d(d[671])，.sel(sel))；
xtmux4b i672(.xtout(xtout[672])，.a(a[672])，.b(b[672])，.c(c[672])，
.d(d[672])，.sel(sel))；
xtmux4b i673(.xtout(xtout[673])，.a(a[673])，.b(b[673])，.c(c[673])，
.d(d[673])，.sel(sel))；
xtmux4b i674(.xtout(xtout[674])，.a(a[674])，.b(b[674])，.c(c[674])，
.d(d[674])，.sel(sel))；
xtmux4b i675(.xtout(xtout[675])，.a(a[675])，.b(b[675])，.c(c[675])，
.d(d[675])，.sel(sel))；
xtmux4b i676(.xtout(xtout[676])，.a(a[676])，.b(b[676])，.c(c[676])，
.d(d[676])，.sel(sel))；
xtmux4b i677(.xtout(xtout[677])，.a(a[677])，.b(b[677])，.c(c[677])，
.d(d[677])，.sel(sel))；
xtmux4b i678(.xtout(xtout[678])，.a(a[678])，.b(b[678])，.c(c[678])，
.d(d[678])，.sel(sel))；
xtmux4b i679(.xtout(xtout[679])，.a(a[679])，.b(b[679])，.c(c[679])，
.d(d[679])，.sel(sel))；
xtmux4b i680(.xtout(xtout[680])，.a(a[680])，.b(b[680])，.c(c[680])，
.d(d[680])，.sel(sel))；
xtmux4b i681(.xtout(xtout[681])，.a(a[681])，.b(b[681])，.c(c[681])，
.d(d[681])，.sel(sel))；
xtmux4b i682(.xtout(xtout[682])，.a(a[682])，.b(b[682])，.c(c[682])，
.d(d[682])，.sel(sel))；
xtmux4b i683(.xtout(xtout[683])，.a(a[683])，.b(b[683])，.c(c[683])，
.d(d[683])，.sel(sel))；
xtmux4b i684(.xtout(xtout[684])，.a(a[684])，.b(b[684])，.c(c[684])，
.d(d[684])，.sel(sel))；
xtmux4b i685(.xtout(xtout[685])，.a(a[685])，.b(b[685])，.c(c[685])，
.d(d[685])，.sel(sel))；
xtmux4b i686(.xtout(xtout[686])，.a(a[686])，.b(b[686])，.c(c[686])，
.d(d[686])，.sel(sel))；
<dp n="d247"/>
xtmux4b i687(.xtout(xtout[687])，.a(a[687])，.b(b[687])，.c(c[687])，
.d(d[687])，.sel(sel))；
xtmux4b i688(.xtout(xtout[688])，.a(a[688])，.b(b[688])，.c(c[688])，
.d(d[688])，.sel(sel))；
xtmux4b i689(.xtout(xtout[689])，.a(a[689])，.b(b[689])，.c(c[689])，
.d(d[689])，.sel(sel))；
xtmux4b i690(.xtout(xtout[690])，.a(a[690])，.b(b[690])，.c(c[690])，
.d(d[690])，.sel(sel))；
xtmux4b i691(.xtout(xtout[691])，.a(a[691])，.b(b[691])，.c(c[691])，
.d(d[691])，.sel(sel))；
xtmux4b i692(.xtout(xtout[692])，.a(a[692])，.b(b[692])，.c(c[692])，
.d(d[692])，.sel(sel))；
xtmux4b i693(.xtout(xtout[693])，.a(a[693])，.b(b[693])，.c(c[693])，
.d(d[693])，.sel(sel))；
xtmux4b i694(.xtout(xtout[694])，.a(a[694])，.b(b[694])，.c(c[694])，
.d(d[694])，.sel(sel))；
xtmux4b i695(.xtout(xtout[695])，.a(a[695])，.b(b[695])，.c(c[695])，
.d(d[695])，.sel(sel))；
xtmux4b i696(.xtout(xtout[696])，.a(a[696])，.b(b[696])，.c(c[696])，
.d(d[696])，.sel(sel))；
xtmux4b i697(.xtout(xtout[697])，.a(a[697])，.b(b[697])，.c(c[697])，
.d(d[697])，.sel(sel))；
xtmux4b i698(.xtout(xtout[698])，.a(a[698])，.b(b[698])，.c(c[698])，
.d(d[698])，.sel(sel))；
xtmux4b i699(.xtout(xtout[699])，.a(a[699])，.b(b[699])，.c(c[699])，
.d(d[699])，.sel(sel))；
xtmux4b i700(.xtout(xtout[700])，.a(a[700])，.b(b[700])，.c(c[700])，
.d(d[700])，.sel(sel))；
xtmux4b i701(.xtout(xtout[701])，.a(a[701])，.b(b[701])，.c(c[701])，
.d(d[701])，.sel(sel))；
xtmux4b i702(.xtout(xtout[702])，.a(a[702])，.b(b[702])，.c(c[702])，
.d(d[702])，.sel(sel))；
xtmux4b i703(.xtout(xtout[703])，.a(a[703])，.b(b[703])，.c(c[703])，
.d(d[703])，.sel(sel))；
xtmux4b i704(.xtout(xtout[704])，.a(a[704])，.b(b[704])，.c(c[704])，
.d(d[704])，.sel(sel))；
xtmux4b i705(.xtout(xtout[705])，.a(a[705])，.b(b[705])，.c(c[705])，
.d(d[705])，.sel(sel))；
xtmux4b i706(.xtout(xtout[706])，.a(a[706])，.b(b[706])，.c(c[706])，
.d(d[706])，.sel(sel))；
xtmux4b i707(.xtout(xtout[707])，.a(a[707])，.b(b[707])，.c(c[707])，
.d(d[707])，.sel(sel))；
xtmux4b i708(.xtout(xtout[708])，.a(a[708])，.b(b[708])，.c(c[708])，
.d(d[708])，.sel(sel))；
xtmux4b i709(.xtout(xtout[709])，.a(a[709])，.b(b[709])，.c(c[709])，
.d(d[709])，.sel(sel))；
xtmux4b i710(.xtout(xtout[710])，.a(a[710])，.b(b[710])，.c(c[710])，
.d(d[710])，.sel(sel))；
xtmux4b i711(.xtout(xtout[711])，.a(a[711])，.b(b[711])，.c(c[711])，
.d(d[711])，.sel(sel))；
xtmux4b i712(.xtout(xtout[712])，.a(a[712])，.b(b[712])，.c(c[712])，
.d(d[712])，.sel(sel))；
xtmux4b i713(.xtout(xtout[713])，.a(a[713])，.b(b[713])，.c(c[713])，
.d(d[713])，.sel(sel))；
xtmux4b i714(.xtout(xtout[714])，.a(a[714])，.b(b[714])，.c(c[714])，
.d(d[714])，.sel(sel))；
xtmux4b i715(.xtout(xtout[715])，.a(a[715])，.b(b[715])，.c(c[715])，
.d(d[715])，.sel(sel))；
xtmux4b i716(.xtout(xtout[716])，.a(a[716])，.b(b[716])，.c(c[716])，
.d(d[716])，.sel(sel))；
<dp n="d248"/>
xtmux4b i717(.xtout(xtout[717])，.a(a[717])，.b(b[717])，.c(c[717])，
.d(d[717])，.sel(sel))；
xtmux4b i718(.xtout(xtout[718])，.a(a[718])，.b(b[718])，.c(c[718])，
.d(d[718])，.sel(sel))；
xtmux4b i719(.xtout(xtout[719])，.a(a[719])，.b(b[719])，.c(c[719])，
.d(d[719])，.sel(sel))；
xtmux4b i720(.xtout(xtout[720])，.a(a[720])，.b(b[720])，.c(c[720])，
.d(d[720])，.sel(sel))；
xtmux4b i721(.xtout(xtout[721])，.a(a[721])，.b(b[721])，.c(c[721])，
.d(d[721])，.sel(sel))；
xtmux4b i722(.xtout(xtout[722])，.a(a[722])，.b(b[722])，.c(c[722])，
.d(d[722])，.sel(sel))；
xtmux4b i723(.xtout(xtout[723])，.a(a[723])，.b(b[723])，.c(c[723])，
.d(d[723])，.sel(sel))；
xtmux4b i724(.xtout(xtout[724])，.a(a[724])，.b(b[724])，.c(c[724])
.d(d[724])，.sel(sel))；
xtmux4b i725(.xtout(xtout[725])，.a(a[725])，.b(b[725])，.c(c[725])，
.d(d[725])，.sel(sel))；
xtmux4b i726(.xtout(xtout[726])，.a(a[726])，.b(b[726])，.c(c[726])，
.d(d[726])，.sel(sel))；
xtmux4b i727(.xtout(xtout[727])，.a(a[727])，.b(b[727])，.c(c[727])，
.d(d[727])，.sel(sel))；
xtmux4b i728(.xtout(xtout[728])，.a(a[728])，.b(b[728])，.c(c[728])，
.d(d[728])，.sel(sel))；
xtmux4b i729(.xtout(xtout[729])，.a(a[729])，.b(b[729])，.c(c[729])，
.d(d[729])，.sel(sel))；
xtmux4b i730(.xtout(xtout[730])，.a(a[730])，.b(b[730])，.c(c[730])，
.d(d[730])，.sel(sel))；
xtmux4b i731(.xtout(xtout[731])，.a(a[731])，.b(b[731])，.c(c[731])，
.d(d [731])，.sel(sel))；
xtmux4b i732(.xtout(xtout[732])，.a(a[732])，.b(b[732])，.c(c[732])，
.d(d[732])，.sel(sel))；
xtmux4b i733(.xtout(xtout[733])，.a(a[733])，.b(b[733])，.c(c[733])，
.d(d[733])，.sel(sel))；
xtmux4b i734(.xtout(xtout[734])，.a(a[734])，.b(b[734])，.c(c[734])，
.d(d[734])，.sel(sel))；
xtmux4b i735(.xtout(xtout[735])，.a(a[735])，.b(b[735])，.c(c[735])，
.d(d[735])，.sel(sel))；
xtmux4b i736(.xtout(xtout[736])，.a(a[736])，.b(b[736])，.c(c[736])，
.d(d[736])，.sel(sel))；
xtmux4b i737(.xtout(xtout[737])，.a(a[737])，.b(b[737])，.c(c[737])，
.d(d[737])，.sel(sel))；
xtmux4b i738(.xtout(xtout[738])，.a(a[738])，.b(b[738])，.c(c[738])，
.d(d[738])，.sel(sel))；
xtmux4b i739(.xtout(xtout[739])，.a(a[739])，.b(b[739])，.c(c[739])，
.d(d[739])，.sel(sel))；
xtmux4b i740(.xtout(xtout[740])，.a(a[740])，.b(b[740])，.c(c[740])，
.d(d[740])，.sel(sel))；
xtmux4b i741(.xtout(xtout[741])，.a(a[741])，.b(b[741])，.c(c[741])，
.d(d[741])，.sel(sel))；
xtmux4b i742(.xtout(xtout[742])，.a(a[742])，.b(b[742])，.c(c[742])，
.d(d[742])，.sel(sel))；
xtmux4b i743(.xtout(xtout[743])，.a(a[743])，.b(b[743])，.c(c[743])，
.d(d[743])，.sel(sel))；
xtmux4b i744(.xtout(xtout[744])，.a(a[744])，.b(b[744])，.c(c[744])，
.d(d[744])，.sel(sel))；
xtmux4b i745(.xtout(xtout[745])，.a(a[745])，.b(b[745])，.c(c[745])，
.d(d[745])，.sel(sel))；
xtmux4b i746(.xtout(xtout[746])，.a(a[746])，.b(b[746])，.c(c[746])，
.d(d[746])，.sel(sel))；
<dp n="d249"/>
xtmux4b i747(.xtout(xtout[747])，.a(a[747])，.b(b[747])，.c(c[747])，
.d(d[747])，.sel(sel))；
xtmux4b i748(.xtout(xtout[748])，.a(a[748])，.b(b[748])，.c(c[748])，
.d(d[748])，.sel(sel))；
xtmux4b i749(.xtout(xtout[749])，.a(a[749])，.b(b[749])，.c(c[749])，
.d(d[749])，.sel(sel))；
xtmux4b i750(.xtout(xtout[750])，.a(a[750])，.b(b[750])，.c(c[750])，
.d(d[750])，.sel(sel))；
xtmux4b i751(.xtout(xtout[751])，.a(a[751])，.b(b[751])，.c(c[751])，
.d(d[751])，.sel(sel))；
xtmux4b i752(.xtout(xtout[752])，.a(a[752])，.b(b[752])，.c(c[752])，
.d(d[752])，.sel(sel))；
xtmux4b i753(.xtout(xtout[753])，.a(a[753])，.b(b[753])，.c(c[753])，
.d(d[753])，.sel(sel))；
xtmux4b i754(.xtout(xtout[754])，.a(a[754])，.b(b[754])，.c(c[754])，
.d(d[754])，.sel(sel))；
xtmux4b i755(.xtout(xtout[755])，.a(a[755])，.b(b[755])，.c(c[755])，
.d(d[755])，.sel(sel))；
xtmux4b i756(.xtout(xtout[756])，.a(a[756])，.b(b[756])，.c(c[756])，
.d(d[756])，.sel(sel))；
xtmux4b i757(.xtout(xtout[757])，.a(a[757])，.b(b[757])，.c(c[757])，
.d(d[757])，.sel(sel))；
xtmux4b i758(.xtout(xtout[758])，.a(a[758])，.b(b[758])，.c(c[758])，
.d(d[758])，.sel(sel))；
xtmux4b i759(.xtout(xtout[759])，.a(a[759])，.b(b[759])，.c(c[759])，
.d(d[759])，.sel(sel))；
xtmux4b i760(.xtout(xtout[760])，.a(a[760])，.b(b[760])，.c(c[760])，
.d(d[760])，.sel(sel))；
xtmux4b i761(.xtout(xtout[761])，.a(a[761])，.b(b[761])，.c(c[761])，
.d(d[761])，.sel(sel))；
xtmux4b i762(.xtout(xtout[762])，.a(a[762])，.b(b[762])，.c(c[762])，
.d(d[762])，.sel(sel))；
xtmux4b i763(.xtout(xtout[763])，.a(a[763])，.b(b[763])，.c(c[763])，
.d(d[763])，.sel(sel))；
xtmux4b i764(.xtout(xtout[764])，.a(a[764])，.b(b[764])，.c(c[764])，
.d(d[764])，.sel(sel))；
xtmux4b i765(.xtout(xtout[765])，.a(a[765])，.b(b[765])，.c(c[765])，
.d(d[765])，.sel(sel))；
xtmux4b i766(.xtout(xtout[766])，.a(a[766])，.b(b[766])，.c(c[766])，
.d(d[766])，.sel(sel))；
xtmux4b i767(.xtout(xtout[767])，.a(a[767])，.b(b[767])，.c(c[767])，
.d(d[767])，.sel(sel))；
xtmux4b i768(.xtout(xtout[768])，.a(a[768])，.b(b[768])，.c(c[768])，
.d(d[768])，.sel(sel))；
xtmux4b i769(.xtout(xtout[769])，.a(a[769])，.b(b[769])，.c(c[769])，
.d(d[769])，.sel(sel))；
xtmux4b i770(.xtout(xtout[770])，.a(a[770])，.b(b[770])，.c(c[770])，
.d(d[770])，.sel(sel))；
xtmux4b i771(.xtout(xtout[771])，.a(a[771])，.b(b[771])，.c(c[771])，
.d(d[771])，.sel(sel))；
xtmux4b i772(.xtout(xtout[772])，.a(a[772])，.b(b[772])，.c(c[772])，
.d(d[772])，.sel(sel))；
xtmux4b i773(.xtout(xtout[773])，.a(a[773])，.b(b[773])，.c(c[773])，
.d(d[773])，.sel(sel))；
xtmux4b i774(.xtout(xtout[774])，.a(a[774])，.b(b[774])，.c(c[774])，
.d(d[774])，.sel(sel))；
xtmux4b i775(.xtout(xtout[775])，.a(a[775])，.b(b[775])，.c(c[775])，
.d(d[775])，.sel(sel))；
xtmux4b i776(.xtout(xtout[776])，.a(a[776])，.b(b[776])，.c(c[776])，
.d(d[776])，.sel(sel))；
<dp n="d250"/>
xtmux4b i777(.xtout(xtout[777])，.a(a[777])，.b(b[777])，.c(c[777])，
.d(d[777])，.sel(sel))；
xtmux4b i778(.xtout(xtout[778])，.a(a[778])，.b(b[778])，.c(c[778])，
.d(d[778])，.sel(sel))；
xtmux4b i779(.xtout(xtout[779])，.a(a[779])，.b(b[779])，.c(c[779])，
.d(d[779])，.sel(sel))；
xtmux4b i780(.xtout(xtout[780])，.a(a[780])，.b(b[780])，.c(c[780])，
.d(d[780])，.sel(sel))；
xtmux4b i781(.xtout(xtout[781])，.a(a[781])，.b(b[781])，.c(c[781])，
.d(d[781])，.sel(sel))；
xtmux4b i782(.xtout(xtout[782])，.a(a[782])，.b(b[782])，.c(c[782])，
.d(d[782])，.sel(sel))；
xtmux4b i783(.xtout(xtout[783])，.a(a[783])，.b(b[783])，.c(c[783])，
.d(d[783])，.sel(sel))；
xtmux4b i784(.xtout(xtout[784])，.a(a[784])，.b(b[784])，.c(c[784])，
.d(d[784])，.sel(sel))；
xtmux4b i785(.xtout(xtout[785])，.a(a[785])，.b(b[785])，.c(c[785])，
.d(d[785])，.sel(sel))；
xtmux4b i786(.xtout(xtout[786])，.a(a[786])，.b(b[786])，.c(c[786])，
.d(d[786])，.sel(sel))；
xtmux4b i787(.xtout(xtout[787])，.a(a[787])，.b(b[787])，.c(c[787])，
.d(d[787])，.sel(sel))；
xtmux4b i788(.xtout(xtout[788])，.a(a[788])，.b(b[788])，.c(c[788])，
.d(d[788])，.sel(sel))；
xtmux4b i789(.xtout(xtout[789])，.a(a[789])，.b(b[789])，.c(c[789])，
.d(d[789])，.sel(sel))；
xtmux4b i790(.xtout(xtout[790])，.a(a[790])，.b(b[790])，.c(c[790])，
.d(d[790])，.sel(sel))；
xtmux4b i791(.xtout(xtout[791])，.a(a[791])，.b(b[791])，.c(c[791])，
.d(d[791])，.sel(sel))；
xtmux4b i792(.xtout(xtout[792])，.a(a[792])，.b(b[792])，.c(c[792])，
.d(d[792])，.sel(sel))；
xtmux4b i793(.xtout(xtout[793])，.a(a[793])，.b(b[793])，.c(c[793])，
.d(d[793])，.sel(sel))；
xtmux4b i794(.xtout(xtout[794])，.a(a[794])，.b(b[794])，.c(c[794])，
.d(d[794])，.sel(sel))；
xtmux4b i795(.xtout(xtout[795])，.a(a[795])，.b(b[795])，.c(c[795])，
.d(d[795])，.sel(sel))；
xtmux4b i796(.xtout(xtout[796])，.a(a[796])，.b(b[796])，.c(c[796])，
.d(d[796])，.sel(sel))；
xtmux4b i797(.xtout(xtout[797])，.a(a[797])，.b(b[797])，.c(c[797])，
.d(d[797])，.sel(sel))；
xtmux4b i798(.xtout(xtout[798])，.a(a[798])，.b(b[798])，.c(c[798])，
.d(d[798])，.sel(sel))；
xtmux4b i799(.xtout(xtout[799])，.a(a[799])，.b(b[799])，.c(c[799])，
.d(d[799])，.sel(sel))；
xtmux4b i800(.xtout(xtout[800])，.a(a[800])，.b(b[800])，.c(c[800])，
.d(d[800])，.sel(sel))；
xtmux4b i801(.xtout(xtout[801])，.a(a[801])，.b(b[801])，.c(c[801])，
.d(d[801])，.sel(sel))；
xtmux4b i802(.xtout(xtout[802])，.a(a[802])，.b(b[802])，.c(c[802])，
.d(d[802])，.sel(sel))；
xtmux4b i803(.xtout(xtout[803])，.a(a[803])，.b(b[803])，.c(c[803])，
.d(d[803])，.sel(sel))；
xtmux4b i804(.xtout(xtout[804])，.a(a[804])，.b(b[804])，.c(c[804])，
.d(d[804])，.sel(sel))；
xtmux4b i805(.xtout(xtout[805])，.a(a[805])，.b(b[805])，.c(c[805])，
.d(d[805])，.sel(sel))；
xtmux4b i806(.xtout(xtout[806])，.a(a[806])，.b(b[806])，.c(c[806])，
.d(d[806])，.sel(sel))；
<dp n="d251"/>
xtmux4b i807(.xtout(xtout[807])，.a(a[807])，.b(b[807])，.c(c[807])，
.d(d[807])，.sel(sel))；
xtmux4b i808(.xtout(xtout[808])，.a(a[808])，.b(b[808])，.c(c[808])，
.d(d[808])，.sel(sel))；
xtmux4b i809(.xtout(xtout[809])，.a(a[809])，.b(b[809])，.c(c[809])，
.d(d[809])，.sel(sel))；
xtmux4b i810(.xtout(xtout[810])，.a(a[810])，.b(b[810])，.c(c[810])，
.d(d[810])，.sel(sel))；
xtmux4b i811(.xtout(xtout[811])，.a(a[811])，.b(b[811])，.c(c[811])，
.d(d[811])，.sel(sel))；
xtmux4b i812(.xtout(xtout[812])，.a(a[812])，.b(b[812])，.c(c[812])，
.d(d[812])，.sel(sel))；
xtmux4b i813(.xtout(xtout[813])，.a(a[813])，.b(b[813])，.c(c[813])，
.d(d[813])，.sel(sel))；
xtmux4b i814(.xtout(xtout[814])，.a(a[814])，.b(b[814])，.c(c[814])，
.d(d[814])，.sel(sel))；
xtmux4b i815(.xtout(xtout[815])，.a(a[815])，.b(b[815])，.c(c[815])，
.d(d[815])，.sel(sel))；
xtmux4b i816(.xtout(xtout[816])，.a(a[816])，.b(b[816])，.c(c[816])，
.d(d[816])，.sel(sel))；
xtmux4b i817(.xtout(xtout[817])，.a(a[817])，.b(b[817])，.c(c[817])，
.d(d[817])，.sel(sel))；
xtmux4b i818(.xtout(xtout[818])，.a(a[818])，.b(b[818])，.c(c[818])，
.d(d[818])，.sel(sel))；
xtmux4b i819(.xtout(xtout[819])，.a(a[819])，.b(b[819])，.c(c[819])，
.d(d[819])，.sel(sel))；
xtmux4b i820(.xtout(xtout[820])，.a(a[820])，.b(b[820])，.c(c[820])，
.d(d[820])，.sel(sel))；
xtmux4b i821(.xtout(xtout[821])，.a(a[821])，.b(b[821])，.c(c[821])，
.d(d[821])，.sel(sel))；
xtmux4b i822(.xtout(xtout[822])，.a(a[822])，.b(b[822])，.c(c[822])，
.d(d[822])，.sel(sel))；
xtmux4b i823(.xtout(xtout[823])，.a(a[823])，.b(b[823])，.c(c[823])，
.d(d[823])，.sel(sel))；
xtmux4b i824(.xtout(xtout[824])，.a(a[824])，.b(b[824])，.c(c[824])，
.d(d[824])，.sel(sel))；
xtmux4b i825(.xtout(xtout[825])，.a(a[825])，.b(b[825])，.c(c[825])，
.d(d[825])，.sel(sel))；
xtmux4b i826(.xtout(xtout[826])，.a(a[826])，.b(b[826])，.c(c[826])，
.d(d[826])，.sel(sel))；
xtmux4b i827(.xtout(xtout[827])，.a(a[827])，.b(b[827])，.c(c[827])，
.d(d[827])，.sel(sel))；
xtmux4b i828(.xtout(xtout[828])，.a(a[828])，.b(b[828])，.c(c[828])，
.d(d[828])，.sel(sel))；
xtmux4b i829(.xtout(xtout[829])，.a(a[829])，.b(b[829])，.c(c[829])，
.d(d[829])，.sel(sel))；
xtmux4b i830(.xtout(xtout[830])，.a(a[830])，.b(b[830])，.c(c[830])，
.d(d[830])，.sel(sel))；
xtmux4b i831(.xtout(xtout[831])，.a(a[831])，.b(b[831])，.c(c[831])，
.d(d[831])，.sel(sel))；
xtmux4b i832(.xtout(xtout[832])，.a(a[832])，.b(b[832])，.c(c[832])，
.d(d[832])，.sel(sel))；
xtmux4b i833(.xtout(xtout[833])，.a(a[833])，.b(b[833])，.c(c[833])，
.d(d[833])，.sel(sel))；
xtmux4b i834(.xtout(xtout[834])，.a(a[834])，.b(b[834])，.c(c[834])，
.d(d[834])，.sel(sel))；
xtmux4b i835(.xtout(xtout[835])，.a(a[835])，.b(b[835])，.c(c[835])，
.d(d[835])，.sel(sel))；
xtmux4b i836(.xtout(xtout[836])，.a(a[836])，.b(b[836])，.c(c[836])，
.d(d[836])，.sel(sel))；
<dp n="d252"/>
xtmux4b i867(.xtout(xtout[867])，.a(a[867])，.b(b[867])，.c(c[867])，
.d(d[867])，.sel(sel))；
xtmux4b i868(.xtout(xtout[868])，.a(a[868])，.b(b[868])，.c(c[868])，
.d(d[868])，.sel(sel))；
xtmux4b i869(.xtout(xtout[869])，.a(a[869])，.b(b[869])，.c(c[869])，
.d(d[869])，.sel(sel))；
xtmudx4b i870(.xtout(xtout[870])，.a(a[870])，.b(b[870])，.c(c[870])，
.d(d[870])，.sel(sel))；
xtmux4b i871(.xtout(xtout[871])，.a(a[871])，.b(b[871])，.c(c[871])，
.d(d[871])，.sel(sel))；
xtmux4b i872(.xtout(xtout[872])，.a(a[872])，.b(b[872])，.c(c[872])，
.d(d[872])，.sel(sel))；
xtmux4b i873(.xtout(xtout[873])，.a(a[873])，.b(b[873])，.c(c[873])，
.d(d[873])，.sel(sel))；
xtmux4b i874(.xtout(xtout[874])，.a(a[874])，.b(b[874])，.c(c[874])，
.d(d[874])，.sel(sel))；
xtmux4b i875(.xtout(xtout[875])，.a(a[875])，.b(b[875])，.c(c[875])，
.d(d[875])，.sel(sel))；
xtmux4b i876(.xtout(xtout[876])，.a(a[876])，.b(b[876])，.c(c[876])，
.d(d[876])，.sel(sel))；
xtmux4b i877(.xtout(xtout[877])，.a(a[877])，.b(b[877])，.c(c[877])，
.d(d[877])，.sel(sel))；
xtmux4b i878(.xtout(xtout[878])，.a(a[878])，.b(b[878])，.c(c[878])，
.d(d[878])，.sel(sel))；
xtmux4b i879(.xtout(xtout[879])，.a(a[879])，.b(b[879])，.c(c[879])，
.d(d[879])，.sel(sel))；
xtmux4b i880(.xtout(xtout[880])，.a(a[880])，.b(b[880])，.c(c[880])，
.d(d[880])，.sel(sel))；
xtmux4b i881(.xtout(xtout[881])，.a(a[881])，.b(b[881])，.c(c[881])，
.d(d[881])，.sel(sel))；
xtmux4b i882(.xtout(xtout[882])，.a(a[882])，.b(b[882])，.c(c[882])，
.d(d[882])，.sel(sel))；
xtmux4b i883(.xtout(xtout[883])，.a(a[883])，.b(b[883])，.c(c[883])，
.d(d[883])，.sel(sel))；
xtmux4b i884(.xtout(xtout[884])，.a(a[884])，.b(b[884])，.c(c[884])，
.d(d[884])，.sel(sel))；
xtmux4b i885(.xtout(xtout[885])，.a(a[885])，.b(b[885])，.c(c[885])，
.d(d[885])，.sel(sel))；
xtmux4b i886(.xtout(xtout[886])，.a(a[886])，.b(b[886])，.c(c[886])，
.d(d[886])，.sel(sel))；
xtmux4b i887(.xtout(xtout[887])，.a(a[887])，.b(b[887])，.c(c[887])，
.d(d[887])，.sel(sel))；
xtmux4b i888(.xtout(xtout[888])，.a(a[888])，.b(b[888])，.c(c[888])，
.d(d[888])，.sel(sel))；
xtmux4b i889(.xtout(xtout[889])，.a(a[889])，.b(b[889])，.c(c[889])，
.d(d[889])，.sel(sel))；
xtmux4b i890(.xtout(xtout[890])，.a(a[890])，.b(b[890])，.c(c[890])，
.d(d[890])，.sel(sel))；
xtmux4b i891(.xtout(xtout[891])，.a(a[891])，.b(b[891])，.c(c[891])，
.d(d[891])，.sel(sel))；
xtmux4b i892(.xtout(xtout[892])，.a(a[892])，.b(b[892])，.c(c[892])，
.d(d[892])，.sel(sel))；
xtmux4b i893(.xtout(xtout[893])，.a(a[893])，.b(b[893])，.c(c[893])，
.d(d[893])，.sel(sel))；
xtmux4b i894(.xtout(xtout[894])，.a(a[894])，.b(b[894])，.c(c[894])，
.d(d[894])，.sel(sel))；
xtmux4b i895(.xtout(xtout[895])，.a(a[895])，.b(b[895])，.c(c[895])，
.d(d[895])，.sel(sel))；
xtmux4b i896(.xtout(xtout[896])，.a(a[896])，.b(b[896])，.c(c[896])，
.d(d[896])，.sel(sel))；
<dp n="d253"/>
xtmux4b i837(.xtout(xtout[837])，.a(a[837])，.b(b[837])，.c(c[837])，
.d(d[837])，.sel(sel))；
xtmux4b i838(.xtout(xtout[838])，.a(a[838])，.b(b[838])，.c(c[838])，
.d(d[838])，.sel(sel))；
xtmux4b i839(.xtout(xtout[839])，.a(a[839])，.b(b[839])，.c(c[839])，
.d(d[839])，.sel(sel))；
xtmux4b i840(.xtout(xtout[840])，.a(a[840])，.b(b[840])，.c(c[840])，
.d(d[840])，.sel(sel))；
xtmux4b i841(.xtout(xtout[841])，.a(a[841])，.b(b[841])，.c(c[841])，
.d(d[841])，.sel(sel))；
xtmux4b i842(.xtout(xtout[842])，.a(a[842])，.b(b[842])，.c(c[842])，
.d(d[842])，.sel(sel))；
xtmux4b i843(.xtout(xtout[843])，.a(a[843])，.b(b[843])，.c(c[843])，
.d(d[843])，.sel(sel))；
xtmux4b i844(.xtout(xtout[844])，.a(a[844])，.b(b[844])，.c(c[844])，
.d(d[844])，.sel(sel))；
xtmux4b i845(.xtout(xtout[845])，.a(a[845])，.b(b[845])，.c(c[845])，
.d(d[845])，.sel(sel))；
xtmux4b i846(.xtout(xtout[846])，.a(a[846])，.b(b[846])，.c(c[846])，
.d(d[846])，.sel(sel))；
xtmux4b i847(.xtout(xtout[847])，.a(a[847])，.b(b[847])，.c(c[847])，
.d(d[847])，.sel(sel))；
xtmux4b i848(.xtout(xtout[848])，.a(a[848])，.b(b[848])，.c(c[848])，
.d(d[848])，.sel(sel))；
xtmux4b i849(.xtout(xtout[849])，.a(a[849])，.b(b[849])，.c(c[849])，
.d(d[849])，.sel(sel))；
xtmux4b i850(.xtout(xtout[850])，.a(a[850])，.b(b[850])，.c(c[850])，
.d(d[850])，.sel(sel))；
xtmux4b i851(.xtout(xtout[851])，.a(a[851])，.b(b[851])，.c(c[851])，
.d(d[851])，.sel(sel))；
xtmux4b i852(.xtout(xtout[852])，.a(a[852])，.b(b[852])，.c(c[852])，
.d(d[852])，.sel(sel))；
xtmux4b i853(.xtout(xtout[853])，.a(a[853])，.b(b[853])，.c(c[853])，
.d(d[853])，.sel(sel))；
xtmux4b i854(.xtout(xtout[854])，.a(a[854])，.b(b[854])，.c(c[854])，
.d(d[854])，.sel(sel))；
xtmux4b i855(.xtout(xtout[855])，.a(a[855])，.b(b[855])，.c(c[855])，
.d(d[855])，.sel(sel))；
xtmux4b i856(.xtout(xtout[856])，.a(a[856])，.b(b[856])，.c(c[856])，
.d(d[856])，.sel(sel))；
xtmux4b i857(.xtout(xtout[857])，.a(a[857])，.b(b[857])，.c(c[857])，
.d(d[857])，.sel(sel))；
xtmux4b i858(.xtout(xtout[858])，.a(a[858])，.b(b[858])，.c(c[858])，
.d(d[858])，.sel(sel))；
xtmux4b i859(.xtout(xtout[859])，.a(a[859])，.b(b[859])，.c(c[859])，
.d(d[859])，.sel(sel))；
xtmux4b i860(.xtout(xtout[860])，.a(a[860])，.b(b[860])，.c(c[860])，
.d(d[860])，.sel(sel))；
xtmux4b i861(.xtout(xtout[861])，.a(a[861])，.b(b[861])，.c(c[861])，
.d(d[861])，.sel(sel))；
xtmux4b i862(.xtout(xtout[862])，.a(a[862])，.b(b[862])，.c(c[862])，
.d(d[862])，.sel(sel))；
xtmux4b i863(.xtout(xtout[863])，.a(a[863])，.b(b[863])，.c(c[863])，
.d(d[863])，.sel(sel))；
xtmux4b i864(.xtout(xtout[864])，.a(a[864])，.b(b[864])，.c(c[864])，
.d(d[864])，.sel(sel))；
xtmux4b i865(.xtout(xtout[865])，.a(a[865])，.b(b[865])，.c(c[865])，
.d(d[865])，.sel(sel))；
xtmux4b i866(.xtout(xtout[866])，.a(a[866])，.b(b[866])，.c(c[866])，
.d(d[866])，.sel(sel))；
<dp n="d254"/>
xtmux4b i897(.xtot(xtout[897])，.a(a[897])，.b(b[897])，.c(c[897])，
.d(d[897])，.sel(sel))；
xtmux4b i898(.xtout(xtout[898])，.a(a[898])，.b(b[898])，.c(c[898])，
.d(d[898])，.sel(sel))；
xtmux4b i899(.xtout(xtout[899])，.a(a[899])，.b(b[899])，.c(c[899])，
.d(d[899])，.sel(sel))；
xtmux4b i900(.xtout(xtout[900])，.a(a[900])，.b(b[900])，.c(c[900])，
.d(d[900])，.sel(sel))；
xtmux4b i901(.xtout(xtout[901])，.a(a[901])，.b(b[901])，.c(c[901])，
.d(d[901])，.sel(sel))；
xtmux4b i902(.xtout(xtout[902])，.a(a[902])，.b(b[902])，.c(c[902])，
.d(d[902])，.sel(sel))；
xtmux4b i903(.xtout(xtout[903])，.a(a[903])，.b(b[903])，.c(c[903])，
.d(d[903])，.sel(sel))；
xtmux4b i904(.xtout(xtout[904])，.a(a[904])，.b(b[904])，.c(c[904])，
.d(d[904])，.sel(sel))；
xtmux4b i905(.xtout(xtout[905])，.a(a[905])，.b(b[905])，.c(c[905])，
.d(d[905])，.sel(sel))；
xtmux4b i906(.xtout(xtout[906])，.a(a[906])，.b(b[906])，.c(c[906])，
.d(d[906])，.sel(sel))；
xtmux4b i907(.xtout(xtout[907])，.a(a[907])，.b(b[907])，.c(c[907])，
.d(d[907])，.sel(sel))；
xtmux4b i908(.xtout(xtout[908])，.a(a[908])，.b(b[908])，.c(c[908])，
.d(d[908])，.sel(sel))；
xtmux4b i909(.xtout(xtout[909])，.a(a[909])，.b(b[909])，.c(c[909])，
.d(d[909])，.sel(sel))；
xtmux4b i910(.xtout(xtout[910])，.a(a[910])，.b(b[910])，.c(c[910])，
.d(d[910])，.sel(sel))；
xtmux4b i911(.xtout(xtout[911])，.a(a[911])，.b(b[911])，.c(c[911])，
.d(d[911])，.sel(sel))；
xtmux4b i912(.xtout(xtout[912])，.a(a[912])，.b(b[912])，.c(c[912])，
.d(d[912])，.sel(sel))；
xtmux4b i913(.xtout(xtout[913])，.a(a[913])，.b(b[913])，.c(c[913])，
.d(d[913])，.sel(sel))；
xtmux4b i914(.xtout(xtout[914])，.a(a[914])，.b(b[914])，.c(c[914])，
.d(d[914])，.sel(sel))；
xtmux4b i915(.xtout(xtout[915])，.a(a[915])，.b(b[915])，.c(c[915])，
.d(d[915])，.sel(sel))；
xtmux4b i916(.xtout(xtout[916])，.a(a[916])，.b(b[916])，.c(c[916])，
.d(d[916])，.sel(sel))；
xtmux4b i917(.xtout(xtout[917])，.a(a[917])，.b(b[917])，.c(c[917])，
.d(d[917])，.sel(sel))；
xtmux4b i918(.xtout(xtout[918])，.a(a[918])，.b(b[918])，.c(c[918])，
.d(d[918])，.sel(sel))；
xtmux4b i919(.xtout(xtout[919])，.a(a[919])，.b(b[919])，.c(c[919])，
.d(d[919])，.sel(sel))；
xtmux4b i920(.xtout(xtout[920])，.a(a[920])，.b(b[920])，.c(c[920])，
.d(d[920])，.sel(sel))；
xtmux4b i92l(.xtout(xtout[921])，.a(a[921])，.b(b[921])，.c(c[921])，
.d(d[921])，.sel(sel))；
xtmux4b i922(.xtout(xtout[922])，.a(a[922])，.b(b[922])，.c(c[922])，
.d(d[922])，.sel(sel))；
xtmux4b i923(.xtout(xtout[923])，.a(a[923])，.b(b[923])，.c(c[923])，
.d(d[923])，.sel(sel))；
xtmux4b i924(.xtout(xtout[924])，.a(a[924])，.b(b[924])，.c(c[924])，
.d(d[924])，.sel(sel))；
xtmux4b i925(.xtout(xtout[925])，.a(a[925])，.b(b[925])，.c(c[925])，
.d(d[925])，.sel(sel))；
xtmux4b i926(.xtout(xtout[926])，.a(a[926])，.b(b[926])，.c(c[926])，
.d(d[926])，.sel(sel))；
<dp n="d255"/>
xtmux4b i927(.xtout(xtout[927])，.a(a[927])，.b(b[927])，.c(c[927])，
.d(d[927])，.sel(sel))；
xtmux4b i928(.xtout(xtout[928])，.a(a[928])，.b(b[928])，.c(c[928])，
.d(d[928])，.sel(sel))；
xtmux4b i929(.xtout(xtout[929])，.a(a[929])，.b(b[929])，.c(c[929])，
.d(d[929])，.sel(sel))；
xtmux4b i930(.xtout(xtout[930])，.a(a[930])，.b(b[930])，.c(c[930])，
.d(d[930])，.sel(sel))；
xtmux4b i931(.xtot(xtout[931])，.a(a[931])，.b(b[931])，.c(c[931])，
.d(d[931])，.sel(sel))；
xtmux4b i932(.xtout(xtout[932])，.a(a[932])，.b(b[932])，.c(c[932])，
.d(d[932])，.sel(sel))；
xtmux4b i933(.xtout(xtout[933])，.a(a[933])，.b(b[933])，.c(c[933])，
.d(d[933])，.sel(sel))；
xtmux4b i934(.xtout(xtout[934])，.a(a[934])，.b(b[934])，.c(c[934])，
.d(d[934])，.sel(sel))；
xtmux4b i935(.xtout(xtout[935])，.a(a[935])，.b(b[935])，.c(c[935])，
.d(d[935])，.sel(sel))；
xtmux4b i936(.xtout(xtout[936])，.a(a[936])，.b(b[936])，.c(c[936])，
.d(d[936])，.sel(sel))；
xtmux4b i937(.xtout(xtout[937])，.a(a[937])，.b(b[937])，.c(c[937])，
.d(d[937])，.sel(sel))；
xtmux4b i938(.xtout(xtout[938])，.a(a[938])，.b(b[938])，.c(c[938])，
.d(d[938])，.sel(sel))；
xtmux4b i939(.xtout(xtout[939])，.a(a[939])，.b(b[939])，.c(c[939])，
.d(d[939])，.sel(sel))；
xtmux4b i940(.xtout(xtout[940])，.a(a[940])，.b(b[940])，.c(c[940])，
.d(d[940])，.sel(sel))；
xtmux4b i941(.xtot(xtout[941])，.a(a[941])，.b(b[941])，.c(c[941])，
.d(d[941])，.sel(sel))；
xtmux4b i942(.xtout(xtout[942])，.a(a[942])，.b(b[942])，.c(c[942])，
.d(d[942])，.sel(sel))；
xtmux4b i943(.xtout(xtout[943])，.a(a[943])，.b(b[943])，.c(c[943])，
.d(d[943])，.sel(sel))；
xtmux4b i944(.xtout(xtout[944])，.a(a[944])，.b(b[944])，.c(c[944])，
.d(d[944])，.sel(sel))；
xtmux4b i945(.xtout(xtout[945])，.a(a[945])，.b(b[945])，.c(c[945])，
.d(d[945])，.sel(sel])；
xtmux4b i946(.xtout(xtout[946])，.a(a[946])，.b(b[946])，.c(c[946])，
.d(d[946])，.sel(sel))；
xtmux4b i947(.xtout(xtout[947])，.a(a[947])，.b(b[947])，.c(c[947])，
.d(d[947])，.sel(sel))；
xtmux4b i948(.xtout(xtout[948])，.a(a[948])，.b(b[948])，.c(c[948])，
.d(d[948])，.sel(sel))；
xtmux4b i949(.xtout(xtout[949])，.a(a[949])，.b(b[949])，.c(c[949])，
.d(d[949])，.sel(sel))；
xtmux4b i950(.xtout(xtout[950])，.a(a[950])，.b(b[950])，.c(c[950])，
.d(d[950])，.sel(sel))；
xtmux4b i951(.xtout(xtout[951])，.a(a[951])，.b(b[951])，.c(c[951])，
.d(d[951])，.sel(sel))；
xtmux4b i952(.xtout(xtout[952])，.a(a[952])，.b(b[952])，.c(c[952])，
.d(d[952])，.sel(sel))；
xtmux4b i953(.xtout(xtout[953])，.a(a[953])，.b(b[953])，.c(c[953])，
.d(d[953])，.sel(sel))；
xtmux4b i954(.xtout(xtout[954])，.a(a[954])，.b(b[954])，.c(c[954])，
.d(d[954])，.sel(sel))；
xtmux4b i955(.xtout(xtout[955])，.a(a[955])，.b(b[955])，.c(c[955])，
.d(d[955])，.sel(sel))；
xtmux4b i956(.xtout(xtout[956])，.a(a[956])，.b(b[956])，.c(c[956])，
.d(d[956])，.sel(sel))；
<dp n="d256"/>
xtmux4b i957(.xtout(xtout[957])，.a(a[957])，.b(b[957])，.c(c[957])，
.d(d[957])，.sel(sel))；
xtmux4b i958(.xtout(xtout[958])，.a(a[958])，.b(b[958])，.c(c[958])，
.d(d[958])，.sel(sel))；
xtmux4b i959(.xtout(xtout[959])，.a(a[959])，.b(b[959])，.c(c[959])，
.d(d[959])，.sel(sel))；
xtmux4b i960(.xtout(xtout[960])，.a(a[960])，.b(b[960])，.c(c[960])，
.d(d[960])，.sel(sel))；
xtmux4b i961(.xtout(xtout[961])，.a(a[961])，.b(b[961])，.c(c[961])，
.d(d[961])，.sel(sel))；
xtmux4b i962(.xtout(xtout[962])，.a(a[962])，.b(b[962])，.c(c[962])，
.d(d[962])，.se1(sel))；
xtmux4b i963(.xtout(xtout[963])，.a(a[963])，.b(b[963])，.c(c[963])，
.d(d[963])，.sel(sel))；
xtmux4b i964(.xtout(xtout[964])，.a(a[964])，.b(b[964])，.c(c[964])，
.d(d[964])，.sel(sel))；
xtmux4b i965(.xtout(xtout[965])，.a(a[965])，.b(b[965])，.c(c[965])，
.d(d[965])，.sel(sel))；
xtmux4b i966(.xtout(xtout[966])，.a(a[966])，.b(b[966])，.c(c[966])，
.d(d[966])，.sel(sel))；
xtmux4b i967(.xtout(xtout[967])，.a(a[967])，.b(b[967])，.c(c[967])，
.d(d[967])，.sel(se1))；
xtmux4b i968(.xtout(xtout[968])，.a(a[968])，.b(b[968])，.c(c[968])，
.d(d[968])，.sel(sel))；
xtmux4b i969(.xtout(xtout[969])，.a(a[969])，.b(b[969])，.c(c[969])，
.d(d[969])，.sel(sel))；
xtmux4b i970(.xtout(xtout[970])，.a(a[970])，.b(b[970])，.c(c[970])，
.d(d[970])，.sel(sel))；
xtmux4b i971(.xtout(xtout[971])，.a(a[971])，.b(b[971])，.c(c[971])，
.d(d[971])，.sel(sel))；
xtmux4b i972(.xtout(xtout[972])，.a(a[972])，.b(b[972])，.c(c[972])，
.d(d[972])，.sel(sel))；
xtmux4b i973(.xtout(xtout[973])，.a(a[973])，.b(b[973])，.c(c[973])，
.d(d[973])，.sel(sel))；
xtmux4b i974(.xtout(xtout[974])，.a(a[974])，.b(b[974])，.c(c[974])，
.d(d[974])，.sel(sel))；
xtmux4b i975(.xtout(xtout[975])，.a(a[975])，.b(b[975])，.c(c[975])，
.d(d[975])，.sel(sel))；
xtmux4b i976(.xtout(xtout[976])，.a(a[976])，.b(b[976])，.c(c[976])，
.d(d[976])，.sel(sel))；
xtmux4b i977(.xtout(xtout[977])，.a(a[977])，.b(b[977])，.c(c[977])，
.d(d[977])，.sel(sel))；
xtmux4b i978(.xtout(xtout[978])，.a(a[978])，.b(b[978])，.c(c[978])，
.d(d[978])，.sel(sel))；
xtmux4b i979(.xtout(xtout[979])，.a(a[979])，.b(b[979])，.c(c[979])，
.d(d[979])，.sel(sel))；
xtmux4b i980(.xtout(xtout[980])，.a(a[980])，.b(b[980])，.c(c[980])，
.d(d[980])，.sel(sel))；
xtmux4b i981(.xtout(xtout[981])，.a(a[981])，.b(b[981])，.c(c[981])，
.d(d[981])，.sel(sel))；
xtmux4b i982(.xtout(xtout[982])，.a(a[982])，.b(b[982])，.c(c[982])，
.d(d[982])，.sel(sel))；
xtmux4b i983(.xtout(xtout[983])，.a(a[983])，.b(b[983])，.c(c[983])，
.d(d[983])，.sel(sel))；
xtmux4b i984(.xtout(xtout[984])，.a(a[984])，.b(b[984])，.c(c[984])，
.d(d[984])，.sel(sel))；
xtmux4b i985(.xtout(xtout[985])，.a(a[985])，.b(b[985])，.c(c[985])，
.d(d[985])，.sel(sel))；
xtmux4b i986(.xtout(xtout[986])，.a(a[986])，.b(b[986])，.c(c[986])，
.d(d[986])，.sel(sel))；
<dp n="d257"/>
xtmux4b i987(.xtout(xtout[987])，.a(a[987])，.b(b[987])，.c(c[987])，
.d(d[987])，.sel(sel))；
xtmux4b i988(.xtout(xtout[988])，.a(a[988])，.b(b[988])，.c(c[988])，
.d(d[988])，.sel(sel))；
xtmux4b i989(.xtout(xtout[989])，.a(a[989])，.b(b[989])，.c(c[989])，
.d(d[989])，.sel(sel))；
xtmux4b i990(.xtout(xtout[990])，.a(a[990])，.b(b[990])，.c(c[990])，
.d(d[990])，.sel(sel))；
xtmux4b i991(.xtout(xtout[991])，.a(a[991])，.b(b[991])，.c(c[991])，
.d(d[991])，.sel(sel))；
xtmux4b i992(.xtout(xtout[992])，.a(a[992])，.b(b[992])，.c(c[992])，
.d(d[992])，.sel(sel))；
xtmux4b i993(.xtout(xtout[993])，.a(a[993])，.b(b[993])，.c(c[993])，
.d(d[993])，.sel(sel))；
xtmux4b i994(.xtout(xtout[994])，.a(a[994])，.b(b[994])，.c(c[994])，
.d(d[994])，.sel(sel))；
xtmux4b i995(.xtout(xtout[995])，.a(a[995])，.b(b[995])，.c(c[995])，
.d(d[995])，.sel(sel))；
xtmux4b i996(.xtout(xtout[996])，.a(a[996])，.b(b[996])，.c(c[996])，
.d(d[996])，.sel(sel))；
xtmux4b i997(.xtout(xtout[997])，.a(a[997])，.b(b[997])，.c(c[997])，
.d(d[997])，.sel(sel))；
xtmux4b i998(.xtout(xtout[998])，.a(a[998])，.b(b[998])，.c(c[998])，
.d(d[998])，.sel(sel))；
xtmux4b i999(.xtout(xtout[999])，.a(a[999])，.b(b[999])，.c(c[999])，
.d(d[999])，.sel(sel))；
xtmux4b i1000(.xtout(xtout[1000])，.a(a[1000])，.b(b[1000])，
.c(c[1000])，.d(d[1000])，.sel(sel))；
xtmux4b i1001(.xtout(xtout[1001])，.a(a[1001])，.b(b[1001])，
.c(c[1001])，.d(d[1001])，.sel(sel))；
xtmux4b i1002(.xtout(xtout[1002])，.a(a[1002])，.b(b[1002])，
.c(c[1002])，.d(d[1002])，.sel(sel))；
xtmux4b i1003(.xtout(xtout[1003])，.a(a[1003])，.b(b[1003])，
.c(c[1003])，.d(d[1003])，.sel(sel))；
xtmux4b i1004(.xtout(xtout[1004])，.a(a[1004])，.b(b[1004])，
.c(c[1004])，.d(d[1004])，.sel(sel))；
xtmux4b i1005(.xtout(xtout[1005])，.a(a[1005])，.b(b[1005])，
.c(c[1005])，.d(d[1005])，.sel(sel))；
xtmux4b i1006(.xtout(xtout[1006])，.a(a[1006])，.b(b[1006])，
.c(c[1006])，.d(d[1006])，.sel(sel))；
xtmux4b i1007(.xtout(xtout[1007])，.a(a[1007])，.b(b[1007])，
.c(c[1007])，.d(d[1007])，.sel(sel))；
xtmux4b i1008(.xtout(xtout[1008])，.a(a[1008])，.b(b[1008])，
.c(c[1008])，.d(d[1008])，.sel(sel))；
xtmux4b i1009(.xtout(xtout[1009])，.a(a[1009])，.b(b[1009])，
.c(c[1009])，.d(d[1009])，.sel(sel))；
xtmux4b i1010(.xtout(xtout[1010])，.a(a[1010])，.b(b[1010])，
.c(c[1010])，.d(d[1010])，.sel(sel))；
xtmux4b i1011(.xtout(xtout[1011])，.a(a[1011])，.b(b[1011])，
.c(c[1011])，.d(d[1011])，.sel(sel))；
xtmux4b i1012(.xtout(xtout[1012])，.a(a[1012])，.b(b[1012])，
.c(c[1012])，.d(d[1012])，.sel(sel))；
xtmux4b i1013(.xtout(xtout[1013])，.a(a[1013])，.b(b[1013])，
.c(c[1013])，.d(d[1013])，.sel(sel))；
xtmux4b i1014(.xtout(xtout[1014])，.a(a[1014])，.b(b[1014])，
.c(c[1014])，.d(d[1014])，.sel(sel))；
xtmux4b i1015(.xtout(xtout[1015])，.a(a[1015])，.b(b[1015])，
.c(c[1015])，.d(d[1015])，.sel(sel))；
xtmux4b i1016(.xtout(xtout[1016])，.a(a[1016])，.b(b[1016])，
.c(c[1016])，.d(d[1016])，.sel(sel))；
<dp n="d258"/>
xtmux4b i1017(.xtout(xtout[1017])，.a(a[1017])，.b(b[1017])，
.c(c[1017])，.d(d[1017])，.sel(sel))；
xtmux4b i1018(.xtout(xtout[1018])，.a(a[1018])，.b(b[1018])，
.c(c[1018])，.d(d[1018])，.sel(sel))；
xtmux4b i1019(.xtout(xtout[1019])，.a(a[1019])，.b(b[1019])，
.c(c[1019])，.d(d[1019])，.sel(sel))；
xtmux4b i1020(.xtout(xtout[1020])，.a(a[1020])，.b(b[1020])，
.c(c[1020])，.d(d[1020])，.sel(sel))；
xtmux4b i1021(.xtout(xtout[1021])，.a(a[1021])，.b(b[1021])，
.c(c[1021])，.d(d[1021])，.sel(8el))；
xtmux4b i1022(.xtout(xtout[1022])，.a(a[1022])，.b(b[1022])，
.c(c[1022])，.d(d[1022])，.sel(sel))；
xtmux4b i1023(.xtout(xtout[1023])，.a(a[1023])，.b(b[1023])，
.c(c[1023])，.d(d[1023])，.sel(sel))；
endmodule
module xtcsa_1024(sum，carry，a，b，c)；
output[1023：0]sum，carry；
input[1023：0]a，b，c；
xtfa i0(.sum(sum[0])，.carry(carry[0])，.a(a[0])，.b(b[0])，.c(c[0]))；
xtfa i1(.sum(sum[1])，.carry(carry[1])，.a(a[1])，.b(b[1])，.c(c[1]))；
xtfa i2(.sum(sum[2])，.carry(carry[2])，.a(a[2])，.b(b[2])，.c(c[2]))；
xtfa i3(.sum(sum[3])，.carry(carry[3])，.a(a[3])，.b(b[3])，.c(c[3]))；
xtfa i4(.sum(sum[4])，.carry(carry[4])，.a(a[4])，.b(b[4])，.c(c[4]))；
xtfa i5(.sum(sum[5])，.carry(carry[5])，.a(a[5])，.b(b[5])，.c(c[5]))；
xtfa i6(.sum(sum[6])，.carry(carry[6])，.a(a[6])，.b(b[6])，.c(c[6]))；
xtfa i7(.sum(sum[7])，.carry(carry[7])，.a(a[7])，.b(b[7])，.c(c[7]))；
xtfa i8(.sum(sum[8])，.carry(carry[8])，.a(a[8])，.b(b[8])，.c(c[8]))；
xtfa i9(.sum(sum[9])，.carry(carry[9])，.a(a[9])，.b(b[9])，.c(c[9]))；
xtfa i10(.sum(sum[10])，.carry(carry[10])，.a(a[10])，.b(b[10])，
.c(c[10]))；
xtfa i11(.sum(sum[11])，.carry(carry[11])，.a(a[11])，.b(b[11])，
.c(c[11]))；
xtfa i12(.sum(sum[12])，.carry(carry[12])，.a(a[12])，.b(b[12])，
.c(c[12]))；
xtfa i13(.sum(sum[13])，.carry(carry[13])，.a(a[13])，.b(b[13])，
.c(c[13]))；
xtfa i14(.sum(sum[14])，.carry(carry[14])，.a(a[14])，.b(b[14])，
.c(c[14]))；
xtfa i15(.sum(sum[15])，.carry(carry[15])，.a(a[15])，.b(b[15])，
.c(c[15]))；
xtfa i16(.sum(sum[16])，.carry(carry[16])，.a(a[16])，.b(b[16])，
.c(c[16]))；
xtfa i17(.sum(sum[17])，.carry(carry[17])，.a(a[17])，.b(b[17])，
.c(c[17]))；
xtfa i18(.sum(sum[18])，.carry(carry[18])，.a(a[18])，.b(b[18])，
.c(c[18]))；
xtfa i19(.sum(sum[19])，.carry(carry[19])，.a(a[19])，.b(b[19])，
.c(c[19]))；
xtfa i20(.sum(sum[20])，.carry(carry[20])，.a(a[20])，.b(b[20])，
.c(c[20]))；
xtfa i21(.sum(sum[21])，.carry(carry[21])，.a(a[21])，.b(b[21])，
.c(c[21]))；
xtfa i22(.sum(sum[22])，.carry(carry[22])，.a(a[22])，.b(b[22])，
.c(c[22]))；
xtfa i23(.sum(sum[23])，.carry(carry[23])，.a(a[23])，.b(b[23])，
.c(c[23]))；
xtfa i24(.sum(sum[24])，.carry(carry[24])，.a(a[24])，.b(b[24])，
.c(c[24]))；
xtfa i25(.sum(sum[25])，.carry(carry[25])，.a(a[25])，.b(b[25])，
.c(c[25]))；
<dp n="d259"/>
xtfa i26(.sum(sum[26])，.carry(carry[26])，.a(a[26])，.b(b[26])，
.c(c[26]))；
xtfa i27(.sum(sum[27])，.carry(carry[27])，.a(a[27])，.b(b[27])，
.c(c[27]))；
xtfa i28(.sum(sum[28])，.carry(carry[28])，.a(a[28])，.b(b[28])，
.c(c[28]))；
xtfa i29(.sum(sum[29])，.carry(carry[29])，，a(a[29])，.b(b[29])，
.c (c[29]))；
xtfa i30(.sum(sum[30])，.carry(carry[30])，.a(a[30])，b(b[30])，
.c(c[30]))；
xtfa i31(.sum(sum[31])，.carry(carry[31])，.a(a[31])，.b(b[31])，
.c(c[31]))；
xtfa i32(.sum(sum[32])，.carry(carry[32])，.a(a[32])，.b(b[32])，
.c(c[32]))；
xtfa i33(.sum(sum[33])，.carry(carry[33])，.a(a[33])，.b(b[33])，
.c(c[33]))；
xtfa i34(.sum(sum[34])，.carry(carry[34])，.a(a[34])，.b(b[34])，
.c(c[34]))；
xtfa i35(.sum(sum[35])，.carry(carry[35])，.a(a[35])，.b(b[35])，
.c(c[35]))；
xtfa i36(.sum(sum[36])，.carry(carry[36])，.a(a[36])，.b(b[36])，
.c(c[36]))；
xtfa i37(.sum(sum[37])，.carry(carry[37])，.a(a[37])，.b(b[37])，
.c(c[37]))；
xtfa i38(.sum(sum[38])，.carry(carry[38])，.a(a[38])，.b(b[38])，
.c(c[38]))；
xtfa i39(.sum(sum[39])，.carry(carry[39])，.a(a[39])，.b(b[39])，
.c(c[39]))；
xtfa i40(.sum(sum[40])，.carry(carry[40])，.a(a[40])，.b(b[40])，
.c(c[40]))；
xtfa i41(.sum(sum[41])，.carry(carry[41])，.a(a[41])，.b(b[41])，
.c(c[41]))；
xtfa i42(.sum(sum[42])，.carry(carry[42])，.a(a[42])，.b(b[42])，
.c(c[42]))；
xtfa i43(.sum(sum[43])，.carry(carry[43])，.a(a[43])，.b(b[43])，
.c(c[43]))；
xtfa i44(.sum(sum[44])，.carry(carry[44])，.a(a[44])，.b(b[44])，
.c(c[44]))；
xtfa i45(.sum(sum[45])，.carry(carry[45])，.a(a[45])，.b(b[45])，
.c(c[45]))；
xtfa i46(.sum(sum[46])，.carry(carry[46])，.a(a[46])，.b(b[46])，
.c(c[46]))；
xtfa i47(.sum(sum[47])，.carry(carry[47])，.a(a[47])，.b(b[47])，
.c(c[47]))；
xtfa i48(.sum(sum[48])，.carry(carry[48])，.a(a[48])，.b(b[48])，
.c(c[48]))；
xtfa i49(.sum(sum[49])，.carry(carry[49])，.a(a[49])，.b(b[49])，
.c(c[49]))；
xtfa i50(.sum(sum[50])，.carry(carry[50])，.a(a[50])，.b(b[50])，
.c(c[50]))；
xtfa i51(.sum(sum[51])，.carry(carry[51])，.a(a[51])，.b(b[51])，
.c(c[51]))；
xtfa i52(.sum(sum[52])，.carry(carry[52])，.a(a[52])，.b(b[52])，
.c(c[52]))；
xtfa i53(.sum(sum[53])，.carry(carry[53])，.a(a[53])，.b(b[53])，
.c(c[53]))；
xtfa i54(.sum(sum[54])，.carry(carry[54])，.a(a[54])，.b(b[54])，
.c(c[54]))；
xtfa i55(.sum(sum[55])，.carry(carry[55])，.a(a[55])，.b(b[55])，
.c(c[55]))；
<dp n="d260"/>
xtfa i56(.sum(sum[56])，.carry(carry[56])，.a(a[56])，.b(b[56])，
.c(c[56]))；
xtfa i57(.sum(sum[57])，.carry(carry[57])，.a(a[57])，.b(b[57])，
.c(c[57]))；
xtfa i58(.sum(sum[58])，.carry(carry[58])，.a(a[58])，.b(b[58])，
.c(c[58]))；
xtfa i59(.sum(sum[59])，.carry(carry[59])，.a(a[59])，.b(b[59])，
.c(c[59]))；
xtfa i60(.sum(sum[60])，.carry(carry[60])，.a(a[60])，.b(b[60])，
.c(c[60]))；
xtfa i61(.sum(sum[61])，.carry(carry[61])，.a(a[61])，.b(b[61])，
.c(c[61]))；
xtfa i62(.sum(sum[62])，.carry(carry[62])，.a(a[62])，.b(b[62])，
.c(c[62]))；
xtfa i63(.sum(sum[63])，.carry(carry[63])，.a(a[63])，.b(b[63])，
.c(c[63]))；
xtfa i64(.sum(sum[64])，.carry(carry[64])，.a(a[64])，.b(b[64])，
.c(c[64]))；
xtfa i65(.sum(sum[65])，.carry(carry[65])，.a(a[65])，.b(b[65])，
.c(c[65]))；
xtfa i66(.sum(sum[66])，.carry(carry[66])，.a(a[66])，.b(b[66])，
.c(c[66]))；
xtfa i67(.sum(sum[67])，.carry(carry[67])，.a(a[67])，.b(b[67])，
.c(c[67]))；
xtfa i68(.sum(sum[68])，.carry(carry[68])，.a(a[68])，.b(b[68])，
.c(c[68]))；
xtfa i69(.sum(sum[69])，.carry(carry[69])，.a(a[69])，.b[b[69])，
.c(c[69]))；
xtfa i70(.sum(sum[70])，.carry(carry[70])，.a(a[70])，.b(b[70])，
.c(c[70]))；
xtfa i71(.sum(sum[71])，.carry(carry[71])，.a(a[71])，.b(b[71])，
.c(c[71]))；
xtfa i72(.sum(sum[72])，.carry(carry[72])，.a(a[72])，.b(b[72])，
.c(c[72]))；
xtfa i73(.sum(sum[73])，.carry(carry[73])，.a(a[73])，.b(b[73])，
.c(c[73]))；
xtfa i74(.sum(sum[74])，.carry(carry[74])，.a(a[74])，.b(b[74])，
.c(c[74]))；
xtfa i75(.sum(sum[75])，.carry(carry[75])，.a(a[75])，.b(b[75])，
.c(c[75]))；
xtfa i76(.sum(sum[76])，.carry(carry[76])， a(a[76])，.b(b[76])，
.c(c[76]))；
xtfa i77(.sum(sum[77])，.carry(carry[77])，.a(a[77])，.b(b[77])，
.c(c[77]))；
xtfa i78(.sum(sum[78])，.carry(carry[78])，.a(a[78])，.b(b[78])，
.c(c[78]))；
xtfa i79(.sum(sum[79])，.carry(carry[79])，.a(a[79])，.b(b[79])，
.c(c[79]))；
xtfa i80(.sum(sum[80])，.carry(carry[80])，.a(a[80])，.b(b[80])，
.c(c[80]))；
xtfa i81(.sum(sum[81])，.carry(carry[81])，.a(a[81])，.b(b[81])，
.c(c[81]))；
xtfa i82(.sum(sum[82])，.carry(carry[82])，.a(a[82])，.b(b[82])，
.c(c[82]))；
xtfa i83(.sum(sum[83])，.carry(carry[83])，.a(a[83])，.b(b[83])，
.c(c[83]))；
xtfa i84(.sum(sum[84])，.carry(carry[84])，.a(a[84])，.b(b[84])，
.c(c[84]))；
xtfa i85(.sum(sum[85])，.carry(carry[85])，.a(a[85])，.b(b[85])，
.c(c[85]))；
<dp n="d261"/>
xtfa i86(.sum(sum[86])，.carry(carry[86])，.a(a[86])，.b(b[86])，
.c(c[86]))；
xtfa i87(.sum(sum[87])，.carry(carry[87])，.a(a[87])，.b(b[87])，
.c(c[87]))；
xtfa i88(.sum(sum[88])，.carry(carry[88])，.a(a[88])，.b(b[88])，
.c(c[88]))；
xtfa i89(.sum(sum[89])，.carry(carry[89])，.a(a[89])，.b(b[89])，
.c(c[89]))；
xtfa i90(.sum(sum[90])，.carry(carry[90])，.a(a[90])，.b(b[90])，
.c(c[90]))；
xtfa i91(.sum(sum[91])，.carry(carry[91])，.a(a[91])，.b(b[91])，
.c(c[91]))；
xtfa i92(.sum(sum[92])，.carry(carry[92])，.a(a[92])，.b(b[92])，
.c(c[92]))；
xtfa i93(.sum(sum[93])，.carty(carry[93])，.a(a[93])，.b(b[93])，
.c(c[93]))；
xtfa i94(.sum(sum[94])，.carry(carry[94])，.a(a[94])，.b(b[94])，
.c(c[94]))；
xtfa i95(.sum(sum[95])，.carry(carry[95])，.a(a[95])，.b(b[95])，
.c(c[95]))；
xtfa i96(.sum(sum[96])，.carry(carry[96])，.a(a[96])，.b(b[96])，
.c(c[96]))；
xtfa i97(.sum(sum[97])，.carry(carry[97])，.a(a[97])，.b(b[97])，
.c(c[97]))；
xtfa i98(.sum(sum[98])，.carry(carry[98])，.a(a[98])，.b(b[98])，
.c(c[98]))；
xtfa i99(.sum(sum[99])，.carry(carry[99])，.a(a[99])，.b(b[99])，
.c(c[99]))；
xtfa i100(.sum(sum[100])，.carry(carry[100])，.a(a[100])，.b(b[100])，
.c(c[100]))；
xtfa i101(.sum(sum[101])，.carry(carry[101])，.a(a[101])，.b(b[101])，
.c(c[101]))；
xtfa i102(.sum(sum[102])，.carry(carry[102])，.a(a[102])，.b(b[102])，
.c(c[102]))；
xtfa i103(.sum(sum[103])，.carry(carry[103])，.a(a[103])，.b(b[103])，
.c(c[103]))；
xtfa i104(.sum(sum[104])，.carry(carry[104])，.a(a[104])，.b(b[104])，
.c(c[104]))；
xtfa i105(.sum(sum[105])，.carry(carry[105])，.a(a[105])，.b(b[105])，
.c(c[105]))；
xtfa i106(.sum(sum[106])，.carry(carry[106])，.a(a[106])，.b(b[106])，
.c(c[106]))；
xtfa i107(.sum(sum[107])，.carry(carry[107])，.a(a[107])，.b(b[107])，
.c(c[107]))；
xtfa i108(.sum(sum[108])，.carry(carry[108])，.a(a[108])，.b(b[108])，
.c(c[108]))；
xtfa i109(.sum(sum[109])，.carry(carry[109])，.a(a[109])，.b(b[109])，
.c(c[109]))；
xtfa i110(.sum(sum[110])，.carry(carry[110])，.a(a[110])，.b(b[110])，
.c(c[110]))；
xtfa i111(.sum(sum[111])，.carry(carry[111])，.a(a[111])，.b(b[111])，
.c(c[111]))；
xtfa i112(.sum(sum[112])，.carry(carry[112])，.a(a[112])，.b(b[112])，
.c(c[112]))；
xtfa i113(.sum(sum[113])，.carry(carry[113])，.a(a[113])，.b(b[113])，
.c(c[113]))；
xtfa i114(.sum(sum[114])，.carry(carry[114])，.a(a[114])，.b(b[114])，
.c(c[114]))；
xtfa i115(.sum(sum[115])，.carry(carry[115])，.a(a[115])，.b(b[115])，
.c(c[115]))；
<dp n="d262"/>
xtfa i116(.sum(sum[116])，.carry(carry[116])，.a(a[116])，.b(b[116])，
.c(c[116]))；
xtfa i117(.sum(sum[117])，.carry(carry[117])，.a(a[117])，.b(b[117])，
.c(c[117]))；
xtfa i118(.sum(sum[118])，.carry(carry[118])，.a(a[118])，.b(b[118])，
.c(c[118]))；
xtfa i119(.sum(sum[119])，.carry(carry[119])，.a(a[119])，.b(b[119])，
.c(c[119]))；
xtfa i120(.sum(sum[120])，.carry(carry[120])，.a(a[120])，.b(b[120])，
.c(c[120]))；
xtfa i121(.sum(sum[121])，.carry(carry[121])，.a(a[121])，.b(b[121])，
.c(c[121]))；
xtfa i122(.sum(sum[122])，.carry(carry[122])，.a(a[122])，.b(b[122])，
.c(c[122]))；
xtfa i123(.sum(sum[123])，.carry(carry[123])，.a(a[123])，.b(b[123])，
.c(c[123]))；
xtfa i124(.sum(sum[124])，.carry(carry[124])，.a(a[124])，.b(b[124])，
.c(c[124]))；
xtfa i125(.sum(sum[125])，.carry(carry[125])，.a(a[125])，.b(b[125])，
.c(c[125]))；
xtfa i126(.sum(sum[126])，.carry(carry[126])，.a(a[126])，.b(b[126])，
.c(c[126]))；
xtfa i127(.sum(sum[127])，.carry(carry[127])，.a(a[127])，.b(b[127])，
.c(c[127]))；
xtfa i128(.sum(sum[128])，.carry(carry[128])，.a(a[128])，.b(b[128])，
.c(c[128]))；
xtfa i129(.sum(sum[129])，.carry(carry[129])，.a(a[129])，.b(b[129])，
.c(c[129]))；
xtfa i130(.sum(sum[130])，.carry(carry[130])，.a(a[130])，.b(b[130])，
.c(c[130]))；
xtfa i131(.sum(sum[131])，.carry(carry[131])，.a(a[131])，.b(b[131])，
.c(c[131]))；
xtfa i132(.sum(sum[132])，.carry(carry[132])，.a(a[132])，.b(b[132])，
.c(c[132]))；
xtfa i133(.sum(sum[133])，.carry(carry[133])，.a(a[133])，.b(b[133])，
.c(c[133]))；
xtfa i134(.sum(sum[134])，.carry(carry[134])，.a(a[134])，.b(b[134])，
.c(c[134]))；
xtfa i135(.sum(sum[135])，.carry(carry[135])，.a(a[135])，.b(b[135])，
.c(c[135]))；
xtfa i136(.sum(sum[136])，.carry(carry[136])，.a(a[136])，.b(b[136])，
.c(c[136]))；
xtfa i137(.sum(sum[137])，.carry(carry[137])，.a(a[137])，.b(b[137])，
.c(c[137]))；
xtfa i138(.sum(sum[138])，.carry(carry[138])，.a(a[138])，.b(b[138])，
.c(c[138]))；
xtfa i139(.sum(sum[139])，.carry(carry[139])，.a(a[139])，.b(b[139])，
.c(c[139]))；
xtfa i140(.sum(sum[140])，.carry(carry[140])，.a(a[140])，.b(b[140])，
.c(c[140]))；
xtfa i141(.sum(sum[141])，.carry(carry[141])，.a(a[141])，.b(b[141])，
.c(c[141]))；
xtfa i142(.sum(sum[142])，.carry(carry[142])，.a(a[142])，.b(b[142])，
.c(c[142]))；
xtfa i143(.sum(sum[143])，.carry(carry[143])，.a(a[143])，.b(b[143])，
.c(c[143]))；
xtfa i144(.sum(sum[144])，.carry(carry[144])，.a(a[144])，.b(b[144])，
.c(c[144]))；
xtfa i145(.sum(sum[145])，.carry(carry[145])，.a(a[145])，.b(b[145])，
.c(c[145]))；
<dp n="d263"/>
xtfa i146(.sum(sum[146])，.carry(carry[146])，.a(a[146])，.b(b[146])，
.c(c[146]))；
xtfa i147(.sum(sum[147])，.carry(carry[147])，.a(a[147])，.b(b[147])，
.c(c[147]))；
xtfa i148(.sum(sum[148])，.carry(carry[148])，.a(a[148])，.b(b[148])，
.c(c[148]))；
xtfa i149(.sum(sum[149])，.carry(carry[149])，.a(a[149])，.b(b[149])，
.c(c[149]))；
xtfa i150(.sum(sum[150])，.carry(carry[150])，.a(a[150])，.b(b[150])，
.c(c[150]))；
xtfa i151(.sum(sum[151])，.carry(carry[151])，.a(a[151])，.b(b[151])，
.c(c[151]))；
xtfa i152(.sum(sum[152])，.carry(carry[152])，.a(a[152])，.b(b[152])，
.c(c[152]))；
xtfa i153(.sum(sum[153])，.carry(carry[153])，.a(a[153])，.b(b[153])，
.c(c[153]))；
xtfa i154(.sum(sum[154])，.carry(carry[154])，.a(a[154])，.b(b[154])，
.c(c[154]))；
xtfa i155(.sum(sum[155])，.carry(carry[155])，.a(a[155])，.b(b[155])，
.c(c[155]))；
xtfa i156(.sum(sum[156])，.carry(carry[156])，.a(a[156])，.b(b[156])，
.c(c[156]))；
xtfa i157(.sum(sum[157])，.carry(carry[157])，.a(a[157])，.b(b[157])，
.c(c [157]))；
xtfa i158(.sum(sum[158])，.carry(carry[158])，.a(a[158])，.b(b[158])，
.c(c[158]))；
xtfa i159(.sum(sum[159])，.carry(carry[159])，.a(a[159])，.b(b[159])，
.c(c[159]))；
xtfa i160(.sum(sum[160])，.carry(carry[160])，.a(a[160])，.b(b[160])，
.c(c[160]))；
xtfa i161(.sum(sum[161])，.carry(carry[161])，.a(a[161])，.b(b[161])，
.c(c[161]))；
xtfa i162(.sum(sum[162])，.carry(carry[162])，.a(a[162])，.b(b[162])，
.c(c[162]))；
xtfa i163(.sum(sum[163])，.carry(carry[163])，.a(a[163])，.b(b[163])，
.c(c[163]))；
xtfa i164(.sum(sum[164])，.carry(carry[164])，.a(a[164])，.b(b[164])，
.c(c[164]))；
xtfa i165(.sum(sum[165])，.carry(carry[165])，.a(a[165])，.b(b[165])，
.c(c[165]))；
xtfa i166(.sum(sum[166])，.carry(carry[166])，.a(a[166])，.b(b[166])，
.c(c[166]))；
xtfa i167(.sum(sum[167])，.carry(carry[167])，.a(a[167])，.b(b[167])，
.c(c[167]))；
xtfa i168(.sum(sum[168])，.carry(carry[168])，.a(a[168])，.b(b[168])，
.c(c[168]))；
xtfa i169(.sum(sum[169])，.carry(carry[169])，.a(a[169])，.b(b[169])，
.c(c[169]))；
xtfa i170(.sum(sum[170])，.carry(carry[170])，.a(a[170])，.b(b[170])，
.c(c[170]))；
xtfa i171(.sum(sum[171])，.carry(carry[171])，.a(a[171])，.b(b[171])，
.c(c[171]))；
xtfa i172(.sum(sum[172])，.carry(carry[172])，.a(a[172])，.b(b[172])，
.c(c[172]))；
xtfa i173(.sum(sum[173])，.carry(carry[173])，.a(a[173])，.b(b[173])，
.c(c[173]))；
xtfa i174(.sum(sum[174])，.carry(carry[174])，.a(a[174])，.b(b[174])，
.c(c[174]))；
xtfa i175(.sum(sum[175])，.carry(carry[175])，.a(a[175])，.b(b[175])，
.c(c[175]))；
<dp n="d264"/>
xtfa i176(.sum(sum[176])，.carry(carry[176])，.a(a[176])，.b(b[176])，
.c(c[176]))；
xtfa i177(.sum(sum[177])，.carry(carry[177])，.a(a[177])，.b(b[177])，
.c(c[177]))；
xtfa i178(.sum(sum[178])，.carry(carry[178])，.a(a[178])，.b(b[178])，
.c(c[178]))；
xtfa i179(.sum(sum[179])，.carry(carry[179])，.a(a[179])，.b(b[179])，
.c(c[179]))；
xtfa i180(.sum(sum[180])，.carry(carry[180])，.a(a[180])，.b(b[180])，
.c(c[180]))；
xtfa i181(.sum(sum[181])，.carry(carry[181])，.a(a[181])，.b(b[181])，
.c(c[181]))；
xtfa i182(.sum(sum[182])，.carry(carry[182])，.a(a[182])，.b(b[182])，
.c(c[182]))；
xtfa i183(.sum(sum[183])，.carry(carry[183])，.a(a[183])， b(b[183])，
.c(c[183]))；
xtfa i184(.sum(sum[184])，.carry(carry[184])，.a(a[184])，.b(b[184])，
.c(c[184]))；
xtfa i185(.sum(sum[185])，.carry(carry[185])，.a(a[185])，.b(b[185])，
.c(c[185]))；
xtfa i186(.sum(sum[186])，.carry(carry[186])，.a(a[186])，.b(b[186])，
.c(c[186]))；
xtfa i187(.sum(sum[187])，.carry(carry[187])，.a(a[187])，.b(b[187])，
.c(c[187]))；
xtfa i188(.sum(sum[188])，.carry(carry[188])，.a(a[188])，.b(b[188])，
.c(c[188]))；
xtfa i189(.sum(sum[189])，.carry(carry[189])，.a(a[189])，.b(b[189])，
.c(c[189]))；
xtfa i190(.sum(sum[190])，.carry(carry[190])，.a(a[190])，.b(b[190])，
.c(c[190]))；
xtfa i191(.sum(sum[191])，.carry(carry[191])，.a(a[191])，.b(b[191])，
.c(c[191]))；
xtfa i192(.sum(sum[192])，.carry(carry[192])，.a(a[192])，.b(b[192])，
.c(c[192]))；
xtfa i193(.sum(sum[193])，.carry(carry[193])，.a(a[193])，.b(b[193])，
.c(c[193]))；
xtfa i194(.sum(sum[194])，.carry(carry[194])，.a(a[194])，.b(b[194])，
.c(c[194]))；
xtfa i195(.sum(sum[195])，.carry(carry[195])，.a(a[195])，.b(b[195])，
.c(c[195]))；
xtfa i196(.sum(sum[196])，.carry(carry[196])，.a(a[196])，.b(b[196])，
.c(c[196]))；
xtfa i197(.sum(sum[197])，.carry(carry[197])，.a(a[197])，.b(b[197])，
.c(c [197]))；
xtfa i198(.sum(sum[198])，.carry(carry[198])，.a(a[198])，.b(b[198])，
.c(c [198]))；
xtfa i199(.sum(sum[199])，.carry(carry[199])，.a(a[199])，.b(b[199])，
.c(c[199]))；
xtfa i200(.sum(sum[200])，.carry(carry[200])，.a(a[200])，.b(b[200])，
.c(c[200]))；
xtfa i201(.sum(sum[201])，.carry(carry[201])，.a(a[201])，.b(b[201])，
.c(c[201]))；
xtfa i202(.sum(sum[202])，.carry(carry[202])，.a(a[202])，.b(b[202])，
.c(c[202]))；
xtfa i203(.sum(sum[203])，.carry(carry[203])，.a(a[203])，.b(b[203])，
.c(c[203]))；
xtfa i204(.sum(sum[204])，.carry(carry[204])，.a(a[204])，.b(b[204]，
.c(c[204]))；
xtfa i205(.sum(sum[205])，.carry(carry[205])，.a(a[205])，.b(b[205])，
.c(c[205]))；
<dp n="d265"/>
xtfa i206(.sum(sum[206])，.carry(carry[206])，.a(a[206])，.b(b[206])，
.c(c[206]))；
xtfa i207(.sum(sum[207])，.carry(carry[207])，.a(a[207])，.b(b[207])，
.c(c[207]))；
xtfa i208(.sum(sum[208])，.carry(carry[208])，.a(a[208])，.b(b[208])，
.c(c[208]))；
xtfa i209(.sum(sum[209])，.carry(carry[209])，.a(a[209])，.b(b[209])，
.c(c[209]))；
xtfa i210(.sum(sum[210])，.carry(carry[210])，.a(a[210])，.b(b[210])，
.c(c[210]))；
xtfa i211(.sum(sum[211])，.carry(carry[211])，.a(a[211])，.b(b[211])，
.c(c[211]))；
xtfa i212(.sum(sum[212])，.carry(carry[212])，.a(a[212])，.b(b[212])，
.c(c[212]))；
xtfa i213(.sum(sum[213])，.carry(carry[213])，.a(a[213])，.b(b[213])，
.c(c[213]))；
xtfa i214(.sum(sum[214])，.carry(carry[214])，.a(a[214])，.b(b[214])，
.c(c[214]))；
xtfa i215(.sum(sum[215])，.carry(carry[215])，.a(a[215])，.b(b[215])，
.c(c[215]))；
xtfa i216(.sum(sum[216])，.carry(carry[216])，.a(a[216])，.b(b[216])，
.c(c[216]))；
xtfa i217(.sum(sum[217])，.carry(carry[217])，.a(a[217])，.b(b[217])，
.c(c[217]))；
xtfa i218(.sum(sum[218])，.carry(carry[218])，.a(a[218])，.b(b[218])，
.c(c[218]))；
xtfa i219(.sum(sum[219])，.carry(carry[219])，.a(a[219])，.b(b[219])，
.c(c[219]))；
xtfa i220(.sum(sum[220])，.carry(carry[220])，.a(a[220])，.b(b[220])，
.c(c[220]))；
xtfa i221(.sum(sum[221])，.carry(carry[221])，.a(a[221])，.b(b[221])，
.c(c[221]))；
xtfa i222(.sum(sum[222])，.carry(carry[222])，.a(a[222])，.b(b[222])，
.c(c[222]))；
xtfa i223(.sum(sum[223])，.carry(carry[223])，.a(a[223])，.b(b[223])，
.c(c[223]))；
xtfa i224(.sum(sum[224])，.carry(carry[224])，.a(a[224])，.b(b[224])，
.c(c[224]))；
xtfa i225(.sum(sum[225])，.carry(carry[225])，.a(a[225])，.b(b[225])，
.c(c[225]))；
xtfa i226(.sum(sum[226])，.carry(carry[226])，.a(a[226])，.b(b[226])，
.c(c[226]))；
xtfa i227(.sum(sum[227])，.carry(carry[227])，.a(a[227])，.b(b[227])，
.c(c[227]))；
xtfa i228(.sum(sum[228])，.carry(carry[228])，.a(a[228])，.b(b[228])，
.c(c[228]))；
xtfa i229(.sum(sum[229])，.carry(carry[229])，.a(a[229])，.b(b[229])，
.c(c[229]))；
xtfa i230(.sum(sum[230])，.carry(carry[230])，.a(a[230])，.b(b[230])，
.c(c[230]))；
xtfa i231(.sum(sum[231])，.carry(carry[231])，.a(a[231])，.b(b[231])，
.c(c[231]))；
xtfa i232(.sum(sum[232])，.carry(carry[232])，.a(a[232])，.b(b[232])，
.c(c[232]))；
xtfa i233(.sum(sum[233])，.carry(carry[233])，.a(a[233])，.b(b[233])，
.c(c[233]))；
xtfa i234(.sum(sum[234])，.carry(carry[234])，.a(a[234])，.b(b[234])，
.c(c[234]))；
xtfa i235(.sum(sum[235])，.carry(carry[235])，.a(a[235])，.b(b[235])，
.c(c[235]))；
<dp n="d266"/>
xtfa i236(.sum(sum[236])，.carry(carry[236])，.a(a[236])，.b(b[236])，
.c(c[236]))；
xtfa i237(.sum(sum[237])，.carry(carry[237])，.a(a[237])，.b(b[237])，
.c(c[237]))；
xtfa i238(.sum(sum[238])，.carry(carry[238])，.a(a[238])，.b(b[238])，
.c(c[238]))；
xtfa i239(.sum(sum[239])，.carry(carry[239])，.a(a[239])，.b(b[239])，
.c(c[239]))；
xtfa i240(.sum(sum[240])，.carry(carry[240])，.a(a[240])，.b(b[240])，
.c(c[240]))；
xtfa i241(.sum(sum[241])，.carry(carry[241])，.a(a[241])，.b(b[241])，
.c(c[241]))；
xtfa i242(.sum(sum[242])，.carry(carry[242])，.a(a[242])，.b(b[242])，
.c(c[242]))；
xtfa i243(.sum(sum[243])，.carry(carry[243])，.a(a[243])，.b(b[243])，
.c(c[243]))；
xtfa i244(.sum(sum[244])，.carry(carry[244])，.a(a[244])，.b(b[244])，
.c(c[244]))；
xtfa i245(.sum(sum[245])，.carry(carry[245])，.a(a[245])，.b(b[245])，
.c(c[245]))；
xtfa i246(.sum(sum[246])，.carry(carry[246])，.a(a[246])，.b(b[246])，
.c(c[246]))；
xtfa i247(.sum(sum[247])，.carry(carry[247])，.a(a[247])，.b(b[247])，
.c(c[247]))；
xtfa i248(.sum(sum[248])，.carry(carry[248])，.a(a[248])，.b(b[248])，
.c(c[248]))；
xtfa i249(.sum(sum[249])，.carry(carry[249])，.a(a[249])，.b(b[249])，
.c(c[249]))；
xtfa i250(.sum(sum[250])，.carry(carry[250])，.a(a[250])，.b(b[250])，
.c(c[250]))；
xtfa i251(.sum(sum[251])，.carry(carry[251])，.a(a[251])，.b(b[251])，
.c(c[251]))；
xtfa i252(.sum(sum[252])，.carry(carry[252])，.a(a[252])，.b(b[252])，
.c(c[252]))；
xtfa i253(.sum(sum[253])，.carry(carry[253])，.a(a[253])，.b(b[253])，
.c(c[253]))；
xtfa i254(.sum(sum[254])，.carry(carry[254])，.a(a[254])，.b(b[254])，
.c(c[254]))；
xtfa i255(.sum(sum[255])，.carry(carry[255])，.a(a[255])，.b(b[255])，
.c(c[255]))；
xtfa i256(.sum(sum[256])，.carry(carry[256])，.a(a[256])，.b(b[256])，
.c(c[256]))；
xtfa i257(.sum(sum[257])，.carry(carry[257])，.a(a[257])，.b(b[257])，
.c(c[257]))；
xtfa i258(.sum(sum[258])，.carry(carry[258])，.a(a[258])，.b(b[258])，
.c(c[258]))；
xtfa i259(.sum(sum[259])，.carry(carry[259])，.a(a[259])，.b(b[259])，
.c(c[259]))；
xtfa i260(.sum(sum[260])，.carry(carry[260])，.a(a[260])，.b(b[260])，
.c(c[260]))；
xtfa i261(.sum(sum[261])，.carry(carry[261])，.a(a[261])，.b(b[261])，
.c(c[261]))；
xtfa i262(.sum(sum[262])，.carry(carry[262])，.a(a[262])，.b(b[262])，
.c(c[262]))；
xtfa i263(.sum(sum[263])，.carry(carry[263])，.a(a[263])，.b(b[263])，
.c(c[263]))；
xtfa i264(.sum(sum[264])，.carry(carry[264])，.a(a[264])，.b(b[264])，
.c(c[264]))；
xtfa i265(.sum(sum[265])，.carry(carry[265])，.a(a[265])，.b(b[265])，
.c(c[265]))；
<dp n="d267"/>
xtfa i266(.sum(sum[266])，.carry(carry[266])，.a(a[266])，.b(b[266])，
.c(c[266]))；
xtfa i267(.sum(sum[267])，.carry(carry[267])，.a(a[267])，.b(b[267])，
.c(c[267]))；
xtfa i268(.sum(sum[268])，.carry(carry[268])，.a(a[268])，.b(b[268])，
.c(c[268]))；
xtfa i269(.sum(sum[269])，.carry(carry[269])，.a(a[269])，.b(b[269])，
.c(c[269]))；
xtfa i270(.sum(sum[270])，.carry(carry[270])，.a(a[270])，.b(b[270])，
.c(c[270]))；
xtfa i271(.sum(sum[271])，.carry(carry[271])，.a(a(271])，.b(b[271])，
.c(c[271]))；
xtfa i272(.sum(sum[272])，.carry(carry[272])，.a(a[272])，.b(b[272])，
.c(c[272]))；
xtfa i273(.sum(sum[273])，.carry(carry[273])，.a(a[273])，.b(b[273])，
.c(c[273]))；
xtfa i274(.sum(sum[274])，.carry(carry[274])，.a(a[274])，.b(b[274])，
.c(c[274]))；
xtfa i275(.sum(sum[275])，.carry(carry[275])，.a(a[275])，.b(b[275])，
.c(c[275]))；
xtfa i276(.sum(sum[276])，.carry(carry[276])，.a(a[276])，.b(b[276])，
.c(c[276]))；
xtfa i277(.sum(sum[277])，.carry(carry[277])，.a(a[277])，.b(b[277])，
.c(c[277]))；
xtfa i278(.sum(sum[278])，.carry(carry[278])，.a(a[278])，.b(b[278])，
.c(c[278]))；
xtfa i279(.sum(sum[279])，.carry(carry[279])，.a(a[279])，.b(b[279])，
.c(c[279]))；
xtfa i280(.sum(sum[280])，.carry(carry[280])，.a(a[280])，.b(b[280])，
.c(c[280]))；
xtfa i281(.sum(sum[281])，.carry(carry[281])，.a(a[281])，.b(b[281])，
.c(c[281]))；
xtfa i282(.sum(sum[282])，.carry(carry[282])，.a(a[282])，.b(b[282])，
.c(c[282]))；
xtfa i283(.sum(sum[283])，.carry(carry[283])，.a(a[283])，.b(b[283])，
.c(c[283]))；
xtfa i284(.sum(sum[284])，.carry(carry[284])，.a(a[284])，.b(b[284])，
.c(c[284]))；
xtfa i285(.sum(sum[285])，.carry(carry[285])，.a(a[285])，.b(b[285])，
.c(c[285]))；
xtfa i286(.sum(sum[286])，.carry(carry[286])，.a(a[286])，.b(b[286])，
.c(c[286]))；
xtfa i287(.sum(sum[287])，.carry(carry[287])，.a(a[287])，.b(b[287])，
.c(c[287]))；
xtfa i288(.sum(sum[288])，.carry(carry[288])，.a(a[288])，.b(b[288])，
.c(c[288]))；
xtfa i289(.sum(sum[289])，.carry(carry[289])，.a(a[289])，.b(b[289])，
.c(c[289]))；
xtfa i290(.sum(sum[290])，.carry(carry[290])，.a(a[290])，.b(b[290])，
.c(c[290]))；
xtfa i291(.sum(sum[291])，.carry(carry[291])，.a(a[291])，.b(b[291])，
.c(c[291]))；
xtfa i292(.sum(sum[292])，.carry(carry[292])，.a(a[292])，.b(b[292])，
.c(c[292]))；
xtfa i293(.sum(sum[293])，.carry(carry[293])，.a(a[293])，.b(b[293])，
.c(c[293]))；
xtfa i294(.sum(sum[294])，.carry(carry[294])，.a(a[294])，.b(b[294])，
.c(c[294]))；
xtfa i295(.sum(sum[295])，.carry(carry[295])，.a(a[295])，.b(b[295])，
.c(c[295]))；
<dp n="d268"/>
xtfa i296(.sum(sum[296])，.carry(carry[296])，.a(a[296])，.b(b[296])，
.c(c[296]))；
xtfa i297(.sum(sum[297])，.carry(carry[297])，.a(a[297])，.b(b[297])，
.c(c[297]))；
xtfa i298(.sum(sum[298])，.carry(carry[298])，.a(a[298])，.b(b[298])，
.c(c[298]))；
xtfa i299(.sum(sum[299])，.carry(carry[299])，.a(a[299])，.b(b[299])，
.c(c[299]))；
xtfa i300(.sum(sum[300])，.carry(carry[300])，.a(a[300])，.b(b[300])，
.c(c [300]))；
xtfa i301(.sum(sum[301])，.carry(carry[301])，.a(a[301])，.b(b[301])，
.c(c[301]))；
xtfa i302(.sum(sum[302])，.carry(carry[302])，.a(a[302])，.b(b[302])，
.c(c[302]))；
xtfa i303(.sum(sum[303])，.carry(carry[303])，.a(a[303])，.b(b[303])，
.c(c[303]))；
xtfa i304(.sum(sum[304])，.carry(carry[304])，.a(a[304])，.b(b[304])，
.c(c[304]))；
xtfa i305(.sum(sum[305])，.carry(carry[305])，.a(a[305])，.b(b[305])，
.c(c[305]))；
xtfa i306(.sum(sum[306])，.carry(carry[306])，.a(a[306])，.b(b[306])，
.c(c[306]))；
xtfa i307(.sum(sum[307])，.carry(carry[307])，.a(a[307])，.b(b[307])，
.c(c[307]))；
xtfa i308(.sum(sum[308])，.carry(carry[308])，.a(a[308])，.b(b[308])，
.c(c[308]))；
xtfa i309(.sum(sum[309])，.carry(carry[309])，.a(a[309])，.b(b[309])，
.c(c[309]))；
xtfa i310(.sum(sum[310])，.carry(carry[310])，.a(a[310])，.b(b[310])，
.c(c[310]))；
xtfa i311(.sum(sum[311])，.carry(carry[311])，.a(a[311])，.b(b[311])，
.c(c[311]))；
xtfa i312(.sum(sum[312])，.carry(carry[312])，.a(a[312])，.b(b[312])，
.c(c[312]))；
xtfa i313(.sum(sum[313])，.carry(carry[313])，.a(a[313])，.b(b[313])，
.c(c[313]))；
xtfa i314(.sum(sum[314])，.carry(carry[314])，.a(a[314])，.b(b[314])，
.c(c[314]))；
xtfa i315(.sum(sum[315])，.carry(carry[315])，.a(a[315])，.b(b[315])，
.c(c[315]))；
xtfa i316(.sum(sum[316])，.carry(carry[316])，.a(a[316])，.b(b[316])，
.c(c[316]))；
xtfa i317(.sum(sum[317])，.carry(carry[317])，.a(a[317])，.b(b[317])，
.c(c[317]))；
xtfa i318(.sum(sum[318])，.carry(carry[318])，.a(a[318])，.b(b[318])，
.c(c[318]))；
xtfa i319(.sum(sum[319])，.carry(carry[319])，.a(a[319])，.b(b[319])，
.c(c[319]))；
xtfa i320(.sum(sum[320])，.carry(carry[320])，.a(a[320])，.b(b[320])，
.c(c[320]))；
xtfa i321(.sum(sum[321])，.carry(carry[321])，.a(a[321])，.b(b[321])，
.c(c[321]))；
xtfa i322(.sum(sum[322])，.carry(carry[322])，.a(a[322])，.b(b[322])，
.c(c[322]))；
xtfa i323(.sum(sum[323])，.carry(carry[323])，.a(a[323])，.b(b[323])，
.c(c[323]))；
xtfa i324(.sum(sum[324])，.carry(carry[324])，.a(a[324])，.b(b[324])，
.c(c[324]))；
xtfa i325(.sum(sum[325])，.carry(carry[325])，.a(a[325])，.b(b[325])，
.c(c[325]))；
<dp n="d269"/>
xtfa i326(.sum(sum[326])，.carry(carry[326])，.a(a[326])，.b(b[326])，
.c(c[326]))；
xtfa i327(.sum(sum[327])，.carry(carry[327])，.a(a[327])，.b(b[327])，
.c(c[327]))；
xtfa i328(.sum(sum[328])，.carry(carry[328])，.a(a[328])，.b(b[328])，
.c(c[328]))；
xtfa i329(.sum(sum[329])，.carry(carry[329])，.a(a[329])，.b(b[329])，
.c(c[329]))；
xtfa i330(.sum(sum[330])，.carry(carry[330])，.a(a[330])，.b(b[330])，
.c(c[330]))；
xtfa i331(.sum(sum[331])，.carry(carry[331])，.a(a[331])，.b(b[331])，
.c(c[331]))；
xtfa i332(.sum(sum[332])，.carry(carry[332])，.a(a[332])，.b(b[332])，
.c(c[332]))；
xtfa i333(.sum(sum[333])，.carry(carry[333])，.a(a[333])，.b(b[333])，
.c(c[333]))；
xtfa i334(.sum(sum[334])，.carry(carry[334])，.a(a[334])，.b(b[334])，
.c(c[334]))；
xtfa i335(.sum(sum[335])，.carry(carry[335])，.a(a[335])，.b(b[335])，
.c(c[335]))；
xtfa i336(.sum(sum[336])，.carry(carry[336])，.a(a[336])，.b(b[336])，
.c(c[336]))；
xtfa i337(.sum(sum[337])，.carry(carry[337])，.a(a[337])，.b(b[337])，
.c(c[337]))；
xtfa i338(.sum(sum[338])，.carry(carry[338])，.a(a[338])，.b(b[338])，
.c(c[338]))；
xtfa i339(.sum(sum[339])，.carry(carry[339])，.a(a[339])，.b(b[339])，
.c(c[339]))；
xtfa i340(.sum(sum[340])，.carry(carry[340])，.a(a[340])，.b(b[340])，
.c(c[340]))；
xtfa i341(.sum(sum[341])，.carry(carry[341])，.a(a[341])，.b(b[341])，
.c(c[341]))；
xtfa i342(.sum(sum[342])，.carry(carry[342])，.a(a[342])，.b(b[342])，
.c(c[342]))；
xtfa i343(.sum(sum[343])，.carry(carry[343])，.a(a[343])，.b(b[343])，
.c(c[343]))；
xtfa i344(.sum(sum[344])，.carry(carry[344])，.a(a[344])，.b(b[344])，
.c(c[344]))；
xtfa i345(.sum(sum[345])，.carry(carry[345])，.a(a[345])，.b(b[345])，
.c(c[345]))；
xtfa i346(.sum(sum[346])，.carry(carry[346])，.a(a[346])，.b(b[346])，
.c(c[346]))；
xtfa i347(.sum(sum[347])，.carry(carry[347])，.a(a[347])，.b(b[347])，
.c(c[347]))；
xtfa i348(.sum(sum[348])，.carry(carry[348])，.a(a[348])，.b(b[348])，
.c(c[348]))；
xtfa i349(.sum(sum[349])，.carry(carry[349])，.a(a[349])，.b(b[349])，
.c(c[349]))；
xtfa i350(.sum(sum[350])，.carry(carry[350])，.a(a[350])，.b(b[350])，
.c(c[350]))；
xtfa i351(.sum(sum[351])，.carry(carry[351])，.a(a[351])，.b(b[351])，
.c(c[351]))；
xtfa i352(.sum(sum[352])，.carry(carry[352])，.a(a[352])，.b(b[352])，
.c(c[352]))；
xtfa i353(.sum(sum[353])，.carry(carry[353])，.a(a[353])，.b(b[353])，
.c(c[353]))；
xtfa i354(.sum(sum[354])，.carry(carry[354])，.a(a[354])，.b(b[354])，
.c(c[354]))；
xtfa i355(.sum(sum[355])，.carry(carry[355])，.a(a[355])，.b(b[355])，
.c(c[355]))；
<dp n="d270"/>
xtfa i356(.sum(sum[356])，.carry(carry[356])，.a(a[356])，.b(b[356])，
.c(c[356]))；
xtfa i357(.sum(sum[357])，.carry(carry[357])，.a(a[357])，.b(b[3 57])，
.c(c[357]))；
xtfa i358(.sum(sum[358])，.carry(carry[358])，.a(a[358])，.b(b[3 58])，
.c(c[358]))；
xtfa i359(.sum(sum[359])，.carry(carry[359])，.a(a[359])，.b(b[359])，
.c(c[359]))；
xtfa i360(.sum(sum[360])，.carry(carry[360])，.a(a[360])，.b(b[360])，
.c(c[360]))；
xtfa i361(.sum(sum[361])，.carry(carry[361])，.a(a[361])，.b(b[361])，
.c(c[361]))；
xtfa i362(.sum(sum[362])，.carry(carry[362])，.a(a[362])，.b(b[362])，
.c(c[362]))；
xtfa i363(.sum(sum[363])，.carry(carry[363])，.a(a[363])，.b(b[363])，
.c(c[363]))；
xtfa i364(.sum(sum[364])，.carry(carry[364])，.a(a[364])，.b(b[364])，
.c(c[364]))；
xtfa i365(.sum(sum[365])，.carry(carry[365])，.a(a[365])，.b(b[365])，
.c(c[365]))；
xtfa i366(.sum(sum[366])，.carry(carry[366])，.a(a[366])，.b(b[366])，
.c(c[366]))；
xtfa i367(.sum(sum[367])，.carry(carry[367])，.a(a[367])，.b(b[367])，
.c(c[367]))；
xtfa i368(.sum(sum[368])，.carry(carry[368])，.a(a[368])，.b(b[368])，
.c(c[368]))；
xtfa i369(.sum(sum[369])，.carry(carry[369])，.a(a[369])，.b(b[369])，
.c(c[369]))；
xtfa i370(.sum(sum[370])，.carry(carry[370])，.a(a[370])，.b(b[370])，
.c(c[370]))；
xtfa i371(.sum(sum[371])，.carry(carry[371])，.a(a[371])，.b(b[371])，
.c(c[371]))；
xtfa i372(.sum(sum[372])，.carry(carry[372])，.a(a[372])，.b(b[372])，
.c(c[372]))；
xtfa i373(.sum(sum[373])，.carry(carry[373])，.a(a[373])，.b(b[373])，
.c(c[373]))；
xtfa i374(.sum(sum[374])，.carry(carry[374])，.a(a[374])，.b(b[374])，
.c(c[374]))；
xtfa i375(.sum(sum[375])，.carry(carry[375])，.a(a[375])，.b(b[375])，
.c(c[375]))；
xtfa i376(.sum(sum[376])，.carry(carry[376])，.a(a[376])，.b(b[376])，
.c(c[376]))；
xtfa i377(.sum(sum[377])，.carry(carry[377])，.a(a[377])，.b(b[377])，
.c(c[377]))；
xtfa i378(.sum(sum[378])，.carry(carry[378])，.a(a[378])，.b(b[378])，
.c(c[378]))；
xtfa i379(.sum(sum[379])，.carry(carry[379])，.a(a[379])，.b(b[379])，
.c(c[379]))；
xtfa i380(.sum(sum[380])，.carry(carry[380])，.a(a[380])，.b(b[380])，
.c(c[380]))；
xtfa i381(.sum(sum[381])，.carry(carry[381])，.a(a[381])，.b(b[381])，
.c(c[381]))；
xtfa i382(.sum(sum[382])，.carry(carry[382])，.a(a[382])，.b(b[382])，
.c(c[382]))；
xtfa i383(.sum(sum[383])，.carry(carry[383])，.a(a[383])，.b(b[383])，
.c(c[383]))；
xtfa i384(.sum(sum[384])，.carry(carry[384])，.a(a[384])，.b(b[384])，
.c(c[384]))；
xtfa i385(.sum(sum[385])，.carry(carry[385])，.a(a[385])，.b(b[385])，
.c(c[385]))；
<dp n="d271"/>
xtfa i386(.sum(sum[386])，.carry(carry[386])，.a(a[386])，.b(b[386])，
.c(c[386]))；
xtfa i387(.sum(sum[387])，.carry(carry[387])，.a(a[387])，.b(b[387])，
.c(c[387]))；
xtfa i388(.sum(sum[388])，.carry(carry[388])，.a(a[388])，.b(b[388])，
.c(c[388]))；
xtfa i389(.sum(sum[389])，.carry(carry[389])，.a(a[389])，.b(b[389])，
.c(c[389]))；
xtfa i390(.sum(sum[390])，.carry(carry[390])，.a(a[390])，.b(b[390])，
.c(c[390]))；
xtfa i391(.sum(sum[391])，.carry(carry[391])，.a(a[391])，.b(b[391])，
.c(c[391]))；
xtfa i392(.sum(sum[392])，.carry(carry[392])，.a(a[392])，.b(b[392])，
.c(c[392]))；
xtfa i393(.sum(sum[393])，.carry(carry[393])，.a(a[393])，.b(b[393])，
.c(c[393]))；
xtfa i394(.sum(sum[394])，.carry(carry[394])，.a(a[394])，.b(b[394])，
.c(c[394]))；
xtfa i395(.sum(sum[395])，.carry(carry[395])，.a(a[395])，.b(b[395])，
.c(c[395]))；
xtfa i396(.sum(sum[396])，.carry(carry[396])，.a(a[396])，.b(b[396])，
.c(c[396]))；
xtfa i397(.sum(sum[397])，.carry(carry[397])，.a(a[397])，.b(b[397])，
.c(c[397]))；
xtfa i398(.sum(sum[398])，.carry(carry[398])，.a(a[398])，.b(b[398])，
.c(c[398]))；
xtfa i399(.sum(sum[399])，.carry(carry[399])，.a(a[399])，.b(b[399])，
.c(c[399]))；
xtfa i400(.sum(sum[400])，.carry(carry[400])，.a(a[400])，.b(b[400])，
.c(c[400]))；
xtfa i401(.sum(sum[401])，.carry(carry[401])，.a(a[401])，.b(b[401])，
.c(c[401]))；
xtfa i402(.sum(sum[402])，.carry(carry[402])，.a(a[402])，.b(b[402])，
.c(c[402]))；
xtfa i403(.sum(sum[403])，.carry(carry[403])，.a(a[403])，.b(b[403])，
.c(c[403]))；
xtfa i404(.sum(sum[404])，.carry(carry[404])，.a(a[404])，.b(b[404])，
.c(c[404]))；
xtfa i405(.sum(sum[405])，.carry(carry[405])，.a(a[405])，.b(b[405])，
.c(c[405]))；
xtfa i406(.sum(sum[406])，.carry(carry[406])，.a(a[406])，.b(b[406])，
.c(c[406])))；
xtfa i407(.sum(sum[407])，.carry(carry[407])，.a(a[407])，.b(b[407])，
.c(c[407]))；
xtfa i408(.sum(sum[408])，.carry(carry[408])，.a(a[408])，.b(b[408])，
.c(c[408]))；
xtfa i409(.sum(sum[409])，.carry(carry[409])，.a(a[409])，.b(b[409])，
.c(c[409]))；
xtfa i410(.sum(sum[410])，.carry(carry[410])，.a(a[410])，.b(b[410])，
.c(c[410]))；
xtfa i411(.sum(sum[411])，.carry(carry[411])，.a(a[411])，.b(b[411])，
.c(c[411]))；
xtfa i412(.sum(sum[412])，.carry(carry[412])，.a(a[412])，.b(b[412])，
.c(c[412]))；
xtfa i413(.sum(sum[413])，.carry(carry[413])，.a(a[413])，.b(b[413])，
.c(c[413]))；
xtfa i414(.sum(sum[414])，.carry(carry[414])，.a(a[414])，.b(b[414])，
.c(c[414]))；
xtfa i415(.sum(sum[415])，.carry(carry[415])，.a(a[415])，.b(b[415])，
.c(c[415]))；
<dp n="d272"/>
xtfa i416(.sum(sum[416])，.carry(carry[416])，.a(a[416])，.b(b[416])，
.c(c[416]))；
xtfa i417(.sum(sum[417])，.carry(carry[417])，.a(a[417])，.b(b[417])，
.c(c[417]))；
xtfa i418(.sum(sum[418])，.carry(carry[418])，.a(a[418])，.b(b[418])，
.c(c[418]))；
xtfa i419(.sum(sum[419])，.carry(carry[419])，.a(a[419])，.b(b[419])，
.c(c[419]))；
xtfa i420(.sum(sum[420])，.carry(carry[420])，.a(a[420])，.b(b[420])，
.c(c[420]))；
xtfa i421(.sum(sum[421])，.carry(carry[421])，.a(a[421])，.b(b[421])，
.c(c[421]))；
xtfa i422(.sum(sum[422])，.carry(carry[422])，.a(a[422])，.b(b[422])，
.c(c[422]))；
xtfa i423(.sum(sum[423])，.carry(carry[423])，.a(a[423])，.b(b[423])，
.c(c[423]))；
xtfa i424(.sum(sum[424])，.carry(carry[424])，.a(a[424])，.b(b[424])，
.c(c[424]))；
xtfa i425(.sum(sum[425])，.carry(carry[425])，.a(a[425])，.b(b[425])，
.c(c[425]))；
xtfa i426(.sum(sum[426])，.carry(carry[426])，.a(a[426])，.b(b[426])，
.c(c[426]))；
xtfa i427(.sum(sum[427])，.carry(carry[427])，.a(a[427])，.b(b[427])，
.c(c[427]))；
xtfa i428(.sum(sum[428])，.carry(carry[428])，.a(a[428])，.b(b[428])，
.c(c[428]))
xtfa i429(.sum(sum[429])，.carry(carry[429])，.a(a[429])，.b(b[429])，
.c(c[429]))；
xtfa i430(.sum(sum[430])，.carry(carry[430])，.a(a[430])，.b(b[430])，
.c(c[430]))；
xtfa i431(.sum(sum[431])，.carry(carry[431])，.a(a[431])，.b(b[431])，
.c(c[431]))；
xtfa i432(.sum(sum[432])，.carry(carry[432])，.a(a[432])，.b(b[432])，
.c(c[432]))；
xtfa i433(.sum(sum[433])，.carry(carry[433])，.a(a[433])，.b(b[433])，
.c(c[433]))；
xtfa i434(.sum(sum[434])，.carry(carry[434])，.a(a[434])，.b(b[434])，
.c(c[434]))；
xtfa i435(.sum(sum[435])，.carry(carry[435])，.a(a[435])，.b(b[435])，
.c(c[435]))；
xtfa i436(.sum(sum[436])，.carry(carry[436])，.a(a[436])，.b(b[436])，
.c(c[436]))；
xtfa i437(.sum(sum[437])，.carry(carry[437])，.a(a[437])，.b(b[437])，
.c(c[437]))；
xtfa i438(.sum(sum[438])，.carry(carry[438])，.a(a[438])，.b(b[438])，
.c(c[438]))；
xtfa i439(.sum(sum[439])，.carry(carry[439])，.a(a[439])，.b(b[439])，
.c(c[439]))；
xtfa i440(.sum(sum[440])，.carry(carry[440])，.a(a[440])，.b(b[440])，
.c(c[440]))；
xtfa i441(.sum(sum[441])，.carry(carry[441])，.a(a[441])，.b(b[441])，
.c(c[441]))；
xtfa i442(.sum(sum[442])，.carry(carry[442])，.a(a[442])，.b(b[442])，
.c(c[442]))；
xtfa i443(.sum(sum[443])，.carry(carry[443])，.a(a[443])，.b(b[443])，
.c(c[443]))；
xtfa i444(.sum(sum[444])，.carry(carry[444])，.a(a[444])，.b(b[444])，
.c(c[444]))；
xtfa i445(.sum(sum[445])，.carry(carry[445])，.a(a[445])，.b(b[445])，
.c(c[445]))；
<dp n="d273"/>
xtfa i446(.sum(sum[446])，.carry(carry[446])，.a(a[446])，.b(b[446])，
.c(c[446]))；
xtfa i447(.sum(sum[447])，.carry(carry[447])，.a(a[447])，.b(b[447])，
.c(c[447]))；
xtfa i448(.sum(sum[448])，.carry(carry[448])，.a(a[448])，.b(b[448])，
.c(c[448]))；
xtfa i449(.sum(sum[449])，.carry(carry[449])，.a(a[449])，.b(b[449])，
.c(c[449]))；
xtfa i450(.sum(sum[450])，.carry(carry[450])，.a(a[450])，.b(b[450])，
.c(c[450]))；
xtfa i451(.sum(sum[451])，.carry(carry[451])，.a(a[451])，.b(b[451])，
.c(c[451]))；
xtfa i452(.sum(sum[452])，.carry(carry[452])，.a(a[452])，.b(b[452])，
.c(c[452]))；
xtfa i453(.sum(sum[453])，.carry(carry[453])，.a(a[453])，.b(b[453])，
.c(c[453]))；
xtfa i454(.sum(sum[454])，.carry(carry[454])，.a(a[454])，.b(b[454])，
.c(c[454]))；
xtfa i455(.sum(sum[455])，.carry(carry[455])，.a(a[455])，.b(b[455])，
.c(c[455]))；
xtfa i456(.sum(sum[456])，.carry(carry[456])，.a(a[456])，.b(b[456])，
.c(c[456]))；
xtfa i457(.sum(sum[457])，.carry(carry[457])，.a(a[457])，.b(b[457])，
.c(c[457]))；
xtfa i458(.sum(sum[458])，.carry(carry[458])，.a(a[458])，.b(b[458])，
.c(c[458]))；
xtfa i459(.sum(sum[459])，.carry(carry[459])，.a(a[459])，.b(b[459])，
.c(c[459]))；
xtfa i460(.sum(sum[460])，.carry(carry[460])，.a(a[460])，.b(b[460])，
.c(c[460]))；
xtfa i461(.sum(sum[461])，.carry(carry[461])，.a(a[461])，.b(b[461])，
.c(c[461]))；
xtfa i462(.sum(sum[462])，.carry(carry[462])，.a(a[462])，.b(b[462])，
.c(c[462]))；
xtfa i463(.sum(sum[463])，.carry(carry[463])，.a(a[463])，.b(b[463])，
.c(c[463]))；
xtfa i464(.sum(sum[464])，.carry(carry[464])，.a(a[464])，.b(b[464])，
.c(c[464]))；
xtfa i465(.sum(sum[465])，.carry(carry[465])，.a(a[465])，.b(b[465])，
.c(c[465]))；
xtfa i466(.sum(sum[466])，.carry(carry[466])，.a(a[466])，.b(b[466])，
.c(c[466]))；
xtfa i467(.sum(sum[467])，.carry(carry[467])，.a(a[467])，.b(b[467])，
.c(c[467]))；
xtfa i468(.sum(sum[468])，.carry(carry[468])，.a(a[468])，.b(b[468])，
.c(c[468]))；
xtfa i469(.sum(sum[469])，.carry(carry[469])，.a(a[469])，.b(b[469])，
.c(c[469]))；
xtfa i470(.sum(sum[470])，.carry(carry[470])，.a(a[470])，.b(b[470])，
.c(c[470]))；
xtfa i471(.sum(sum[471])，.carry(carry[471])，.a(a[471])，.b(b[471])，
.c(c[471]))；
xtfa i472(.sum(sum[472])，.carry(carry[472])，.a(a[472])，.b(b[472])，
.c(c[472]))；
xtfa i473(.sum(sum[473])，.carry(carry[473])，.a(a[473])，.b(b[473])，
.c(c[473]))；
xtfa i474(.sum(sum[474])，.carry(carry[474])，.a(a[474])，.b(b[474])，
.c(c[474]))；
xtfa i475(.sum(sum[475])，.carry(carry[475])，.a(a[475])，.b(b[475])，
.c(c[475]))；
<dp n="d274"/>
xtfa i476(.sum(sum[476])，.carry(carry[476])，.a(a[476])，.b(b[476])，
.c(c[476]))；
xtfa i477(.sum(sum[477])，.carry(carry[477])，.a(a[477])，.b(b[477]，
.c(c[477]))；
xtfa i478(.sum(sum[478])，.carry(carry[478])，.a(a[478])，.b(b[478])，
.c(c[478]))；
xtfa i479(.sum(sum[479])，.carry(carry[479])，.a(a[479])，.b(b[479])，
.c(c[479]))；
xtfa i480(.sum(sum[480])，.carry(carry[480])，.a(a[480])，.b(b[480])，
.c(c[480]))；
xtfa i481(.sum(sum[481])，.carry(carry[481])，.a(a[481])，.b(b[481])，
.c(c[481]))；
xtfa i482(.sum(sum[482])，.carry(carry[482])，.a(a[482])，.b(b[482])，
.c(c[482]))；
xtfa i483(.sum(sum[483])，.carry(carry[483])，.a(a[483])，.b(b[483])，
.c(c[483]))；
xtfa i484(.sum(sum[484])，.carry(carry[484])，.a(a[484])，.b(b[484])，
.c(c[484]))；
xtfa i485(.sum(sum[485])，.carry(carry[485])，.a(a[485])，.b(b[485])，
.c(c[485]))；
xtfa i486(.sum(sum[486])，.carry(carry[486])，.a(a[486])，.b(b[486])，
.c(c[486]))；
xtfa i487(.sum(sum[487])，.carry(carry[487])，.a(a[487])，.b(b[487])，
.c(c[487]))；
xtfa i488(.sum(sum[488])，.carry(carry[488])，.a(a[488])，.b(b[488])，
.c(c[488]))；
xtfa i489(.sum(sum[489])，.carry(carry[489])，.a(a[489])，.b(b[489])，
.c(c[489]))；
xtfa i490(.sum(sum[490])，.carry(carry[490])，.a(a[490])，.b(b[490])，
.c(c[490]))；
xtfa i491(.sum(sum[491])，.carry(carry[491])，.a(a[491])，.b(b[491])，
.c(c[491]))；
xtfa i492(.sum(sum[492])，.carry(carry[492])，.a(a[492])，.b(b[492])，
.c(c[492]))；
xtfa i493(.sum(sum[493])，.carry(carry[493])，.a(a[493])，.b(b[493])，
.c(c[493]))；
xtfa i494(.sum(sum[494])，.carry(carry[494])，.a(a[494])，.b(b[494])，
.c(c[494]))；
xtfa i495(.sum(sum[495])，.carry(carry[495])，.a(a[495])，.b(b[495])，
.c(c[495]))；
xtfa i496(.sum(sum[496])，.carry(carry[496])，.a(a[496])，.b(b[496])，
.c(c[496]))；
xtfa i497(.sum(sum[497])，.carry(carry[497])，.a(a[497])，.b(b[497])，
.c(c[497]))；
xtfa i498(.sum(sum[498])，.carry(carry[498])，.a(a[498])，.b(b[498])，
.c(c[498]))；
xtfa i499(.sum(sum[499])，.carry(carry[499])，.a(a[499])，.b(b[499])，
.c(c[499]))；
xtfa i500(.sum(sum[500])，.carry(carry[500])，.a(a[500])，.b(b[500])，
.c(c[500]))；
xtfa i501(.sum(sum[501])，.carry(carry[501])，.a(a[501])，.b(b[501])，
.c(c[501]))；
xtfa i502(.sum(sum[502])，.carry(carry[502])，.a(a[502])，.b(b[502])，
.c(c[502]))；
xtfa i503(.sum(sum[503])，.carry(carry[503])，.a(a[503])，.b(b[503])，
.c(c[503]))；
xtfa i504(.sum(sum[504])，.carry(carry[504])，.a(a[504])，.b(b[504])，
.c(c[504]))；
xtfa i505(.sum(sum[505])，.carry(carry[505])，.a(a[505])，.b(b[505])，
.c(c[505]))；
<dp n="d275"/>
xtfa i506(.sum(sum[506])，.carry(carry[506])，.a(a[506])，.b(b[506])，
.c(c[506]))；
xtfa i507(.sum(sum[507])，.carry(carry[507])，.a(a[507])，.b(b[507])，
.c(c[507]))；
xtfa i508(.sum(sum[508])，.carry(carry[508])，.a(a[508])，.b(b[508])，
.c(c[508]))；
xtfa i509(.sum(sum[509])，.carry(carry[509])，.a(a[509])，.b(b[509])，
.c(c[509]))；
xtfa i510(.sum(sum[510])，.carry(carry[510])，.a(a[510])，.b(b[510])，
.c(c[510]))；
xtfa i511(.sum(sum[511])，.carry(carry[511])，.a(a[511])，.b(b[511])，
.c(c[511]))；
xtfa i512(.sum(sum[512])，.carry(carry[512])，.a(a[512])，.b(b[512])，
.c(c[512]))；
xtfa i513(.sum(sum[513])，.carry(carry[513])，.a(a[513])，.b(b[513])，
.c(c[513]))；
xtfa i514(.sum(sum[514])，.carry(carry[514])，.a(a[514])，.b(b[514])，
.c(c[514]))；
xtfa i515(.sum(sum[515])，.carry(carry[515])，.a(a[515])，.b(b[515])，
.c(c[515]))；
xtfa i516(.sum(sum[516])，.carry(carry[516])，.a(a[5i6])，.b(b[516])，
.c(c[516]))；
xtfa i517(.sum(sum[517])，.carry(carry[517])，.a(a[517])，.b(b[517])，
.c(c[517]))；
xtfa i518(.sum(sum[518])，.carry(carry[518])，.a(a[518])，.b(b[518])，
.c(c[518]))；
xtfa i519(.sum(sum[519])，.carry(carry[519])，.a(a[519])，.b(b[519])，
.c(c[519]))；
xtfa i520(.sum(sum[520])，.carry(carry[520])，.a(a[520])，.b(b[520])，
.c(c[520]))；
xtfa i521(.sum(sum[521])，.carry(carry[521])，.a(a[521])，.b(b[521])，
.c(c[521]))；
xtfa i522(.sum(sum[522])，.carry(carry[522])，.a(a[522])，.b(b[522])，
.c(c[522]))；
xtfa i523(.sum(sum[523])，.carry(carry[523])，.a(a[523])，.b(b[523])，
.c(c[523]))；
xtfa i524(.sum(sum[524])，.carry(carry[524])，.a(a[524])，.b(b[524])，
.c(c[524]))；
xtfa i525(.sum(sum[525])，.carry(carry[525])，.a(a[525])，.b(b[525])，
.c(c[525]))；
xtfa i526(.sum(sum[526])，.carry(carry[526])，.a(a[526])，.b(b[526])，
.c(c[526]))；
xtfa i527(.sum(sum[527])，.carry(carry[527])，.a(a[527])，.b(b[527])，
.c(c[527]))；
xtfa i528(.sum(sum[528])，.carry(carry[528])，.a(a[528])，.b(b[528])，
.c(c[528]))；
xtfa i529(.sum(sum[529])，.carry(carry[529])，.a(a[529])，.b(b[529])，
.c(c[529]))；
xtfa i530(.sum(sum[530])，.carry(carry[530])，.a(a[530])，.b(b[530])，
.c(c[530]))；
xtfa i531(.sum(sum[531])，.carry(carry[531])，.a(a[531])，.b(b[531])，
.c(c[531]))；
xtfa i532(.sum(sum[532])，.carry(carry[532])，.a(a[532])，.b(b[532])，
.c(c[532]))；
xtfa i533(.sum(sum[533])，.carry(carry[533])，.a(a[533])，.b(b[533])，
.c(c[533]))；
xtfa i534(.sum(sum[534])，.carry(carry[534])，.a(a[534])，.b(b[534])，
.c(c[534]))；
xtfa i535(.sum(sum[535])，.carry(carry[535])，.a(a[535])，.b(b[535])，
.c(c[535]))；
<dp n="d276"/>
xtfa i536(.sum(sum[536])，.carry(carry[536])，.a(a[536])，.b(b[536])，
.c(c[536]))；
xtfa i537(.sum(sum[537])，.carry(carry[537])，.a(a(537])，.b(b[537])，
.c(c[537]))；
xtfa i538(.sum(sum[538])，.carry(carry[538])，.a(a[538])，.b(b[538])，
.c(c[538]))；
xtfa i539(.sum(sum[539])，.carry(carry[539])，.a(a[539])，.b(b[539])，
.c(c[539]))；
xtfa i540(.sum(sum[540])，.carry(carry[540])，.a(a[540])，.b(b[540])，
.c(c[540]))；
xtfa i541(.sum(sum[541])，.carry(carry[541])，.a(a[541])，.b(b[541])，
.c(c[541]))；
xtfa i542(.sum(sum[542])，.carry(carry[542])，.a(a[542])，.b(b[542])，
.c(c[542]))；
xtfa i543(.sum(sum[543])，.carry(carry[543])，.a(a[543])，.b(b[543])，
.c(c[543]))；
xtfa i544(.sum(sum[544])，.carry(carry[544])，.a(a[544])，.b(b[544])，
.c(c[544]))；
xtfa i545(.sum(sum[545])，.carry(carry[545])，.a(a[545])，.b(b[545])，
.c(c[545]))；
xtfa i546(.sum(sum[546])，.carry(carry[546])，.a(a[546])，.b(b[546])，
.c(c[546]))；
xtfa i547(.sum(sum[547])，.carry(carry[547])，.a(a[547])，.b(b[547])，
.c(c[547]))；
xtfa i548(.sum(sum[548])，.carry(carry[548])，.a(a[548])，.b(b[548])，
.c(c[548]))；
xtfa i549(.sum(sum[549])，.carry(carry[549])，.a(a[549])，.b(b[549])，
.c(c[549]))；
xtfa i550(.sum(sum[550])，.carry(carry[550])，.a(a[550])，.b(b[550])，
.c(c[550]))；
xtfa i551(.sum(sum[551])，.carry(carry[551])，.a(a[551])，.b(b[551])，
.c(c[551]))；
xtfa i552(.sum(sum[552])，.carry(carry[552])，.a(a[552])，.b(b[552])，
.c(c[552]))；
xtfa i553(.sum(sum[553])，.carry(carry[553])，.a(a[553])，.b(b[553])，
.c(c[553]))；
xtfa i554(.sum(sum[554])，.carry(carry[554])，.a(a[554])，.b(b[554])，
.c(c[554]))；
xtfa i555(.sum(sum[555])，.carry(carry[555])，.a(a[555])，.b(b[555])，
.c(c[555]))；
xtfa i556(.sum(sum[556])，.carry(carry[556])，.a(a[556])，.b(b[556])，
.c(c[556]))；
xtfa i557(.sum(sum[557])，.carry(carry[557])，.a(a[557])，.b(b[557])，
.c(c[557]))；
xtfa i558(.sum(sum[558])，.carry(carry[558])，.a(a[558])，.b(b[558])，
.c(c[558]))；
xtfa i559(.sum(sum[559])，.carry(carry[559])，.a(a[559])，.b(b[559])，
.c(c[559]))；
xtfa i560(.sum(sum[560])，.carry(carry[560])，.a(a[560])，.b(b[560])，
.c(c[560]))；
xtfa i561(.sum(sum[561])，.carry(carry[561])，.a(a[561])，.b(b[561])，
.c(c[561]))；
xtfa i562(.sum(sum[562])，.carry(carry[562])，.a(a[562])，.b(b[562])，
.c(c[562]))；
xtfa i563(.sum(sum[563])，.carry(carry[563])，.a(a[563])，.b(b[563])，
.c(c[563]))；
xtfa i564(.sum(sum[564])，.carry(carry[564])，.a(a[564])，.b(b[564])，
.c(c[564]))；
xtfa i565(.sum(sum[565])，.carry(carry[565])，.a(a[565])，.b(b[565])，
.c(c[565]))；
<dp n="d277"/>
xtfa i566(.sum(sum[566])，.carry(carry[566])，.a(a[566])，.b(b[566])，
.c(c[566]))；
xtfa i567(.sum(sum[567])，.carry(carry[567])，.a(a[567])，.b(b[567])，
.c(c[567]))；
xtfa i568(.sum(sum[568])，.carry(carry[568])，.a(a[568])，.b(b[568])，
.c(c[568]))；
xtfa i569(.sum(sum[569])，.carry(carry[569])，.a(a[569])，.b(b[569])，
.c(c[569]))；
xtfa i570(.sum(sum[570])，.carry(carry[570])，.a(a[570])，.b(b[570])，
.c(c[570]))；
xtfa i571(.sum(sum[571])，.carry(carry[571])，.a(a[571])，.b(b[571])，
.c(c[571]))；
xtfa i572(.sum(sum[572])，.carry(carry[572])，.a(a[572])，.b(b[572])，
.c(c[572]))；
xtfa i573(.sum(sum[573])，.carry(carry[573])，.a(a[573])，.b(b[573])，
.c(c[573]))；
xtfa i574(.sum(sum[574])，.carry(carry[574])，.a(a[574])，.b(b[574])，
.c(c[574]))；
xtfa i575(.sum(sum[575])，.carry(carry[575])，.a(a[575])，.b(b[575])，
.c(c[575]))；
xtfa i576(.sum(sum[576])，.carry(carry[576])，.a(a[576])，.b(b[576])，
.c(c[576]))；
xtfa i577(.sum(sum[577])，.carry(carry[577])，.a(a[577])，.b(b[577])，
.c(c[577]))；
xtfa i578(.sum(sum[578])，.carry(carry[578])，.a(a[578])，.b(b[578])，
.c(c[578]))；
xtfa i579(.sum(sum[579])，.carry(carry[579])，.a(a[579])，.b(b[579])，
.c(c[579]))；
xtfa i580(.sum(sum[580])，.carry(carry[580])，.a(a[580])，.b(b[580])，
.c(c[580]))；
xtfa i581(.sum(sum[581])，.carry(carry[581])，.a(a[581])，.b(b[581])，
.c(c[581]))；
xtfa i582(.sum(sum[582])，.carry(carry[582])，.a(a[582])，.b(b[582])，
.c(c[582]))；
xtfa i583(.sum(sum[583])，.carry(carry[583])，.a(a[583])，.b(b[583])，
.c(c[583]))；
xtfa i584(.sum(sum[584])，.carry(carry[584])，.a(a[584])，.b(b[584])，
.c(c[584]))；
xtfa i585(.sum(sum[585])，.carry(carry[585])，.a(a[585])，.b(b[585])，
.c(c[585]))；
xtfa i586(.sum(sum[586])，.carry(carry[586])，.a(a[586])，.b(b[586])，
.c(c[586]))；
xtfa i587(.sum(sum[587])，.carry(carry[587])，.a(a[587])，.b(b[587])，
.c(c[587]))；
xtfa i588(.sum(sum[588])，.carry(carry[588])，.a(a[588])，.b(b[588])，
.c(c[588]))；
xtfa i589(.sum(sum[589])，.carry(carry[589])，.a(a[589])，.b(b[589])，
.c(c[589]))；
xtfa i590(.sum(sum[590])，.carry(carry[590])，.a(a[590])，.b(b[590])，
.c(c[590]))；
xtfa i591(.sum(sum[591])，.carry(carry[591])，.a(a[591])，.b(b[591])，
.c(c[591]))；
xtfa i592(.sum(sum[592])，.carry(carry[592])，.a(a[592])，.b(b[592])，
.c(c[592]))；
xtfa i593(.sum(sum[593])，.carry(carry[593])，.a(a[593])，.b(b[593])，
.c(c[593]))；
xtfa i594(.sum(sum[594])，.carry(carry[594])，.a(a[594])，.b(b[594])，
.c(c[594]))；
xtfa i595(.sum(sum[595])，.carry(carry[595])，.a(a[595])，.b(b[595])，
.c(c[595]))；
<dp n="d278"/>
xtfa i596(.sum(sum[596])，.carry(carry[596])，.a(a[596])，.b(b[596])，
.c(c[596]))；
xtfa i597(.sum(sum[597])，.carry(carry[597])，.a(a[597])，.b(b[597])，
.c(c[597]))；
xtfa i598(.sum(sum[598])，.carry(carry[598])，.a(a[598])，.b(b[598])，
.c(c[598]))；
xtfa i599(.sum(sum[599])，.carry(carry[599])，.a(a[599])，.b(b[599])，
.c(c[599]))；
xtfa i600(.sum(sum[600])，.carry(carry[600])，.a(a[600])，.b(b[600])，
.c(c[600]))；
xtfa i601(.sum(sum[601])，.carry(carry[601])，.a(a[601])，.b(b[601])，
.c(c[601]))；
xtfa i602(.sum(sum[602])，.carry(carry[602])，.a(a[602])，.b(b[602])，
.c(c[602]))；
xtfa i603(.sum(sum[603])，.carry(carry[603])，.a(a[603])，.b(b[603])，
.c(c[603]))；
xtfa i604(.sum(sum[604])，.carry(carry[604])，.a(a[604])，.b(b[604])，
.c(c[604]))；
xtfa i605(.sum(sum[605])，.carry(carry[605])，.a(a[605])，.b(b[605])，
.c(c[605]))；
xtfa i606(.sum(sum[606])，.carry(carry[606])，.a(a[606])，.b(b[606])，
.c(c[606]))；
xtfa i607(.sum(sum[607])，.carry(carry[607])，.a(a[607])，.b(b[607])，
.c(c[607]))；
xtfa i608(.sum(sum[608])，.carry(carry[608])，.a(a[608])，.b(b[608])，
.c(c[608]))；
xtfa i609(.sum(sum[609])，.carry(carry[609])，.a(a[609])，.b(b[609])，
.c(c[609]))；
xtfa i610(.sum(sum[610])，.carry(carry[610])，.a(a[610])，.b(b[610])，
.c(c[610]))；
xtfa i611(.sum(sum[611])，.carry(carry[611])，.a(a[611])，.b(b[611])，
.c(c[611]))；
xtfa i612(.sum(sum[612])，.carry(carry[612])，.a(a[612])，.b(b[612])，
.c(c[612]))；
xtfa i613(.sum(sum[613])，.carry(carry[613])，.a(a[613])，.b(b[613])，
.c(c[613]))；
xtfa i614(.sum(sum[614])，.carry(carry[614])，.a(a[614])，.b(b[614])，
.c(c[614]))；
xtfa i615(.sum(sum[615])，.carry(carry[615])，.a(a[615])，.b(b[615])，
.c(c[615]))；
xtfa i616(.sum(sum[616])，.carry(carry[616])，.a(a[616])，.b(b[616])，
.c(c[616]))；
xtfa i617(.sum(sum[617])，.carry(carry[617])，.a(a[617])，.b(b[617])，
.c(c[617]))；
xtfa i618(.sum(sum[618])，.carry(carry[618])，.a(a[618])，.b(b[618])，
.c(c[618]))；
xtfa i619(.sum(sum[619])，.carry(carry[619])，.a(a[619])，.b(b[619])，
.c(c[619]))；
xtfa i620(.sum(sum[620])，.carry(carry[620])，.a(a[620])，.b(b[620])，
.c(c[620]))；
xtfa i621(.sum(sum[621])，.carry(carry[621])，.a(a[621])，.b(b[621])，
.c(c[621]))；
xtfa i622(.8um(sum[622])，.carry(carry[622])，.a(a[622])，.b(b[622])，
.c(c[622]))；
xtfa i623(.sum(sum[623])，.carry(carry[623])，.a(a[623])，.b(b[623])，
.c(c[623]))；
xtfa i624(.sum(sum[624])，.carry(carry[624])，.a(a[624])，.b(b[624])，
.c(c[624]))；
xtfa i625(.sum(sum[625])，.carry(carry[625])，.a(a[625])，.b(b[625])，
.c(c[625]))；
<dp n="d279"/>
xtfa i626(.sum(sum[626])，.carry(carry[626])，.a(a[626])，.b(b[626])，
.c(c[626]))；
xtfa i627(.sum(sum[627])，.carry(carry[627])，.a(a[627])，.b(b[627])，
.c(c[627]))；
xtfa i628(.sum(sum[628])，.carry(carry[628])，.a(a[628])，.b(b[628])，
.c(c[628]))；
xtfa i629(.sum(sum[629])，.carry(carry[629])，.a(a[629])，.b(b[629]，
.c(c[629]))；
xtfa i630(.sum(sum[630])，.carry(carry[630])，.a(a[630])，.b(b[630])，
.c(c[630]))；
xtfa i631(.sum(sum[631])，.carry(carry[631])，.a(a[631])，.b(b[631])，
.c(c[631]))；
xtfa i632(.sum(sum[632])，.carry(carry[632])，.a(a[632])，.b(b[632])，
.c(c[632]))；
xtfa i633(.sum(sum[633])，.carry(carry[633])，.a(a[633])，.b(b[633])，
.c(c[633]))；
xtfa i634(.sum(sum[634])，.carry(carry[634])，.a(a[634])，.b(b[634])，
.c(c[634]))；
xtfa i635(.sum(sum[635])，.carry(carry[635])，.a(a[635])，.b(b[635])，
.c(c[635]))；
xtfa i636(.sum(sum[636])，.carry(carry[636])，.a(a[636])，.b(b[636])，
.c(c[636]))；
xtfa i637(.sum(sum[637])，.carry(carry[637])，.a(a[637])，.b(b[637])，
.c(c[637]))；
xtfa i638(.sum(sum[638])，.carry(carry[638])，.a(a[638])，.b(b[638])，
.c(c[638]))；
xtfa i639(.sum(sum[639])，.carry(carry[639])，.a(a[639])，.b(b[639])，
.c(c[639]))；
xtfa i640(.sum(sum[640])，.carry(carry[640])，.a(a[640])，.b(b[640])，
.c(c[640]))；
xtfa i641(.sum(sum[641])，.carry(carry[641])，.a(a[641])，.b(b[641])，
.c(c[641]))；
xtfa i642(.sum(sum[642])，.carry(carry[642])，.a(a[642])，.b(b[642])，
.c(c[642]))；
xtfa i643(.sum(sum[643])，.carry(carry[643])，.a(a[643])，.b(b[643])，
.c(c[643]))；
xtfa i644(.sum(sum[644])，.carry(carry[644])，.a(a[644])，.b(b[644])，
.c(c[644]))；
xtfa i645(.sum(sum[645])，.carry(carry[645])，.a(a[645])，.b(b[645])，
.c(c[645]))；
xtfa i646(.sum(sum[646])，.carry(carry[646])，.a(a[646])，.b(b[646])，
.c(c[646]))；
xtfa i647(.sum(sum[647])，.carry(carry[647])，.a(a[647])，.b(b[647])，
.c(c[647]))；
xtfa i648(.sum(sum[648])，.carry(carry[648])，.a(a[648])，.b(b[648])，
.c(c[648]))；
xtfa i649(.sum(sum[649])，.carry(carry[649])，.a(a[649])，.b(b[649])，
.c(c[649]))；
xtfa i650(.sum(sum[650])，.carry(carry[650])，.a(a[650])，.b(b[650])，
.c(c[650]))；
xtfa i651(.sum(sum[651])，.carry(carry[651])，.a(a[651])，.b(b[651])，
.c(c[651]))；
xtfa i652(.sum(sum[652])，.carry(carry[652])，.a(a[652])，.b(b[652])，
.c(c[652]))；
xtfa i653(.sum(sum[653])，.carry(carry[653])，.a(a[653])，.b(b[653])，
.c(c[653]))；
xtfa i654(.sum(sum[654])，.carry(carry[654])，.a(a[654])，.b(b[654])，
.c(c[654]))；
xtfa i655(.sum(sum[655])，.carry(carry[655])，.a(a[655])，.b(b[655])，
.c(c[655]))；
<dp n="d280"/>
xtfa i656(.sum(sum[656])，.carry(carry[656])，.a(a[656])，.b(b[656])，
.c(c[656]))；
xtfa i657(.sum(sum[657])，.carry(carry[657])，.a(a[657])，.b(b[657])，
.c(c[657]))；
xtfa i658(.sum(sum[658])，.carry(carry[658])，.a(a[658])，.b(b[658])，
.c(c[658]))；
xtfa i659(.sum(sum[659])，.carry(carry[659])，.a(a[659])，.b(b[659])，
.c(c[659]))；
xtfa i660(.sum(sum[660])，.carry(carry[660])，.a(a[660])，.b(b[660])，
.c(c[660]))；
xtfa i661(.sum(sum[661])，.carry(carry[661])，.a(a[661])，.b(b[661])，
.c(c[661]))；
xtfa i662(.sum(sum[662])，.carry(carry[662])，.a(a[662])，.b(b[662])，
.c(c[662]))；
xtfa i663(.sum(sum[663])，.carry(carry[663])，.a(a[663])，.b(b[663])，
.c(c[663]))；
xtfa i664(.sum(sum[664])，.carry(carry[664])，.a(a[664])，.b(b[664])，
.c(c[664]))；
xtfa i665(.sum(sum[665])，.carry(carry[665])，.a(a[665])，.b(b[665])，
.c(c[665]))；
xtfa i666(.sum(sum[666])，.carry(carry[666])，.a(a[666])，.b(b[666])，
.c(c[666]))；
xtfa i667(.sum(sum[667])，.carry(carry[667])，.a(a[667])，.b(b[667])，
.c(c[667]))；
xtfa i668(.sum(sum[668])，.carry(carry[668])，.a(a[668])，.b(b[668])，
.c(c[668]))；
xtfa i669(.sum(sum[669])，.carry(carry[669])，.a(a[669])，.b(b[669])，
.c(c[669]))；
xtfa i670(.sum(sum[670])，.carry(carry[670])，.a(a[670])，.b(b[670])，
.c(c[670]))；
xtfa i671(.sum(sum[671])，.carry(carry[671])，.a(a[671])，.b(b[671])，
.c(c[671]))；
xtfa i672(.sum(sum[672])，.carry(carry[672])，.a(a[672])，.b(b[672])，
.c(c[672]))；
xtfa i673(.sum(sum[673])，.carry(carry[673])，.a(a[673])，.b(b[673])，
.c(c[673]))；
xtfa i674(.sum(sum[674])，.carry(carry[674])，.a(a[674])，.b(b[674])，
.c(c[674]))；
xtfa i675(.sum(sum[675])，.carry(carry[675])，.a(a[675])，.b(b[675])，
.c(c[675]))；
xtfa i676(.sum(sum[676])，.carry(carry[676])，.a(a[676])，.b(b[676])，
.c(c[676]))；
xtfa i677(.sum(sum[677])，.carry(carry[677])，.a(a[677])，.b(b[677])，
.c(c[677]))；
xtfa i678(.sum(sum[678])，.carry(carry[678])，.a(a[678])，.b(b[678])，
.c(c[678]))；
xtfa i679(.sum(sum[679])，.carry(carry[679])，.a(a[679])，.b(b[679])，
.c(c[679]))；
xtfa i680(.sum(sum[680])，.carry(carry[680])，.a(a[680])，.b(b[680])，
.c(c[680]))；
xtfa i681(.sum(sum[681])，.carry(carry[681])，.a(a[681])，.b(b[681])，
.c(c[681]))；
xtfa i682(.sum(sum[682])，.carry(carry[682])，.a(a[682])，.b(b[682])，
.c(c[682]))；
xtfa i683(.sum(sum[683])，.carry(carry[683])，.a(a[683])，.b(b[683])，
.c(c[683]))；
xtfa i684(.sum(sum[684])，.carry(carry[684])，.a(a[684])，.b(b[684])，
.c(c[684]))；
xtfa i685(.sum(sum[685])，.carry(carry[685])，.a(a[685])，.b(b[685])，
.c(c[685]))；
<dp n="d281"/>
xtfa i686(.sum(sum[686])，.carry(carry[686])，.a(a[686])，.b(b[686])，
.c(c[686]))；
xtfa i687(.sum(sum[687])，.carry(carry[687])，.a(a[687])，.b(b[687])，
.c(c[687]))；
xtfa i688(.sum(sum[688])，.carry(carry[688])，.a(a[688])，.b(b[688])，
.c(c[688]))；
xtfa i689(.sum(sum[689])，.carry(carry[689])，.a(a[689])，.b(b[689])，
.c(c[689]))；
xtfa i690(.sum(sum[690])，.carry(carry[690])，.a(a[690])，.b(b[690])，
.c(c[690]))；
xtfa i691(.sum(sum[691])，.carry(carry[691])，.a(a[691])，.b(b[691])，
.c(c[691]))；
xtfa i692(.sum(sum[692])，.carry(carry[692])，.a(a[692])，.b(b[692])，
.c(c[692]))；
xtfa i693(.sum(sum[693])，.carry(carry[693])，.a(a[693])，.b(b[693])，
.c(c[693]))；
xtfa i694(.sum(sum[694])，.carry(carry[694])，.a(a[694])，.b(b[694])，
.c(c[694]))；
xtfa i695(.sum(sum[695])，.carry(carry[695])，.a(a[695])，.b(b[695])，
.c(c[695]))；
xtfa i696(.sum(sum[696])，.carry(carry[696])，.a(a[696])，.b(b[696])，
.c(c[696]))；
xtfa i697(.sum(sum[697])，.carry(carry[697])，.a(a[697])，.b(b[697])，
.c(c[697]))；
xtfa i698(.sum(sum[698])，.carry(carry[698])，.a(a[698])，.b(b[698])，
.c(c[698]))；
xtfa i699(.sum(sum[699])，.carry(carry[699])，.a(a[699])，.b(b[699])，
.c(c[699]))；
xtfa i700(.sum(sum[700])，.carry(carry[700])，.a(a[700])，.b(b[700])，
.c(c[700]))；
xtfa i701(.sum(sum[701])，.carry(carry[701])，.a(a[701])，.b(b[701])，
.c(c[701]))；
xtfa i702(.sum(sum(702])，.carry(carry[702])，.a(a[702])，.b(b[702])，
.c(c[702]))；
xtfa i703(.sum(sum[703])，.carry(carry[703])，.a(a[703])，.b(b[703])，
.c(c[703]))；
xtfa i704(.sum(sum[704])，.carry(carry[704])，.a(a[704])，.b(b[704])，
.c(c[704]))；
xtfa i705(.sum(sum[705])，.carry(carry[705])，.a(a[705])，.b(b[705])，
.c(c[705]))；
xtfa i706(.sum(sum[706])，.carry(carry[706])，.a(a[706])，.b(b[706])，
.c(c[706]))；
xtfa i707(.sum(sum[707])，.carry(carry[707])，.a(a[707])，.b(b[707])，
.c(c[707]))；
xtfa i708(.sum(sum[708])，.carry(carry[708])，.a(a[708])，.b(b[708])，
.c(c[708]))；
xtfa i709(.sum(sum[709])，.carry(carry[709])，.a(a[709])，.b(b[709])，
.c(c[709]))；
xtfa i710(.sum(sum[710])，.carry(carry[710])，.a(a[710])，.b(b[710])，
.c(c[710]))；
xtfa i711(.sum(sum[711])，.carry(carry[711])，.a(a[711])，.b(b[711])，
.c(c[711]))；
xtfa i712(.sum(sum[712])，.carry(carry[712])，.a(a[712])，.b(b[712])，
.c(c[712]))；
xtfa i713(.sum(sum[713])，.carry(carry[713])，.a(a[713])，.b(b[713])，
.c(c[713]))；
xtfa i714(.sum(sum[714])，.carry(carry[714])，.a(a[714])，.b(b[714])，
.c(c[714]))；
xtfa i715(.sum(sum[715])，.carry(carry[715])，.a(a[715])，.b(b[715])，
.c(c[715]))；
<dp n="d282"/>
xtfa i716(.sum(sum[716])，.carry(carry[716])，.a(a[716])，.b(b[716])，
.c(c[716]))；
xtfa i717(.sum(sum[717])，.carry(carry[717])，.a(a[717])，.b(b[717])，
.c(c[717]))；
xtfa i718(.sum(sum[718])，.carry(carry[718])，.a(a[718])，.b(b[718])，
.c(c[718]))；
xtfa i719(.sum(sum[719])，.carry(carry[719])，.a(a[719])，.b(b[719])，
.c(c[719]))；
xtfa i720(.sum(sum[720])，.carry(carry[720])，.a(a[720])，.b(b[720])，
.c(c[720]))；
xtfa i721(.sum(sum[721])，.carry(carry[721])，.a(a[721])，.b(b[721])，
.c(c[721]))；
xtfa i722(.sum(sum[722])，.carry(carry[722])，.a(a[722])，.b(b[722])，
.c(c[722]))；
xtfa i723(.sum(sum[723])，.carry(carry[723])，.a(a[723])，.b(b[723])，
.c(c[723]))；
xtfa i724(.sum(sum[724])，.carry(carry[724])，.a(a[724])，.b(b[724])，
.c(c[724]))；
xtfa i725(.sum(sum[725])，.carry(carry[725])，.a(a[725])，.b(b[725])，
.c(c[725]))；
xtfa i726(.sum(sum[726])，.carry(carry[726])，.a(a[726])，.b(b[726])，
.c(c[726]))；
xtfa i727(.sum(sum[727])，.carry(carry[727])，.a(a[727])，.b(b[727])，
.c(c[727]))；
xtfa i728(.sum(sum[728])，.carry(carry[728])，.a(a[728])，.b(b[728])，
.c(c[728]))；
xtfa i729(.sum(sum[729])，.carry(carry[729])，.a(a[729])，.b(b[729])，
.c(c[729]))；
xtfa i730(.sum(sum[730])，.carry(carry[730])，.a(a[730])，.b(b[730])，
.c(c[730]))；
xtfa i731(.sum(sum[731])，.carry(carry[731])，.a(a[731])，.b(b[731])，
.c(c[731]))；
xtfa i732(.sum(sum[732])，.carry(carry[732])，.a(a[732])，.b(b[732])，
.c(c[732]))；
xtfa i733(.sum(sum[733])，.carry(carry[733])，.a(a[733])，.b(b[733])，
.c(c[733]))；
xtfa i734(.sum(sum[734])，.carry(carry[734])，.a(a[734])，.b(b[734])，
.c(c[734]))；
xtfa i735(.sum(sum[735])，.carry(carry[735])，.a(a[735])，.b(b[735])，
.c(c[735]))；
xtfa i736(.sum(sum[736])，.carry(carry[736])，.a(a[736])，.b(b[73 6])，
.c(c[736]))；
xtfa i737(.sum(sum[737])，.carry(carry[737])，.a(a[737])，.b(b[737])，
.c(c[737]))；
xtfa i738(.sum(sum[738])，.carry(carry[738])，.a(a[738])，.b(b[738])，
.c(c[738]))；
xtfa i739(.sum(sum[739])，.carry(carry[739])，.a(a[739])，.b(b[739])，
.c(c[739]))；
xtfa i740(.sum(sum[740])，.carry(carry[740])，.a(a[740])，.b(b[740])，
.c(c[740]))；
xtfa i741(.sum(sum[741])，.carry(carry[741])，.a(a[741])，.b(b[741])，
.c(c[741]))；
xtfa i742(.sum(sum[742])，.carry(carry[742])，.a(a[742])，.b(b[742])，
.c(c[742]))；
xtfa i743(.sum(sum[743])，.carry(carry[743])，.a(a[743])，.b(b[743])，
.c(c[743]))；
xtfa i744(.sum(sum[744])，.carry(carry[744])，.a(a[744])，.b(b[744])，
.c(c[744]))；
xtfa i745(.sum(sum[745])，.carry(carry[745])，.a(a[745])，.b(b[745])，
.c(c[745]))；
<dp n="d283"/>
xtfa i746(.sum(sum[746])，.carry(carry[746])，.a(a[746])，.b(b[746])，
.c(c[746]))；
xtfa i747(.sum(sum[747])，.carry(carry[747])，.a(a[747])，.b(b[747])，
.c(c[747]))；
xtfa i748(.sum(sum[748])，.carry(carry[748])，.a(a[748])，.b(b[748])，
.c(c[748]))；
xtfa i749(.sum(sum[749])，.carry(carry[749])，.a(a[749])，.b(b[749])，
.c(c[749]))；
xtfa i750(.sum(sum[750])，.carry(carry[750])，.a(a[750])，.b(b[750])，
.c(c[750]))；
xtfa i751(.sum(sum[751])，.carry(carry[751])，.a(a[751])，.b(b[751])，
.c(c[751]))；
xtfa i752(.sum(sum[752])，.carry(carry[752])，.a(a[752])，.b(b[752])，
.c(c[752]))；
xtfa i753(.sum(sum[753])，.carry(carry[753])，.a(a[753])，.b(b[753])，
.c(c[753]))；
xtfa i754(.sum(sum[754])，.carry(carry[754])，.a(a[754])，.b(b[754])，
.c(c[754]))；
xtfa i755(.sum(sum[755])，.carry(carry[755])，.a(a[755])，.b(b[755])，
.c(c[755]))；
xtfa i756(.sum(sum[756])，.carry(carry[756])，.a(a[756])，.b(b[756])，
.c(c[756]))；
xtfa i757(.sum(sum[757])，.carry(carry[757])，.a(a[757])，.b(b[757])，
.c(c[757]))；
xtfa i758(.sum(sum[758])，.carry(carry[758])，.a(a[758])，.b(b[758])，
.c(c[758]))；
xtfa i759(.sum(sum[759])，.carry(carry[759])，.a(a[759])，.b(b[759])，
.c(c[759]))；
xtfa i760(.sum(sum[760])，.carry(carry[760])，.a(a[760])，.b(b[760])，
.c(c[760]))；
xtfa i761(.sum(sum[761])，.carry(carry[761])，.a(a[761])，.b(b[761])，
.c(c[761]))；
xtfa i762(.sum(sum[762])，.carry(carry[762])，.a(a[762])，.b(b[762])，
.c(c[762]))；
xtfa i763(.sum(sum[763])，.carry(carry[763])，.a(a[763])，.b(b[763])，
.c(c[763]))；
xtfa i764(.sum(sum[764])，.carry(carry[764])，.a(a[764])，.b(b[764])，
.c(c[764]))；
xtfa i765(.sum(sum[765])，.carry(carry[765])，.a(a[765])，.b(b[765])，
.c(c[765]))；
xtfa i766(.sum(sum[766])，.carry(carry[766])，.a(a[766])，.b(b[766])，
.c(c[766]))；
xtfa i767(.sum(sum[767])，.carry(carry[767])，.a(a[767])，.b(b[767])，
.c(c[767]))；
xtfa i768(.sum(sum[768])，.carry(carry[768])，.a(a[768])，.b(b[768])，
.c(c[768]))；
xtfa i769(.sum(sum[769])，.carry(carry[769])，.a(a[769])，.b(b[769])，
.c(c[769]))；
xtfa i770(.sum(sum[770])，.carry(carry[770])，.a(a[770])，.b(b[770])，
.c(c[770]))；
xtfa i771(.sum(sum[771])，.carry(carry[771])，.a(a[771])，.b(b[771])，
.c(c[771]))；
xtfa i772(.sum(sum[772])，.carry(carry[772])，.a(a[772])，.b(b[772])，
.c(c[772]))；
xtfa i773(.sum(sum[773])，.carry(carry[773])，.a(a[773])，.b(b[773])，
.c(c[773]))；
xtfa i774(.sum(sum[774])，.carry(carry[774])，.a(a[774])，.b(b[774])，
.c(c[774]))；
xtfa i775(.sum(sum[775])，.carry(carry[775])，.a(a[775])，.b(b[775])，
.c(c[775]))；
<dp n="d284"/>
xtfa i776(.sum(sum[776])，.carry(carry[776])，.a(a[776])，.b(b[776])，
.c(c[776]))；
xtfa i777(.sum(sum[777])，.carry(carry[777])，.a(a[777])，.b(b[777])，
.c(c[777]))；
xtfa i778(.sum(sum[778])，.carry(carry[778])，.a(a[778])，.b(b[778])，
.c(c[778]))；
xtfa i779(.sum(sum[779])，.carry(carry[779])，.a(a[779])，.b(b[779])，
.c(c[779]))；
xtfa i780(.sum(sum[780])，.carry(carry[780])，.a(a[780])，.b(b[780])，
.c(c[780]))；
xtfa i781(.sum(sum[781])，.carry(carry[781])，.a(a[781])，.b(b[781])，
.c(c[781]))；
xtfa i782(.sum(sum[782])，.carry(carry[782])，.a(a[782])，.b(b[782])，
.c(c[782]))；
xtfa i783(.sum(sum[783])，.carry(carry[783])，.a(a[783])，.b(b[783])，
.c(c[783]))；
xtfa i784(.sum(sum[784])，.carry(carry[784])，.a(a[784])，.b(b[784])，
.c(c[784]))；
xtfa i785(.sum(sum[785])，.carry(carry[785])，.a(a[785])，.b(b[785])，
.c(c[785]))；
xtfa i786(.sum(sum[786])，.carry(carry[786])，.a(a[786])，.b(b[786])，
.c(c[786]))；
xtfa i787(.sum(sum[787])，.carry(carry[787])，.a(a[787])，.b(b[787])，
.c(c[787]))；
xtfa i788(.sum(sum[788])，.carry(carry[788])，.a(a[788])，.b(b[788])，
.c(c[788]))；
xtfa i789(.sum(sum[789])，.carry(carry[789])，.a(a[789])，.b(b[789])，
.c(c[789]))；
xtfa i790(.sum(sum[790])，.carry(carry[790])，.a(a[790])，.b(b[790])，
.c(c[790]))；
xtfa i791(.sum(sum[791])，.carry(carry[791])，.a(a[791])，.b(b[791])，
.c(c[791]))；
xtfa i792(.sum(sum[792])，.carry(carry[792])，.a(a[792])，.b(b[792])，
.c(c[792]))；
xtfa i793(.sum(sum[793])，.carry(carry[793])，.a(a[793])，.b(b[793])，
.c(c[793]))；
xtfa i794(.sum(sum[794])，.carry(carry[794])，.a(a[794])，.b(b[794])，
.c(c [794]))；
xtfa i795(.sum(sum[795])，.carry(carry[795])，.a(a[795])，.b(b[795])，
.c(c[795]))；
xtfa i796(.sum(sum[796])，.carry(carry[796])，.a(a[796])，.b(b[796])，
.c(c[796]))；
xtfa i797(.sum(sum[797])，.carry(carry[797])，.a(a[797])，.b(b[797])，
.c(c[797]))；
xtfa i798(.sum(sum[798])，.carry(carry[798])，.a(a[798])，.b(b[798])，
.c(c[798]))；
xtfa i799(.sum(sum[799])，.carry(carry[799])，.a(a[799])，.b(b[799])，
.c(c[799]))；
xtfa i800(.sum(sum[800])，.carry(carry[800])，.a(a[800])，.b(b[800])，
.c(c[800]))；
xtfa i801(.sum(sum[801])，.carry(carry[801])，.a(a[801])，.b(b[801])，
.c(c[801]))；
xtfa i802(.sum(sum[802])，.carry(carry[802])，.a(a[802])，.b(b[802])，
.c(c[802]))；
xtfa i803(.sum(sum[803])，.carry(carry[803])，.a(a[803])，.b(b[803])，
.c(c[803]))；
xtfa i804(.sum(sum[804])，.carry(carry[804])，.a(a[804])，.b(b[804])，
.c(c[804]))；
xtfa i805(.sum(sum[805])，.carry(carry[805])，.a(a[805])，.b(b[805])，
.c(c[805]))；
<dp n="d285"/>
xtfa i806(.sum(sum[806])，.carry(carry[806])，.a(a[806])，.b(b[806])，
.c(c[806]))；
xtfa i807(.sum(sum[807])，.carry(carry[807])，.a(a[807])，.b(b[807])，
.c(c[807]))；
xtfa i808(.sum(sum[808])，.carry(carry[808])，.a(a[808])，.b(b[808])，
.c(c[808]))；
xtfa i809(.sum(sum[809])，.carry(carry[809])，.a(a[809])，.b(b[809])，
.c(c[809]))；
xtfa i810(.sum(sum[810])，.carry(carry[810])，.a(a[810])，.b(b[810])，
.c(c[810]))；
xtfa i811(.sum(sum[811])，.carry(carry[811])，.a(a[811])，.b(b[811])，
.c(c[811]))；
xtfa i812(.sum(sum[812])，.carry(carry[812])，.a(a[812])，.b(b[812])，
.c(c[812]))；
xtfa i813(.sum(sum[813])，.carry(carry[813])，.a(a[813])，.b(b[813])，
.c(c[813]))；
xtfa i814(.sum(sum[814])，.carry(carry[814])，.a(a[814])，.b(b[814])，
.c(c[814]))；
xtfa i815(.sum(sum[815])，.carry(carry[815])，.a(a[815])，.b(b[815])，
.c(c[815]))；
xtfa i816(.sum(sum[816])，.carry(carry[816])，.a(a[816])，.b(b[816])，
.c(c[816]))；
xtfa i817(.sum(sum[817])，.carry(carry[817])，.a(a[817])，.b(b[817])，
.c(c[817]))；
xtfa i818(.sum(sum[818])，.carry(carry[818])，.a(a[818])，.b(b[818])，
.c(c[818]))；
xtfa i819(.sum(sum[819])，.carry(carry[819])，.a(a[819])，.b(b[819])，
.c(c[819]))；
xtfa i820(.sum(sum[820])，.carry(carry[820])，.a(a[820])，.b(b[820])，
.c(c[820]))；
xtfa i821(.sum(sum[821])，.carry(carry[821])，.a(a[821])，.b(b[821])，
.c(c[821]))；
xtfa i822(.sum(sum[822])，.carry(carry[822])，.a(a[822])，.b(b[822])，
.c(c[822]))；
xtfa i823(.sum(sum[823])，.carry(carry[823])，.a(a[823])，.b(b[823])，
.c(c[823]))；
xtfa i824(.sum(sum[824])，.carry(carry[824])，.a(a[824])，.b(b[824])，
.c(c[824]))；
xtfa i825(.sum(sum[825])，.carry(carry[825])，.a(a[825])，.b(b[825])，
.c(c[825]))；
xtfa i826(.sum(sum[826])，.carry(carry[826])，.a(a[826])，.b(b[826])，
.c(c[826]))；
xtfa i827(.sum(sum[827])，.carry(carry[827])，.a(a[827])，.b(b[827])，
.c(c[827]))；
xtfa i828(.sum(sum[828])，.carry(carry[828])，.a(a[828])，.b(b[828])，
.c(c[828]))；
xtfa i829(.sum(sum[829])，.carry(carry[829])，.a(a[829])，.b(b[829])，
.c(c[829]))；
xtfa i830(.sum(sum[830])，.carry(carry[830])，.a(a[830])，.b(b[830])，
.c(c[830]))；
xtfa i831(.sum(sum[831])，.carry(carry[831])，.a(a[831])，.b(b[831])，
.c(c[831]))；
xtfa i832(.sum(sum[832])，.carry(carry[832])，.a(a[832])，.b(b[832])，
.c(c[832]))；
xtfa i833(.sum(sum[833])，.carry(carry[833])，.a(a[833])，.b(b[833])，
.c(c[833]))
xtfa i834(.sum(sum[834])，.carry(carry[834])，.a(a[834])，.b(b[834])，
.c(c[834]))；
xtfa i835(.sum(sum[835])，.carry(carry[835])，.a(a[835])，.b(b[835])，
.c(c[835]))；
<dp n="d286"/>
xtfa i836(.sum(sum[836])，.carry(carry[836])，.a(a[836])，.b(b[836])，
.c(c[836]))；
xtfa i837(.sum(sum[837])，.carry(carry[837])，.a(a[837])，.b(b[837])，
.c(c[837]))；
xtfa i838(.sum(sum[838])，.carry(carry[838])，.a(a[838])，.b(b[838])，
.c(c[838]))；
xtfa i839(.sum(sum[839])，.carry(carry[839])，.a(a[839])，.b(b[839])，
.c(c[839]))；
xtfa i840(.sum(sum[840])，.carry(carry[840])，.a(a[840])，.b(b[840])，
.c(c[840]))；
xtfa i841(.sum(sum[841])，.carry(carry[841])，.a(a[841])，.b(b[841])，
.c(c[841]))；
xtfa i842(.sum(sum[842])，.carry(carry[842])，.a(a[842])，.b(b[842])，
.c(c[842]))；
xtfa i843(.sum(sum[843])，.carry(carry[843])，.a(a[843])，.b(b[843])，
.c(c[843]))；
xtfa i844(.sum(sum[844])，.carry(carry[844])，.a(a[844])，.b(b[844])，
.c(c[844]))；
xtfa i845(.sum(sum[845])，.carry(carry[845])，.a(a[845])，.b(b[845])，
.c(c[845]))；
xtfa i846(.sum(sum[846])，.carry(carry[846])，.a(a[846])，.b(b[846])，
.c(c[846]))；
xtfa i847(.sum(sum[847])，.carry(carry[847])，.a(a[847])，.b(b[847])，
.c(c[847]))；
xtfa i848(.sum(sum[848])，.carry(carry[848])，.a(a[848])，.b(b[848])，
.c(c[848]))；
xtfa i849(.sum(sum[849])，.carry(carry[849])，.a(a[849])，.b(b[849])，
.c(c[849]))；
xtfa i850(.sum(sum[850])，.carry(carry[850])，.a(a[850])，.b(b[850])，
.c(c[850]))；
xtfa i851(.sum(sum[851])，.carry(carry[851])，.a(a[851])，.b(b[851])，
.c(c[851]))；
xtfa i852(.sum(sum[852])，.carry(carry[852])，.a(a[852])，.b(b[852])，
.c(c[852]))；
xtfa i853(.sum(sum[853])，.carry(carry[853])，.a(a[853])，.b(b[853])，
.c(c[853]))；
xtfa i854(.sum(sum[854])，.carry(carry[854])，.a(a[854])，.b(b[854])，
.c(c[854]))；
xtfa i855(.sum(sum[855])，.carry(carry[855])，.a(a[855])，.b(b[855])，
.c(c[855]))；
xtfa i856(.sum(sum[856])，.carry(carry[856])，.a(a[856])，.b(b[856])，
.c(c[856]))；
xtfa i857(.sum(sum[857])，.carry(carry[857])，.a(a[857])，.b(b[857])，
.c(c[857]))；
xtfa i858(.sum(sum[858])，.carry(carry[858])，.a(a[858])，.b(b[858])，
.c(c[858]))；
xtfa i859(.sum(sum[859])，.carry(carry[859])，.a(a[859])，.b(b[859])，
.c(c[859]))；
xtfa i860(.sum(sum[860])，.carry(carry[860])，.a(a[860])，.b(b[860])，
.c(c[860]))；
xtfa i861(.sum(sum[861])，.carry(carry[861])，.a(a[861])，.b(b[861])，
.c(c[861]))；
xtfa i862(.sum(sum[862])，.carry(carry[862])，.a(a[862])，.b(b[862])，
.c(c[862]))；
xtfa i863(.sum(sum[863])，.carry(carry[863])，.a(a[863])，.b(b[863])，
.c(c[863]))；
xtfa i864(.sum(sum[864])，.carry(carry[864])，.a(a[864])，.b(b[864])，
.c(c[864]))；
xtfa i865(.sum(sum[865])，.carry(carry[865])，.a(a[865])，.b(b[865])，
.c(c[865]))；
<dp n="d287"/>
xtfa i866(.sum(sum[866])，.carry(carry[866])，.a(a[866])，.b(b[866])，
.c(c[866]))；
xtfa i867(.sum(sum[867])，.carry(carry[867])，.a(a[867])，.b(b[867])，
.c(c[867]))；
xtfa i868(.sum(sum[868])，.carry(carry[868])，.a(a[868])，.b(b[868])，
.c(c[868]))；
xtfa i869(.sum(sum[869])，.carry(carry[869])，.a(a[869])，.b(b[869])，
.c(c[869]))；
xtfa i870(.sum(sum[870])，.carry(carry[870])，.a(a[870])，.b(b[870])，
.c(c[870]))；
xtfa i871(.sum(sum[871])，.carry(carry[871])，.a(a[871])，.b(b[871])，
.c(c[871]))；
xtfa i872(.sum(sum[872])，.carry(carry[872])，.a(a[872])，.b(b[872])，
.c(c[872]))；
xtfa i873(.sum(sum[873])，.carry(carry[873])，.a(a[873])，.b(b[873])，
.c(c[873]))；
xtfa i874(.sum(sum[874])，.carry(carry[874])，.a(a[874])，.b(b[874])，
.c(c[874]))；
xtfa i875(.sum(sum[875])，.carry(carry[875])，.a(a[875])，.b(b[875])，
.c(c[875]))；
xtfa i876(.sum(sum[876])，.carry(carry[876])，.a(a[876])，.b(b[876])，
.c(c[876]))；
xtfa i877(.sum(sum[877])，.carry(carry[877])，.a(a[877])，.b(b[877])，
.c(c[877]))；
xtfa i878(.sum(sum[878])，.carry(carry[878])，.a(a[878])，.b(b[878])，
.c(c[878]))；
xtfa i879(.sum(sum[879])，.carry(carry[879])，.a(a[879])，.b(b[879])，
.c(c[879]))；
xtfa i880(.sum(sum[880])，.carry(carry[880])，.a(a[880])，.b(b[880])，
.c(c[880]))；
xtfa i881(.sum(sum[881])，.carry(carry[881])，.a(a[881])，.b(b[881])，
.c(c[881]))；
xtfa i882(.sum(sum[882])，.carry(carry[882])，.a(a[882])，.b(b[882])，
.c(c[882]))；
xtfa i883(.sum(sum[883])，.carry[carry[883])，.a(a[883])，.b(b[883])，
.c(c[883]))；
xtfa i884(.sum(sum[884])，.carry(carry[884])，.a(a[884])，.b(b[884])，
.c(c[884]))；
xtfa i885(.sum(sum[885])，.carry(carry[885])，.a(a[885])，.b(b[885])，
.c(c[885]))；
xtfa i886(.sum(sum[886])，.carry(carry[886])，.a(a[886])，.b(b[886])，
.c(c[886]))；
xtfa i887(.sum(sum[887])，.carry(carry[887])，.a(a[887])，.b(b[887])，
.c(c[887]))；
xtfa i888(.sum(sum[888])，.carry(carry[8881)，.a(a[888])，.b(b[888])，
.c(c[888]))；
xtfa i889(.sum(sum[889])，.carry(carry[889])，.a(a[889])，.b(b[889])，
.c(c[889]))；
xtfa i890(.sum(sum[890])，.carry(carry[890])，.a(a[890])，.b(b[890])，
.c(c[890]))；
xtfa i891(.sum(sum[891])，.carry(carry[891])，.a(a[891])，.b(b[891])，
.c(c[891]))；
xtfa i892(.sum(sum[892])，.carry(carry[892])，.a(a[892])，.b(b[892])，
.c(c[892]))；
xtfa i893(.sum(sum[893])，.carry(carry[893])，.a(a[893])，.b(b[893])，
.c(c[893]))；
xtfa i894(.sum(sum[894])，.carry(carry[894])，.a(a[894])，.b(b[894])，
.c(c[894]))；
xtfa i895(.sum(sum[895])，.carry(carry[895])，.a(a[895])，.b(b[895])，
.c(c[895]))；
<dp n="d288"/>
xtfa i896(.sum(sum[896])，.carry(carry[896])，.a(a[896])，.b(b[896])，
.c(c[896]))；
xtfa i897(.sum(sum[897])，.carry(carry[897])，.a(a[897])，.b(b[897])，
.c(c[897]))；
xtfa i898(.sum(sum[898])，.carry(carry[898])，.a(a[898])，.b(b[898])，
.c(c[898]))；
xtfa i899(.sum(sum[899])，.carry(carry[899])，.a(a[899])，.b(b[899])，
.c(c[899]))；
xtfa i900(.sum(sum[900])，.carry(carry[900])，.a(a[900])，.b(b[900])，
.c(c[900]))；
xtfa i901(.sum(sum[901])，.carry(carry[901])，.a(a[901])，.b(b[901])，
.c(c[901]))；
xtfa i902(.sum(sum[902])，.carry(carry[902])，.a(a[902])，.b(b[902])，
.c(c[902]))；
xtfa i903(.sum(sum[903])，.carry(carry[903])，.a(a[903])，.b(b[903])，
.c(c[903]))；
xtfa i904(.sum(sum[904])，.carry(carry[904])，.a(a[904])，.b(b[904])，
.c(c[904]))；
xtfa i905(.sum(sum[905])，.carry(carry[905])，.a(a[905])，.b(b[905])，
.c(c[905]))；
xtfa i906(.sum(sum[906])，.carry(carry[906])，.a(a[906])，.b(b[906])，
.c(c[906]))；
xtfa i907(.sum(sum[907])，.carry(carry[907])，.a(a[907])，.b(b[907])，
.c(c[907]))；
xtfa i908(.sum(sum[908])，.carry(carry[908])，.a(a[908])，.b(b[908])，
.c(c[908]))；
xtfa i909(.sum(sum[909])，.carry(carry[909])，.a(a[909])，.b(b[909])，
.c(c[909]))；
xtfa i910(.sum(sum[910])，.carry(carry[910])，.a(a[910])，.b(b[910])，
.c(c[910]))；
xtfa i911(.sum(sum[911])，.carry(carry[911])，.a(a[911])，.b(b[911])，
.c(c[911]))；
xtfa i912(.sum(sum[912])，.carry(carry[912])，.a(a[912])，.b(b[912])，
.c(c[912]))；
xtfa i913(.sum(sum[913])，.carry(carry[913])，.a(a[913])，.b(b[913])，
.c(c[913]))；
xtfa i914(.sum(sum[914])，.carry(carry[914])，.a(a[914])，.b(b[914])，
.c(c[914]))；
xtfa i915(.sum(sum[915])，.carry(carry[915])，.a(a[915])，.b(b[915])，
.c(c[915]))；
xtfa i916(.sum(sum[916])，.carry(carry[916])，.a(a[916])，.b(b[916])，
.c(c[916]))；
xtfa i917(.sum(sum[917])，.carry(carry[917])，.a(a[917])，.b(b[917])，
.c(c[917]))；
xtfa i918(.sum(sum[918])，.carry(carry[918])，.a(a[918])，.b(b[918])，
.c(c[918]))；
xtfa i919(.sum(sum[919])，.carry(carry[919])，.a(a[919])，.b(b[919])，
.c(c[919]))；
xtfa i920(.sum(sum[920])，.carry(carry[920])，.a(a[920])，.b(b[920])，
.c(c[920]))；
xtfa i921(.sum(sum[921])，.carry(carry[921])，.a(a[921])，.b(b[921])，
.c(c[921]))；
xtfa i922(.sum(sum[922])，.carry(carry[922])，.a(a[922])，.b(b[922])，
.c(c[922]))；
xtfa i923(.sum(sum[923])，.carry(carry[923])，.a(a[923])，.b(b[923])，
.c(c[923]))；
xtfa i924(.sum(sum[924])，.carry(carry[924])，.a(a[924])，.b(b[924])，
.c(c[924]))；
xtfa i925(.sum(sum[925])，.carry(carry[925])，.a(a[925])，.b(b[925])，
.c(c[925]))；
<dp n="d289"/>
xtfa i926(.sum(sum[926])，.carry(carry[926])，.a(a[926])，.b(b[926])，
.c(c[926]))；
xtfa i927(.sum(sum[927])，.carry(carry[927])，.a(a[927])，.b(b[927])，
.c(c[927]))；
xtfa i928(.sum(sum[928])，.carry(carry[928])，.a(a[928])，.b(b[928])，
.c(c[928]))；
xtfa i929(.sum(sum[929])，.carry(carry[929])，.a(a[929])，.b(b[929])，
.c(c[929]))；
xtfa i930(.sum(sum[930])，.carry(carry[930])，.a(a[930])，.b(b[930])，
.c(c[930]))；
xtfa i931(.sum(sum[931])，.carry(carry[931])，.a(a[931])，.b(b[931])，
.c(c[931]))；
xtfa i932(.sum(sum[932])，.carry(carry[932])，.a(a[932])，.b(b[932])，
.c(c[932]))；
xtfa i933(.sum(sum[933])，.carry(carry[933])，.a(a[933])，.b(b[933])，
.c(c[933]))；
xtfa i934(.sum(sum[934])，.carry(carry[934])，.a(a[934])，.b(b[934])，
.c(c[934]))；
xtfa i935(.sum(sum[935])，.carry(carry[935])，.a(a[935])，.b(b[935])，
.c(c[935]))；
xtfa i936(.sum(sum[936])，.carry(carry[936])，.a(a[936])，.b(b[936])，
.c(c[936]))；
xtfa i937(.sum(sum[937])，.carry(carry[937])，.a(a[937])，.b(b[937])，
.c(c[937]))；
xtfa i938(.sum(sum[938])，.carry(carry[938])，.a(a[938])，.b(b[938])，
.c(c[938]))；
xtfa i939(.sum(sum[939])，.carry(carry[939])，.a(a[939])，.b(b[939])，
.c(c[939]))；
xtfa i940(.sum(sum[940])，.carry(carry[940])，.a(a[940])，.b(b[940])，
.c(c[940]))；
xtfa i941(.sum(sum[941])，.carry(carry[941])，.a(a[941])，.b(b[941])，
.c(c[941]))；
xtfa i942(.sum(sum[942])，.carry(carry[942])，.a(a[942])，.b(b[942])，
.c(c[942]))；
xtfa i943(.sum(sum[943])，.carry(carry[943])，.a(a[943])，.b(b[943])，
.c(c[943]))；
xtfa i944(.sum(sum[944])，.carry(carry[944])，.a(a[944])，.b(b[944])，
.c(c[944]))；
xtfa i945(.sum(sum[945])，.carry(carry[945])，.a(a[945])，.b(b[945])，
.c(c[945]))；
xtfa i946(.sum(sum[946])，.carry(carry[946])，.a(a[946])，.b(b[946])，
.c(c[946]))；
xtfa i947(.sum(sum[947])，.carry(carry[947])，.a(a[947])，.b(b[947])，
.c(c[947]))；
xtfa i948(.sum(sum[948])，.carry(carry[948])，.a(a[948])，.b(b[948])，
.c(c[948]))；
xtfa i949(.sum(sum[949])，.carry(carry[949])，.a(a[949])，.b(b[949])，
.c(c[949]))；
xtfa i950(.sum(sum[950])，.carry(carry[950])，.a(a[950])，.b(b[950])，
.c(c[950]))；
xtfa i951(.sum(sum[951])，.carry(carry[951])，.a(a[951])，.b(b[951])，
.c(c[951]))；
xtfa i952(.sum(sum[952])，.carry(carry[952])，.a(a[952])，.b(b[952])，
.c(c[952]))；
xtfa i953(.sum(sum[953])，.carry(carry[953])，.a(a[953])，.b(b[953])，
.c(c[953]))；
xtfa i954(.sum(sum[954])，.carry(carry[954])，.a(a[954])，.b(b[954])，
.c(c[954]))；
xtfa i955(.sum(sum[955])，.carry(carry[955])，.a(a[955])，.b(b[955])，
.c(c[955]))；
<dp n="d290"/>
xtfa i956(.sum(sum[956])，.carry(carry[956])，.a(a[956])，.b(b[956])，
.c(c[956]))；
xtfa i957(.sum(sum[957])，.carry(carry[957])，.a(a[957])，.b(b[957])，
.c(c[957]))；
xtfa i958(.sum(sum[958])，.carry(carry[958])，.a(a[958])，.b(b[958])，
.c(c[958]))；
xtfa i959(.sum(sum[959])，.carry(carry[959])，.a(a[959])，.b(b[959])，
.c(c[959]))；
xtfa i960(.sum(sum[960])，.carry(carry[960])，.a(a[960])，.b(b[960])，
.c(c[960]))；
xtfa i961(.sum(sum[961])，.carry(carry[961])，.a(a[961])，.b(b[961])，
.c(c[961]))；
xtfa i962(.sum(sum[962])，.carry(carry[962])，.a(a[962])，.b(b[962])，
.c(c[962]))；
xtfa i963(.sum(sum[963])，.carry(carry[963])，.a(a[963])，.b(b[963])，
.c(c[963]))；
xtfa i964(.sum(sum[964])，.carry(carry[964])，.a(a[964])，.b(b[964])，
.c(c[964]))；
xtfa i965(.sum(sum[965])，.carry(carry[965])，.a(a[965])，.b(b[965])，
.c(c[965]))；
xtfa i966(.sum(sum[966])，.carry(carry[966])，.a(a[966])，.b(b[966])，
.c(c[966]))；
xtfa i967(.sum(sum[967])，.carry(carry[967])，.a(a[967])，.b(b(967])，
.c(c[967]))；
xtfa i968(.sum(sum[968])，.carry(carry[968])，.a(a[968])，.b(b[968])，
.c(c[968]))；
xtfa i969(.sum(sum[969])，.carry(carry[969])，.a(a[969])，.b(b[969])，
.c(c[969]))；
xtfa i970(.sum(sum[970])，.carry(carry[970])，.a(a[970])，.b(b[970])，
.c(c[970]))；
xtfa i971(.sum(sum[971])，.carry(carry[971])，.a(a[971])，.b(b[971])，
.c(c[971]))；
xtfa i972(.sum(sum[972])，.carry(carry[972])，.a(a[972])，.b(b[972])，
.c(c[972]))；
xtfa i973(.sum(sum[973])，.carry(carry[973])，.a(a[973])，.b(b[973])，
.c(c[973]))；
xtfa i974(.sum(sum[974])，.carry(carry[974])，.a(a[974])，.b(b[974])，
.c(c[974]))；
xtfa i975(.sum(sum[975])，.carry(carry[975])，.a(a[975])，.b(b[975])，
.c(c[975]))；
xtfa i976(.sum(sum[976])，.carry(carry[976])，.a(a[976])，.b(b[976])，
.c(c[976]))；
xtfa i977(.sum(sum[977])，.carry(carry[977])，.a(a[977])，.b(b[977])，
.c(c[977]))；
xtfa i978(.sum(sum[978])，.carry(carry[978])，.a(a[978])，.b(b[978])，
.c(c[978]))；
xtfa i979(.sum(sum[979])，.carry(carry[979])，.a(a[979])，.b(b[979])，
.c(c[979]))；
xtfa i980(.sum(sum[980])，.carry(carry[980])，.a(a[980])，.b(b[980])，
.c(c[980]))；
xtfa i981(.sum(sum[981])，.carry(carry[981])，.a(a[981])，.b(b[981])，
.c(c[981]))；
xtfa i982(.sum(sum[982])，.carry(carry[982])，.a(a[982])，.b(b[982])，
.c(c[982]))；
xtfa i983(.sum(sum[983])，.carry(carry[983])，.a(a[983])，.b(b[983])，
.c(c[983]))；
xtfa i984(.sum(sum[984])，.carry(carry[984])，.a(a[984])，.b(b[984])，
.c(c[984]))；
xtfa i985(.sum(sum[985])，.carry(carry[985])，.a(a[985])，.b(b[985])，
.c(c[985]))；
<dp n="d291"/>
xtfa i986(.sum(sum[986])，.carry(carry[986])，.a(a[986])，.b(b[986])，
.c(c[986]))；
xtfa i987(.sum(sum[987])，.carry(carry[987])，.a(a[987])，.b(b[987])，
.c(c[987]))；
xtfa i988(.sum(sum[988])，.carry(carry[988])，.a(a[988])，.b(b[988])，
.c(c[988]))；
xtfa i989(.sum(sum[989])，.carry(carry[989])，.a(a[989])，.b(b[989])，
.c(c[989]))；
xtfa i990(.sum(sum[990])，.carry(carry[990])，.a(a[990])，.b(b[990])，
.c(c[990]))；
xtfa i991(.sum(sum[991])，.carry(carry[991])，.a(a[991])，.b(b[991])，
.c(c[991]))；
xtfa i992(.sum(sum[992])，.carry(carry[992])，.a(a[992])，.b(b[992])，
.c(c[992]))；
xtfa i993(.sum(sum[993])，.carry(carry[993])，.a(a[993])，.b(b[993])，
.c(c[993]))；
xtfa i994(.sum(sum[994])，.carry(carry[994])，.a(a[994])，.b(b[994])，
.c(c[994]))；
xtfa i995(.sum(sum[995])，.carry(carry[995])，.a(a[995])，.b(b[995])，
.c(c[995]))；
xtfa i996(.sum(sum[996])，.carry(carry[996])，.a(a[996])，.b(b[996])，
.c(c[996]))；
xtfa i997(.sum[sum[997])，.carry(carry[997])，.a(a[997])，.b(b[997])，
.c(c[997]))；
xtfa i998(.sum(sum[998])，.carry(carry[998])，.a(a[998])，.b(b[998])，
.c(c[998]))；
xtfa i999(.sum(sum[999])，.carry(carry[999])，.a(a[999])，.b(b[999])，
.c(c[999]))；
xtfa i1000(.sum(sum[1000])，.carry(carry[1000])，.a(a[1000])，
.b(b[1000])，.c(c[1000]))；
xtfa i1001(.sum(sum[1001])，.carry(carry[1001])，.a(a[1001])，
.b(b[1001])，.c(c[1001]))；
xtfa i1002(.sum(sum[1002])，.carry(carry[1002])，.a(a[1002])，
.b(b[1002])，.c(c[1002]))；
xtfa i1003(.sum(sum[1003])，.carry(carry[1003])，.a(a[1003])，
.b(b[1003])，.c(c[1003]))；
xtfa i1004(.sum(sum[1004])，.carry(carry[1004])，.a(a[1004])，
.b(b[1004])，.c(c[1004]))；
xtfa i1005(.sum(sum[1005])，.carry(carry[1005])，.a(a[1005])，
.b(b[1005])，.c(c[1005]))；
xtfa i1006(.sum(sum[1006])，.carry(carry[1006])，.a(a[1006])，
.b(b[1006])，.c(c[1006]))；
xtfa i1007(.sum(sum[1007])，.carry(carry[1007])，.a(a[1007])，
.b(b[1007])，.c(c[1007]))；
xtfa i1008(.sum(sum[1008])，.carry(carry[1008])，.a(a[1008])，
.b(b[1008])，.c(c[1008]))；
xtfa i1009(.sum(sum[1009])，.carry(carry[1009])，.a(a[1009])，
.b(b[1009])，.c(c[1009]))；
xtfa i1010(.sum(sum[1010])，.carry(carry[1010])，.a(a[1010])，
.b(b[1010])，.c(c[1010]))；
xtfa i1011(.sum(sum[1011])，.carry(carry[1011])，.a(a[1011])，
.b(b[1011])，.c(c[1011]))；
xtfa i1012(.sum(sum[1012])，.carry(carry[1012])，.a(a[1012])，
.b(b[1012])，.c(c[1012]))；
xtfa i1013(.sum(sum[1013])，.carry(carry[1013])，.a(a[1013])，
.b(b[1013])，.c(c[1013]))；
xtfa i1014(.sum(sum[1014])，.carry(carry[1014])，.a(a[1014])，
.b(b[1014])，.c(c[1014]))；
xtfa i1015(.sum(sum[1015])，.carry(carry[1015])，.a(a[1015])，
.b(b[1015])，.c(c[1015]))；
<dp n="d292"/>
xtfa i1016(.sum(sum[1016])，.carry(carry[1016])，.a(a[1016])，
.b(b[1016])，.c(c[1016]))；
xtfa i1017(.sum(sum[1017])，.carry(carry[1017])，.a(a[1017])，
.b(b[1017])，.c(c[1017]))；
xtfa i1018(.sum(sum[1018])，.carry(carry[1018])，.a(a[1018])，
.b(b[1018])，.c(c[1018]))；
xtfa i1019(.sum(sum[1019])，.carry(csrry[1019])，.a(a[1019])，
.b(b[1019])，.c(c[1019]))；
xtfa i1020(.sum(sum[1020])，.carry(carry[1020])，.a(a[1020])，
.b(b[1020])，.c(c[1020]))；
xtfa i1021(.sum(sum[1021])，.carry(carry[1021])，.a(a[1021])，
.b(b[1021])，.c(c[1021]))；
xtfa i1022(.sum(sum[1022])，.carry(carry[1022])，.a(a[1022])，
.b(b[1022])，.c(c[1022]))；
xtfa i1023(.sum(sum[1023])，.carry(carry[1023])，.a(a[1023])，
.b(b[1023])，.c(c[1023]))；
endmodule
//Local Variables：***
//mode：verilog **
//End：***
verysys/verify sem.v
module xmTIE_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[7：0]rd0_data_C1；
input[3：0]rd0_addr_C0；
input rd0_width8_C0；
input rd0_use1_C0；
output[7：0]rd1_data_C1；
input[3：0]rd1_addr_C0；
input rd1_width8_C0；
input rd1_use1_C0；
output[7：0]rd2_data_C1；
input[3：0]rd2_addr_C0；
input rd2_width8_C0；
input rd2_use1_C0；
input[3：0]wd_addr_C0；
input wd_width8_C0；
input wd_def1_C0；
input wd_def2_C0；
input[7：0]wd_data8_C1；
input[7：0]wd_data8_C2；
input wd_wen_C1；
input wd_wen_C2；
input Kill_E；
input KillPipe_W；
output Stall_R；
input clk；
/***********************************************************************
<dp n="d293"/>
TEAD POPT rd0
***********************************************************************/
//compute the address mask
wire rd0_addr_mask_C0＝1′d0；
//masked address pipeline
wire rd0_maddr_C0＝1′d0；
//bank-qualified use
wire rd0_use1_bank0_C0＝(rd0_use1_C0 & (rd0_maddr_C0＝＝(1′d0 &
rd0_addr_mask_C0)))；
//alignment mux for use1
wire[7：0]rd0_data_bank0_C1；
assign rd0_data_C1[7：0]＝rd0_data_bank0_C1；
/***********************************************************************
READ PORT rd1
***********************************************************************/
//compute the address mask
wire rd1_addr_mask_C0＝1′d0；
//masked address pipeline
wire rd1_maddr_C0＝1′d0；
//bank-qualified use
wire rd1_use1_bank0_C0＝(rd1_use1_C0 & (rd1_maddr_C0＝＝(1′d0 &
rd1_addr_mask_C0)))；
//alignment mux for use1
wire[7：0]rd1_data_bank0_C1；
assign rd1_data_C1[7：0]＝rd1_data_bank0_C1；
/***********************************************************************
READ PORT rd2
***********************************************************************/
//compute the address mask
wire rd2_addr_mask_C0＝1′d0；
//masked address pipeline
wire rd2_maddr_C0＝1′d0；
//bank-qua1ified use
wire rd2_usel_bank0_C0＝(rd2_usel_C0 & (rd2_maddr_C0＝＝(1′d0 &
rd2_addr_mask_C0)))
//alignment mux for use1
wire[7：0]rd2_data_bank0_C1；
assign rd2_data_C1[7：0]＝rd2_data_bank0_C1；
/***********************************************************************
<dp n="d294"/>
WRITE PORT wd
***********************************************************************/
//compute the address mask
wire wd_addr_mask_C0＝1′d0；
//bank-qualified write def for port wd
wire wd_def1-bank0_C0＝(wd_def1_C0 & ((wd_addr_C0 & wd_addr_mask_C0)
＝＝(1′d0 & wd_addr_mask_C0)))；
wire wd_def2_bank0_C0＝(wd_def2_C0 & ((wd_addr_C0 & wd_addr_mask_C0)
＝＝(1′d0 & wd_addr_mask_C0)))；
//write mux for def 1
wire[7：0]wd_wdata_C1；
assign wd_wdata_C1＝{1{wd_data8_C1[7：0]}}；
//write mux for def2
wire[7：0]wd_wdata_C2；
assign wd_wdata_C2＝{1{wd_data8_C2[7：0]}}；
wire Stall_R0；
/***********************************************************************
PIPELINED BANK
***********************************************************************/
xmTIE_gf_Regfile_bank TIE_gf_Regfile_bank0(rd0_data_bank0_C1，
rd0_addr_C0[3：0]，rd0_use1_bank0_C0，rd1_data_bank0_C1，
rd1_addr_C0[3：0]，
rd1_use1_bank0_C0，rd2_data_bank0_C1，rd2_addr_C0[3：0]，
rd2_use1_bank0_C0，
wd_addr_C0[3：0]，wd_def1_bank0_C0，wd_def2_bank0_C0，
wd_wdata_C1[7：0]，
wd_wdata_C2[7：0]，wd_wen_C1，wd_wen_C2，Kill_E，KillPipe_W，
Stall_R0，
clk)；
assign Stall_R＝Stall_R0|1′b0；
endmodule
module xmTIE_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 [7：0] rd0_data_C1；
input [3：0] rd0_addr_C0；
input rd0_use1_C0；
output [7：0] rd1_data_C1；
input [3：0] rd1_addr_C0；
input rd1_use1_C0；
output [7：0] rd2_data_C1；
input [3：0] rd2_addr_C0；
input rd2_use1_C0；
input [3：0] wd_addr_C0；
input wd_def1_C0；
input wd_def2_C0；
input [7：0] wd_data_C1；
<dp n="d295"/>
input [7：0] wd_data_C2；
input wd_wen_C1 ；
input wd_wen_C2；
input Kill_E；
input KillPipe_W；
output Stall_R；
input clk；
wire rd0_use2_C0＝1′d0；
wire rd1_use2_C0＝1′d0；
wire rd2_use2_C0＝1′d0；
wire kill_C0＝Ki1lPipe_W；
wire kill_C1＝KillPipe_W|Kill_E；
wire kill_C2＝KillPipe_W；
wire kill_C3＝KillPipe_W；
//write definition pipeline
wire wd_ns_def1_C0＝wd_def1_C0 & 1′b1 &-kill_C0；
wire wd_def1_C1；
xtdelay1 #(1) iwd_def1_C1(wd_def1_C1，wd_ns_def1_C0，clk)；
wire wd_ns_def2_C0＝wd_def2_C0 & 1′b1 & -kill_C0；
wire wd_def2_C1；
xtdelay1 #(1) iwd_def2_C1(wd_def2_C1，wd_ns_def2_C0，clk)；
wire wd_ns_def2_C1＝wd_def2_C1 & wd_wen_C1 & -kill_C1;
wire wd_def2_C2；
xtdelay1 #(1) iwd_def2_C2(wd_def2_C2，wd_ns_def2_C1，clk)；
//write enable pipeline
wire wd_we_C2；
wire wd_we_C3；
wire wd_ns_we_C1＝(1′d0|(wd_def1_C1 & wd_wen_C1)) & -kill_C1；
wire wd_ns_we_C2＝(wd_we_C2|(wd_def2_C2 & wd_wen_C2)) &-kill_C2；
wire wd_ns_we_C3＝(wd_we_C3|(1′d0 & 1′d0)) & -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);
//write address pipeline
wire [3：0] wd_addr_C1；
wire [3：0] wd_addr_C2；
wire [3：0] 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)；
//write data pipeline
wire [7：0] wd_result_C2；
wire [7：0] wd_result_C3；
wire [7：0] wd_mux_C1＝wd_data_C1；
wire [7：0] wd_mux_C2＝wd_def2_C2？wd_data_C2：wd_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 [7：0] rd0_data_C0；
wire [7：0] rd1_data_C0；
wire [7：0] 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)；
<dp n="d296"/>
xtdelay1 #(8) ird2_data_C1(rd2_data_C1，rd2_data_C0，clk)；
assign Stall_R＝
((wd_addr_C1＝＝rd0_addr_C0)&(
(rd0_use1_C0&(wd_ns_def2 C1))))|
((wd_addr_C1＝＝rd1_addr_C0)&(
(rd1_use1_C0&(wd_ns_def2_C1))))|
((wd_addr_C1＝＝rd2_addr_C0)&(
(rd2_use1_C0&(wd_ns_def2_C1))))|
1′b0；
//verification register file replacement
wire[7：0] 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_data C0，xwd_verify，clk)；
xtflop #(8) rd2_verify(rd2_data_C0，xwd_verify，clk)；
endmodule
module xmTIE_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[7：0]ps_data_C1；
input ps_width8_C0；
input ps_use1_C0；
input ns_width8_C0；
input ns_def1_C0；
input [7：0] ns_data8_C1；
input ns_wen_C1；
input Kill_E；
input KillPipe_W；
output Stall_R；
input clk；
wire ps_addr_C0＝1′d0；
wire ns_addr_C0＝1′d0；
wire ns_wen_C2＝1′d1；
/***********************************************************************
READ PORT ps
***********************************************************************/
//compute the address mask
wire ps_addr_mask_C0＝1′d0；
//masked addtess pipeline
wire_ps_maddr_C0＝1′d0；
//bank-qualified use
wire ps_usel_bank0_C0＝(ps_use1_C0&(ps_maddr_C0＝＝(1′d0 &
ps_addr_mask C0)))；
//alignment mux for use 1
wire [7：0] ps_data_bank0_C1；
assign ps_data_C1[7：0]＝ps_data_bank0_C1；
<dp n="d297"/>
/***********************************************************************
WRITE PORT ns
***********************************************************************/
//compute the address mask
wire ns_addr_mask_C0＝1′d0；
//bank-qualified write def for port ns
wire ns_def1_bank0_C0＝(ns_def1_C0&((ns_addr_C0&ns_addr_mask_C0)
＝＝(1′d0 & ns_addr_mask_C0)))；
//write mux for def1
wire [7：0] ns_wdata_C1；
assign ns_wdata_C1＝{1{ns_data8_C1[7：0]}}；
wire Stall_R0；
/***********************************************************************
PIPELINED BANK
***********************************************************************/
xmTIE_gfmod_State_bank TIE_gfmod_State_bank0(ps_data_bank0_C1，
ps_use1_bank0_C0，ns_def1_bank0_C0，ns_wdata_C1[7：0]，ns_wen_C1，
ns_wen_C2，Kill_E，KillPipe_W，Stall_R0，clk)；
assign stall_R＝Stall_R0|1′b0；
endmodule
module xmTIE_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 [7：0] ps_data_C1；
input ps_use1_C0；
input ns_def1_C0；
input [7：0] ns_data_C1；
input ns_wen_C1；
input ns_wen_C2；
input Kill_E；
input KillPipe_W；
output Stall_R；
input clk；
wire ps_addr_C0＝1′d0；
wire ps_use2_C0＝1′d0；
wire ns_addr_C0＝1′d0；
wire ns_def2_C0＝1′d0；
wire [7：0] ns_data_C2＝0；
wire kill_C0＝KillPipe_W；
wire kill_C1＝KillPipe_W|Kill_E；
wire kill_C2＝KillPipe_W；
wire kill_C3＝KillPipe_W；
//write definition pipeline
wire ns_ns_def1_C0＝ns_def1_C0&1′b1&-kill_C0；
wire ns_def1_C1；
<dp n="d298"/>
xtdelay1 #(1) ins_def1_C1(ns_def1_C1，ns_ns_def1_C0，clk)；
wire ns_ns_def2_C0＝1′d0；
wire ns_def2_C1＝1′d0；
wire ns_ns_def2_C1＝1′d0；
wire ns_def2_C2＝1′d0；
//write enable pipeline
wire ns_we_C2；
wire ns_we_C3；
wire ns_ns_we_C1＝(1′d0|(ns_def1_C1 & ns_wen_C1))&-kill_C1；
wire ns_ns_we_C2＝(ns_we_C2|(ns_def2_C2 &ns_wen_C2))&-kill_C2；
wire ns_ns_we_C3＝(ns_we_C3|(1′d0&1′d0))&-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)；
//write address pipeline
wire ns_addr_C1；
wire ns_addr_C2；
wire ns_addr_C3；
assign ns_addr_C1＝1′d0；
assign ns_addr_C2＝1′d0；
assign ns_addr_C3＝1′d0；
//write data pipeline
wire [7：0] ns_result_C2；
wire [7：0] ns_result_C3；
wire [7：0] ns_mux_C1＝ns_data_C1；
wire [7：0] ns_mux_C2＝ns_def2_C2？ns_data_C2：ns_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 [7：0] ps_data_C0；
xtdelay1 #(8) ips_data_C1(ps_data_C1，ps_data_C0，clk)；
assign Stall_R＝
((ns_addr_C1＝＝ps_addr_C0)&(
(ps_use1_C0&(ns_ns_def2_C1))))|
1′b0；
//verification register file replacement
wire [7：0] 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)；
endmodule
module xmTIE_decoder(
GFADD8，
GFADD8I，
GFMULX8，
GFRWMOD8，
LGF8_I，
SGF8_I，
LGF8_IU，
SGF8_IU，
LGF8_X，
SGF8_X，
LGF8_XU，
SGF8_Xu，
<dp n="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
)；
<dp n="d300"/>
output GFADD8；
output GFADD8I；
output GFMULX8；
output GFRWMOD8；
output LGF8_I；
output SGF8_I；
output LGF8_IU；
output SGF8_IU；
output LGF8_X；
output SGF8_X；
output LGF8_XU；
output SGF8_XU；
output RUR0；
output WUR0；
output [31：0]imm4；
output [7：0]imm8；
output art_use；
output art_def；
output ars_use；
output ars_def；
output arr_use；
output arr_def；
output br_use；
output br_def；
output bs_use；
output bs_def；
output bt_use；
output bt_def；
output bs4_use；
output bs4_def；
output bs8_use；
output bs8_def；
output gr_use；
output gr_def；
output gs_use；
output gs_def；
output gt_use；
output gt_def；
output gfmod_use1；
output gfmod_def1；
output AR_rd0_use1；
output AR_rd0_width32；
output AR_rd1_use1；
output AR_rd1_width32；
output AR_wd_def1；
output AR_wd_width32；
output [3：0]gf_rd0_addr；
output gf_rd0_use1；
output gf_rd0_width8；
output [3：0] gf_rd1_addr；
output gf_rd1_use1；
output gf_rd1_width8；
output [3：0]gf_rd2_addr；
output gf_rd2_use1；
output gf_rd2_width8；
output [3：0]gf_wd_addr；
output gf_wd_def2；
output gf_wd_def1；
output gf_wd_width8；
output gf1_semantic；
<dp n="d301"/>
output gf4_semantic；
output gf2_semantic；
output gf3_semantic；
output 1gf_semantic；
output sgf_semantic；
output RUR0_semantic；
output WUR0_semantic；
output load_instruction；
output store_instruction；
output TIE_Inst；
input [23：0]Inst；
wire [3：0] op2＝{Inst[23：20]}；
wire [3：0] op1＝{Inst[19：16]}；
wire [3：0] op0＝{Inst[3：0]}；
wire CUST0＝(op1＝＝4′b0110) & QRST；
assign GFADD8I＝(op2＝＝4′b0100)& CUST0；
assign GFMULX8＝(op2＝＝4′b0001)& CUST0；
assign GFRWMOD8＝(op2＝＝4′b0010)& CUST0；
wire [3：0]r＝{Inst[15：12]}；
wire LSCI＝(op0＝＝4′b0011)；
assign LGF8_I＝(r＝＝4′b0000)&LSCI；
assign LGF8_IU＝(r＝＝4′b0010)&LSCI；
assign SGF8_IU＝(r＝＝4′b0011)&LSCI；
wire LSCX＝(op1＝＝4′b1000)&QRST；
assign LGF8_X＝(op2＝＝4′b0000)&LSCX；
assign SGF8_X＝(op2＝＝4′b0001)&LSCX；
assign LGF8_XU＝(op2＝＝4′b0010)&LSCX；
assign SGF8_XU＝(op2＝＝4′b0011)&LSCX；
wire [3：0] s＝{Inst[11：8]}；
wire [3：0] t＝{Inst[7：4]}；
wire [7：0] st＝{s，t}；
wire [7：0] sr＝{r，s}；
wire WUR＝(op2＝＝4′b1111)&RST3；
assign gfmod_use1＝GFMULX8|GFRWMOD8|RUR0|1′b0；
assign gfmod_def1＝GFRWMOD8|WUR0|1′b0；
assign AR_rd0_use1＝1′b0
|LGF8_I
|SGF8_I
|LGF8_IU
|SGF8_IU
|LGF8_X
|SGF8_X
|LGF8_XU
|SGF8_XU；
assign AR_rd0_width32＝1′b0；
assign AR_rd1_use1＝1′b0
|LGF8_X
|SGF8_X
|LGF8_XU
|SGF8_XU
|WIR0；
assign AR_rd1_width32＝1′b0；
<dp n="d302"/>
assign AR_wd_def1＝1′b0
|LGF8_IU
|SGF8_IU
|LGF8_XU
|SGF8_XU
|RUR0；
assign AR_wd_width32＝1′b0；
assign gf_rd0_use1＝1′b0
|GFADD8
|GFADD8I
|GFMULX8；
assign gf_rd0_width8＝1′b0；
assign gf_rd1_use1＝1′b0
|GFADD8
|GFRWMOD8
|SGF8_I
|SGF8_IU；
assign gf_rd1_width8＝1′b0；
assign gf_rd2_use1＝1′b0
|SGF8_X
|SGF8_XU；
assign gf_rd2_width8＝1′b0；
assign gf_wd_def2＝1′b0
|LGF8_I
|LGF8_IU
|LGF8_X
|LGF8_XU；
assign gf_wd_def1＝1′b0
|GFADD8
|GFADD8I
|GFMULX8
|GFRWMOD8；
assign gf_wd_width8＝1′b0；
assign art_def＝1′b0；
assign art_use＝LGF8_X|SGF8_X|LGF8_XU|SGF8_XU|WURO|1′b0；
assign ars_def＝LGF8_IU|SGF8_IU|LGF8_XU|SGF8_XU|1′bo；
assign ars_use＝LGF8_I|SGF8_I|LGF8_IU|SGF8_IU|LGF8_X|SGF8_X|
LGF8_XU|SGF8_XU|1′b0；
assign arr_def＝RUR0|1′b0；
assign arr_use＝1′b0；
assign br_def＝1′b0；
assign br_use＝1′b0；
assign bs_def＝1′b0；
assign bs_use＝1′b0；
assign bt_def＝1′b0；
assign bt_use＝1′b0；
assign bs4_def＝1′b0；
assign bs4_use＝1′b0；
assign bs8_def＝1′b0；
assign bs8_use＝1′b0；
assign gr_def＝GFADD8|GFADD8I|GFMULX8|LGF8_X|LGF8_XU|1′b0；
assign gr_use＝SGF8_X|SGF8_XU|1′b0；
assign gs_def＝1′b0；
assign gs_use＝GFADD8|GFADD8I|GFMULX8|1′b0；
assign gt_def＝GFRWMOD8|LGF8_I|LGF8_IU|1′b0；
assign gt_use＝GFADD8|GFRWMOD8|SGF8_I|SGF8_IU|1′b0；
wire [3：0] gr_addr＝r；
wire [3：0] gs_addr＝s；
wire [3：0] gt_addr＝t；
assign gf_wd_addr＝4′b0
<dp n="d303"/>
|{4{gr_def}}&gr_addr
|{4{gt_def}}&gt_addr；
assign gf_rd0_addr＝gs_addr；
assign gf_rd1_addr＝gt_addr；
assign gf_rd2_addr＝gr_addr；
assign gf1_semantic＝GFADD8|1′b0；
assign gf4_semantic＝GFADD8I|1′b0；
assign gf2_semantic＝GFMULX8|1′b0；
assign gf3_semantic＝GFRWMOD8|1′b0；
assign lgf_semantic＝LGF8_I|LGF8_IU|LGF8_X|LGF8_XU|1′b0；
assign sgf_semantic＝SGF8_|SGF8_IU|SGF8_X|SGF8_XU|1′b0；
assign RUR0_semantic＝RUR0|1′b0；
assign WUR0_semantic＝WUR0|1′b0；
assign imm4＝t；
wire [7：0] imm8＝{Inst[23：16]}；
assign load_instruction＝1′b0
|LGF8_I
|LGF8_IU
|LGF8_X
|LGF8_XU；
assign store_instruction＝1′b0
|SGF8_I
|SGF8_IU
|SGF8_X
|SGF8_XU；
assign TIE_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；
endmodule
module xmTIE_gf1(
GFADD8_C0，
gr_o_C1，
gr_kill_c1，
gs_i_C1，
gt_i_C1，
clk
)；
input GFADD8_C0；
output [7：0] gr_o_Cl；
output gr_kill_C1；
input [7：0] gs_i_C1；
input [7：0] gt_i_C1 ；
input clk；
assign gr_o_C1＝(gs_i_C1)＾(gt_i_C1)；
wire GFADD8_C1；
xtdelay1 #(1) iGFADD8_C1(.xtin(GFADD8_C0)，.xtout(GFADD8_C1)，.clk(clk))；
assign gr_kill_C1＝(1′b0)&(GFADD8_C1)；
<dp n="d304"/>
endmodule
module xmTIE_gf4(
GFADD8I_C0，
gr_o_C1，
gr_kill_C1，
gs_i_C1，
imm4_C0，
clk
)；
input GFADD8I_C0；
output [7：0]gr_o_C1；
output gr_kill_C1；
input [7：0]gs_i_C1；
input [31：0] imm4_C0；
input clk；
wire [31：0] imm4_C1；
xtdelay1 #(32) iimm4_C1(.xtin(imm4_C0)，.xtout(imm4_C1)，.clk(clk))；
assign gr_o_C1＝(gs_i_C1)^(imm4_C1)；
wire GFADD8I_C1；
xtdelay1 #(1) iGFADD8I_C1(.xtin(GFADD8I_C0)，.xtout(GFADD8I_C1)，
.clk(clk))；
assign gr_kill_C1＝(1′b0)&(GFADD8I_C1)；
endmodule
module xmTIE_gf2(
GFMUIX8_C0，
gr_o_C1，
gr_kill_C1，
gs_i_C1，
gfmod_ps_C1，
clk
)；
input GFMULX8_C0；
output [7：0] gr_o_C1；
output gr_kill_C1；
input [7：0] gs_i_C1；
input [7：0] gfmod_ps_C1；
input clk；
assign gr_o_C1＝(gs_i_C1[7])？(({gs_i_C1[6：0]，1′b0})^(gfmod_ps_C1))：
({gs_i_C1[6：0]，1′b0})；
wire GFMULX8_C1；
xtdelay1 #(1) iGFMUIX8_C1(.xtin(GFMULX8_C0)，.xtout(GFMULX8_C1)，
.clk(clk))；
assign gr_kill_C1＝(1′b0)&(GFMULX8_C1)；
endmodule
module xmTIE_gf3(
GFRWMOD8_C0，
gt_i_C1，
gt_o_C1，
gt_kill_C1，
gfmod_ps_C1，
gfmod_ns_C1，
gfmod_kill_C1，
clk
)；
input GFRWMOD8_C0；
input [7：0] gt_i_C1；
output [7：0] gt_o_C1；
<dp n="d305"/>
output gt_kill_C1；
input [7：0] gfmod_ps_C1；
output [7：0] gfmod_ns_C1；
output gfmod_kill_C1；
input clk；
wire [7：0] t1_C1；
assign t1_C1＝gt_i_C1；
wire [7：0] t2_C1；
agsign t2_C1 ＝gfmod_ps_C1；
assign gfmod_ns_C1＝t1_C1；
assign gt_o_C1＝t2_C1；
wire GFRWMOD8 C1；
xtdelay1 #(1) iGFRWMOD8_C1(.xtin(GFRWMOD8_C0)，.xtout(GFRWMOD8_C1)，
.clk(clk))；
assign gfmod_kill_C1＝(1′b0)&(GFRWMOD8_C1)；
assign gt_kill_C1＝(1′b0)&(GFRWMOD8_C1)；
endmodule
module xmTIE_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
)；
input LGF8_I_C0；
input LGF8_IU_CO；
input LGF8_X_C0；
input LGF8_XU_C0；
output [7：0] gt_o_C2；
output gt_kill_C2；
input [31：0] ars_i_C1；
output [31：0] ars_o_C1；
output ars_kill_C1；
input [7：0] imm8_C0；
output [7：0] gr_o_C2；
output gr_kill_C2；
input [31：0] art_i_C1；
input [7：0] MemDataIn8_C2；
input [31：0] VAddrIn_C1；
output [4：0] LSSize_C0；
output [31：0] VAddrBase_C1；
output [31：0] VAddrIndex_C1；
output [31：0] VAddrOffset_C0；
<dp n="d306"/>
output LSIndexed_C0；
input clk；
wire indexed_C0；
assign indexed_C0＝(LGF8_X_C0)|(LGF8_XU_C0)；
assign LSSize_C0＝32′h1；
assign VAddrBase_C1＝ars_i_C1；
assign LSIndexed_C0＝indexed_C0；
assign VAddrOffset_C0＝imm8_C0；
assign VAddrIndex_C1＝arti_C1；
assign gt_o_C2＝MemDataIn8_C2；
assign gr_o_C2＝MemDataIn8_C2；
assign ars_o_C1＝VAddrIn_C1；
wire LGF8_I_C2；
xtdelay2 #(1) iLGF8_I_C2(.xtin(LGF8_I_C0)，.xtout(LGF8_I_C2)，.clk(clk))；
wire LGF8_IU_C2；
xtdelay2 #(1) iLGF8_IU_C2(.xtin(LGF8_IU_C0)，.xtout(LGF8_IU_C2)，
.clk(clk))；
assign gt_ki1l_C2＝(1′b0)&((LGF8_I_C2)|(LGF8_IU_C2))；
wire LGF8_IU_C1；
xtdelay1 #(1) iLGF8_IU_C1(.xtin(LGF8_IU_C0)，.xtout(LGF8_IU_C1)，
.clk(clk))；
wire LGF8_XU_C1；
xtdelay1 #(1) iLGF8_XU_C1(.xtin(LGF8_XU_C0)，.xtout(LGF8_XU_C1)，
.clk(clk))；
assign ars_kill_C1＝(1′b0)&((LGF8_IU_C1)|(LGF8_XU_C1))；
wire LGF8_X_C2；
xtdelay2 #(1) iLGF8_X_C2(.xtin(LGF8_X_C0)，.xtout(LGF8_X_C2)，.clk(clk))；
wire LGF8_XU_C2；
xtdelay2 #(1) iLGF8_XU_C2(.xtin(LGF8_XU_C0)，.xtout(LGF8_XU_C2)，
.clk(clk))；
assign gr_kill_C2＝(1′b0)&((LGF8_X_C2)|(LGF8_XU_C2))；
endmodule
module xmTIE_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
)；
input SGF8_I_C0；
input SGF8_IU_C0；
input SGF8_X_C0；
input SGF8_XU_C0；
input [7：0] gt_i_C1；
input [31：0] ars_i_C1；
<dp n="d307"/>
output [31：0] ars_o_C1；
output ars_kill_C1；
input [7：0] imm8_C0；
input [7：0] gr_i_C1;
input [31：0] art_i_C1；
input [31：0] VAddrIn_C1；
output [4：0] LSSize_C0；
output [7：0] MemDataOut8_C1；
output [31：0] VAddrBase_C1；
output [31：0] VAddrIndex_C1；
output [31：0] VAddrOffset_C0；
output LSIndexed_C0；
input clk；
wire indexed_C0；
assign indexed_C0＝(SGF8_X_C0)|(SGF8_XU_C0)；
assign LSSize_C0＝32′h1；
assign VAddrBase_C1＝ars_i_C1；
assign LSIndexed_C0＝indexed C0；
assign VAddrOffset_C0＝imm8_C0；
assign VAddrIndex_C1＝art_i_C1；
wire SGF8_X_C1；
xtdelay1 #(1) iSGF8_X_C1(.xtin(SGF8_X_C0)，.xtout(SGF8_X_C1)，.clk(clk))；
wire SGF8_XU_C1；
xtdelay1 #(1) iSGF8_XU_C1(.xtin(SGF8_XU_C0)，.xtout(SGF8_XU_C1)，
.clk(clk))；
assign MemDataOut8_C1＝((SGF8_X_C1)|(SGF8_XU_C1))？(gr_i_C1)：
(gt_i_C1)；
assign ars_o_C1＝VAddrIn_C1；
wire SGF8_IU_C1；
xtdelay1 #(1) iSGF8_IU_C1(.xtin(SGF8_IU_C0)，.xtout(SGF8_IU_C1)，
.clk(clk))；
assign ars_kill_C1＝(1′b0)&((SGF8_IU_C1)|(SGF8_XU_C1))；
endmodule
module xmTIE_RUR0(
RUR0_C0，
arr_o_C1，
arr_kill_C1，
gfmod_ps_C1，
clk
)；
input RUR0_C0；
output [31：0] arr_o_C1；
output arr_kill_C1；
input [7：0] gfmod_ps_C1；
input clk；
ass1gn arr_o_C1＝{gfmod_ps_C1}；
wire RUR0_C1 ；
xtdelay1 #(1) iRUR0_C1(.xtin(RUR0_C0)，.xtout(RUR0_C1)，.clk(clk))；
assign arr_kill_C1＝(1′b0)&(RUR0_C1)；
endmodule
module xmTIE_WUR0(
WUR0_C0，
art_i_C1，
gfmod_ns_Cl，
gfmod_kill_C1，
clk
)；
input WUR0_C0；
<dp n="d308"/>
input [31：0] art_i_C1；
output [7：0] gfmod_ns_C1；
output gfmod_kill_C1；
input clk；
assign gfmod_ns_C1＝{art_i_C1[7：0]}；
wire WUR0_C1；
xtdelay1 #(1) iWUR0_C1(.xtin(WUR0_C0)，.xtout(WUR0_C1)，.clk(clk))；
assign gfmod_kill_C1＝(1′b0)&(WUR0_C1)；
endmodule
module xmTIE(
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_E
TBus_E，
MemOpAddr_E，
Kill_E，
Except_W，
Replay_W，
<dp n="d309"/>
G1WCLK，
Reset
)；
output TIE_inst_R；
output TIE_asRead_R；
output TIE_atRead_R；
output TIE_atWrite_R；
output TIE_arWrite_R；
output TIE_asWrite_R；
output TIE_aWriteM_R；
output TIE_aDataKill_E；
output [31：0] TIE aWriteData_E；
output TIE_aDataKill_M；
output [31：0] TIE_aWriteData_M；
output TIE_Load_R；
output TIE_Store_R；
output [4：0] TIE_LSSize_R；
output TIE_LSIndexed_R；
output [31：0] TIE LSOffset_R；
input [127：0] TIE MemLoadData_M；
output [7：0] TIE MemStoreData8_E；
output [15：0] TIE MemStoreData16_E；
output [31：0] TIE MemStoreData32_E；
output [63：0] TIE MemStoreData64_E；
output [127：0] TIE MemStoreData128_E；
output TIE_Stall_R；
output TIE_Exception_E；
output [5：0] TIE_ExcCause_E；
output TIE bsRead R；
output TIE_btRead_R；
output TIE_btWrite_R；
output TIE_brWrite_R；
output TIE_bsWrite_R；
output [4：0] TIE_bsReadSize_R；
output [4：0] TIE_btReadSize_R；
output [4：0] TIE_bWriteSize_R；
input [15：0] TIE_bsReadData_E；
input [15：0] TIE_btReadData_E；
output TIE_bWriteData1_E；
output [1：0] TIE bWriteData2_E；
output [3：0] TIE bWriteData4_E；
output [7：0] TIE bWriteData8_E；
output [15：0] TIE bWriteData16_E；
output TIE_bDataKill_E；
input [7：0] CPEnable；
input [23：0] Instr_R；
input [31：0] SBus_E；
input [31：0] TBus_E；
input [31：0] MemOpAddr_E；
input Kill_E；
input Except_W；
input Replay_W；
input G1WCLK；
input Reset；
//unused signals
wire TMode＝0；
//control signals
wire KillPipe_W；
<dp n="d310"/>
wire clk；
//decoded signals
wire GFADD8_C0；
wire GFADD8I_C0；
wire GFMULX8_C0；
wire GFRWMOD8_C0；
wire LGF8_I_C0；
wire SGF8_I_C0；
wire LGF8_IU_C0；
wire SGF8_IU_C0；
wire LGF8_X_C0；
wire SGF8_X_C0；
wire LGF8_XU_C0；
wire SGF8_XU_C0；
wire RUR0_C0；
wire WUR0_C0；
wire [31：0] imm4_C0；
wire [7：0] imm8_C0；
wire art_use_C0；
wire art_def_C0；
wire ars_use_C0；
wire ars_def_C0；
wire arr_use_C0；
wire arr_def_C0；
wire br_use_C0；
wire br_def_C0；
wire bs_use_C0；
wire bs_def_C0；
wire bt_use_C0；
wire bt_def_C0；
wire bs4_use C0；
wire bs4_def_C0；
wire bs8_use_C0；
wire bs8_def_C0；
wire gr_use_C0；
wire gr_def_C0；
wire gs_use_C0；
wire gs_def_C0；
wire gt_use_C0；
wire gt_def_C0；
wire gfmod_use1_C0；
wire gfmod_def1_C0；
wire AR_rd0_use1_C0；
wire AR_rd0_width32_C0；
wire AR_rd1_use1_C0；
wire AR_rd1_width32_C0；
wire AR_wd_def1_C0；
wire AR_wd_width32_C0；
wire [3：0] gf_rd0_addr_C0；
wire gf_rd0_use1_C0；
wire gf_rd0_width8_C0；
wire [3：0] gf_rd1_addr_C0；
wire gf_rd1_usel_C0；
wire gf_rd1_width8_C0；
wire [3：0] gf_rd2_addr_C0；
wire gf_rd2_use1_C0；
wire gf_rd2_width8_C0；
wire [3：0] gf_wd_addr_C0；
wire gf_wd_def2_C0；
<dp n="d311"/>
wire gf_wd_def1_C0；
wire gf_wd_width8_C0；
wire gf1_semantic_C0；
wire gf4_semantic_C0；
wire gf2_semantic_C0；
wire gf3_semantic_C0；
wire lgf_semantic_C0；
wire sgf_semantic_C0；
wire RUR0_semantic_C0；
wire WUR0_semantic_C0；
wire load_instruction_C0；
wire store_instructior_C0；
wire TIE_Inst_C0；
wire [23：0] Inst_C0；
//state data，write-enable and stall signals
wire [7：0] gfmod_ps_C1；
wire [7：0] gfmod_ns_C1；
wire gfmod_kill_C1；
wire gfmod_stall_C1；
//register data，write-enable and stall signals
wire [31：0] AR_rd0_data_C1；
wire [31：0] AR_rd1_data_C1；
wire [31：0] AR_wd_data32_C1；
wire AR_wd_kill_C1；
wire [7：0] gf_rd0_data_C1；
wire [7：0] gf_rd1_data_C1；
wire [7：0] gf_rd2_data_C1；
wire [7：0] gf_wd_data8_C2；
wire gf_wd_kill_C2；
wire [7：0] gf_wd_data8_C1；
wire gf_wd_kill_C1；
wire gf_Stall_C1；
//operands
wire [31：0] art_i_C1；
wire [31：0] art_o_C1；
wire art_kill_C1；
wire [31：0] ars_i_C1；
wire [31：0] ars_o_C1；
wire ars_kill_C1：
wire [31：0] arr_o_C1；
wire arr_kill_C1；
wire [7：0] gr_i_C1；
wire [7：0] gr_o_C2；
wire gr_kill_C2；
wire [7：0] gr_o_C1；
wire gr_kill_C1；
wire [7：0] gs_i_C1；
wire [7：0] gt_i_C1；
wire [7：0] gt_o_C2；
wire gt_kill_C2；
wire [7：0] gt_o_C1；
wire gt_kill_C1；
//output state of semantic gf1
//output interface of semantic gf1
<dp n="d312"/>
//output operand of semantic gf1
wire [7：0] gf1_gr_o_C1；
wire gfl_gr_kill_C1；
//output state of semantic gf4
//output interface of semantic gf4
//output operand of semantic gf4
wire [7：0] gf4_gr_o_C1；
wire gf4_gr_kill_C1；
//output state of semantic gf2
//output interface of semantic gf2
//output operand of semantic gf2
wire [7：0] gf2_gr_o_C1；
wire gf2_gr_kill_C1；
//output state of semantic gf3
wire [7：0] gf3_gfmod_ns_C1；
wire gf3_gfmod_kill_C1；
//output interface of semantic gf3
//output operand of semantic gf3
wire [7：0] gf3_gt_o_C1；
wire gf3_gt_kill_C1；
//output state of semantic lgf
//output interface of semantic lgf
wire [4：0] lgf_LSSize_C0；
wire [31：0] lgf_VAddrBase_C1；
wire [31：0] lgf_VAddrIndex_C1；
wire [31：0] lgf_VAddrOffset_C0；
wire lgf_LSIndexed_C0；
//output operand of semantic lgf
wire [7：0] lgf_gt_o_C2；
wire lgf_gt_kill_C2；
wire [31：0] lgf_ars_o_C1；
wire lgf_ars_kill_C1；
wire [7：0] lgf_gr_o_C2；
wire lgf_gr_kill_C2 ；
//output state of semantic sgf
//output interface of semantic sgf
wire [4：0] sgf_LSSize_C0；
wire [7：0] sgf_MemDataOut8_C1；
wire [31：0] sgf_VAddrBase_C1；
wire [31：0] sgf_VAddrIndex_C1；
wire [31：0] sgf_VAddrOffset_C0；
wire sgf_LSIndexed_C0；
//output operand of semantic sgf
wire [31：0] sgf_ars_o_C1；
wire sgf_ars_kill_C1；
<dp n="d313"/>
//output state of semantic RUR0
//output interface of semantic RUR0
//output operand of semantic RUR0
wire [31：0] RUR0_arr_o_C1；
wire RUR0_arr_kill_C1；
//output state of semantic WUR0
wire [7：0] WUR0_gfmod_ns_C1；
wire WUR0_gfmod_kill_C1；
//output interface of semantic WUR0
//output operand of semantic WUR0
//TIE-defined interface signals
wire [31：0] VAddr_C1；
wire [31：0] VAddrBase_C1；
wire [31：0] VAddrOffset_C0；
wire [31：0] VAddrIndex_C1；
wire [31：0] VAddrIn_C1；
wire [4：0] LSSize_C0；
wire LSIndexed_C0；
wire [127：0] MemDataIn128_C2；
wire [63：0] MemDataIn64_C2；
wire [31：0] MemDataIn32_C2；
wire [15：0] MemDataIn16_C2；
wire [7：0] MemDataIn8_C2；
wire [127：0] MemDataOut128_C1；
wire [63：0] MemDataOut64_C1；
wire [31：0] MemDataOut32_C1；
wire [15：0] MemDataOut16_C1；
wire [7：0] MemDataOut8_C1；
wire Exception_C1；
wire [5：0] ExcCause_C1；
wire [7：0] CPEnable_C1；
xtflop #(1) reset(localReset，Reset，G1WCLK)；
xmTIE_decoder TIE_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)，
<dp n="d314"/>
.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(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_gf1 TIE_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)，
<dp n="d315"/>
.clk(clk))；
xmTIE_gf4 TIE_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_gf2 TIE_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_gf3 TIE_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_sgf TIE_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)，
<dp n="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_RUR0 TIE_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_WUR0 TIE_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_State TIE_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_Regfile TIE_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)，
<dp n="d317"/>
.wd_width8_C0(gf_wd_width8_C0)，
.Kill_E(Kill_E)，
.KillPipe_W(KillPipe_W)，
.Stall_R(gf_Stall_C1)，
.clk(clk)
)；
//Stall logic
assign TIE_Stall_R＝1′b0
|gf_Stall_C1
|gfmod_Stall_C1；
//pipeline semantic select signals to each stage
wire lgf_semantic_C1；
xtdelay1 #(1) ilgf_semantic_C1(.xtin(lgf_semantic_C0)，
xtout(lgf_semantic_C1)，.clk(clk))；
wire sgf_semantic_C1；
xtdelayl #(1) isgf_semantic_C1(.xtin(sgf_semantic_C0)，
.xtout(sgf_semantic_C1)，.clk(clk))；
wire gf3_semantic_C1；
xtdelay1 #(1)igf3_semantic_C1(.xtin(gf3_semantic_C0)，
.xtout(gf3_semantic_C1)，.clk(clk))；
wire WUR0_semantic_C1；
xtdelay1 #(1) iWUR0_semantic_C1(.xtin(WUR0_semantic_C0)，
.xtout(WUR0_semantic_C1)，.clk(clk))；
wire RUR0_semantic_C1；
xtdelay1 #(1) iRUR0_semantic_C1(.xtin(RUR0_semantic_C0)，
.xtout(RUR0_semantic_C1)，.clk(clk))；
wire lgf_semantic_C2；
xtdelay2 #(1) ilgf_semantic_C2(.xtin(lgf_semantic_C0)，
.xtout(lgf_semantic_C2)，.clk(clk))；
wire gf1_semantic_C1；
xtdelay1 #(1) igf1_semantic_C1(.xtin(gf1_semantic_C0)，
.xtout(gf1_semantic_C1)，.clk(clk))；
wire gf4_semantic_C1；
xtdelay1 #(1) igf4_semantic_C1(.xtin(gf4_semantic_C0)，
.xtout(gf4_semantic_C1)，.clk(clk))；
wire gf2_semantic_C1；
xtdelay1 #(1) igf2_semantic_C1(.xtin(gf2_semantic_C0)，
.xtout(gf2_semantic_C1)，.clk(clk))；
//combine output interface signals from all semantics
assign VAddr_C1＝32′b0；
assign VAddrBase_C1＝32′b0
|(lgf_VAddrBase_C1&{32{lgf_semantic_C1}})
|(sgf_VAddrBase_C1&{32{sgf_semantic_C1}})；
assign VAddrOffset_C0＝32′b0
|(lgf_VAddrOffset_C0&{32{lgf_semantic_C0}})
|(sgf_VAddrOffset_C0&{32{sgf_sematic_C0}})；
assign VAddrIndex_C1＝32′b0
|(lgf_VAddrIndex_C1&{32{lgf_semantic_C1}})
|(sgf_VAddrIndex_C1&{32{sgf_semantic_C1}})；
assign LSSize_C0＝5′b0
|(lgf_LSSize_C0&{5{lgf_semantic_C0}})
|(sgf_LSSize_C0&{5{sgf_semantic_C0}})；
assign LSIndexed_C0＝1′b0
|(lgf_LSIndexed_C0&lgf_semantic_C0)
|(sgf_LSIndexed_C0&sgf_semantic_C0)；
assign MemDataOut128_C1＝128′b0；
assign MemDataOut64_C1＝64′b0；
<dp n="d318"/>
assign MemDataOut32_C1＝32′b0；
assign MemDataOut16_C1＝16′b0；
assign MemDataOut8_C1＝8′b0
|(sgf_MemDataOut8_C1&{8{sgf_semantic_C1}})；
assign Exception_C1＝1′b0；
assign ExcCause_C1＝6′b0；
//combine output state signals from all semantics
assign gfmod_ns_C1＝8′b0
|(gf3_gfmod_ns_C1&{8{gf3_semantic_C1}})
|(WUR0_gfmod_ns_C1&{8{WUR0_semantic_C1}})；
assign gfmod_kill_C1＝1′b0
|(gf3_gfmod_kill_C1&gf3_semantic_C1)
|(WUR0_gfmod_kill_C1&WUR0_semantic_C1)；
//combine output operand signals from all semantics
assign art_o_C1＝32′b0；
assign art_kill_C1＝1′b0；
assign ars_o_C1＝32′b0
| (lgf_ars_o_C1&{32{lgf_semantic_C1}})
| (sgf_ars_o_C1&{32{sgf_semantic_C1}})；
assign ars_kill_C1＝1′b0
|(lgf_ars_kill_C1&lgf_semantic_C1)
|(sgf_ars_kill_C1&sgf_semantic_C1)；
assign arr_o_C1＝32′b0
|(RUR0_arr_o_C1&{32{RUR0_semantic_C1}})；
assign arr_kill_C1＝1′b0
|(RUR0_arr_kill_C1&RUR0_semantic_C1)；
assign gr_o_C2＝8′b0
|(lgf_gr_o_C2&{8{lgf_semantic_C2}})；
assign gr_kill_C2＝1′b0
|(lgf_gr_kill_C2&lgf_semantic_C2)；
assign gr_o_C1＝8′b0
|(gf1_gr_o_C1&{8{gf1_semantic_C1}})
|(gf4_gr_o_C1&{8{gf4_semantic_C1}})
|(gf2_gr_o_C1&{8{gf2_semantic_C1}})；
assign gr_kill_C1＝1′b0
|(gf1_gr_kill_C1&gf1_semantic_C1)
|(gf4_gr_kill_C1&gf4_semantic_C1)
|(gf2_gr_kill_C1&gf2_semantic_C1)；
assign gt_o_C2＝8′b0
|(1gf_gt_c_C2&{8{lgf_semantic_C2}})；
assign gt_kill_C2＝1′b0
|(lgf_gt_kill_C2&lgf_semantic_C2)；
assign gt_o_C1＝8′b0
|(gf3_gt_o_C1&{8{gf3_semantic_C1}})；
assign gt_kill_C1＝1′b0
|(gf3_gt_kill_C1&gf3_semantic_C1)；
//output operandto write portmapping logic
assign AR_wd_data32_C1＝ars_o_C1|arr_o_C1|32′b0；
assign AR_wd_kill_C1＝ars_kill_C1|arr_kill_C1|1′b0；
assign gf_wd_data8_C2＝gt_o_C2|gr_o_C2|8′b0；
assign gf_wd_kill_C2＝gt_kill_C2|gr_kill_C2|1′b0；
assign gf_wd_data8_C1＝gr_o_C1|gt_o_C1|8′b0；
assign gf_wd_kill_C1＝gr_kill_C1|gt_kill_C1|1′b0；
//read port to input operand mapping 1ogic
assign ars_i_C1＝AR_rd0_data_C1；
assign art_i_C1＝AR_rd1_data_C1；
<dp n="d319"/>
assign gs_i_C1＝gf_rd0_data_C1；
assign gt_i_C1＝gf_rd1_data_C1；
assign gr_i_C1＝gf_rd2_data_C1；
//logic to support verification
wire ignore_TIE_aWriteData_E＝-(AR_wd_def1_C0&(TIE_arWrite_R|
TIE_asWrite_R|TIE_atWrite_R)&-TIE_aDataKill_E)；
wire ignore_TIE_aWriteData_M＝-(1′b0&(TIE_arWrite_R|TIE_asWrite_R|
TIE_atWrite_R)&-TIE_aDataKill_M)；
wire ignore_TIE_bWriteData_E＝(-TIE_btWrite_R&-TIE_btWrite_R)|
TIE_bDataKill_E；
wire ignore_TIE_bWriteData16_E＝ignore_TIE_bWriteData_E；
wire ignore_TIE_bWriteData8_E＝ignore_TIE_bWriteData_E；
wire ignore_TIE_bWriteData4_E＝ignore_TIE_bWriteData_E；
wire ignore_TIE_bWriteData2_E＝ignore_TIE_bWriteData_E；
wire ignore_TIE_bWriteData1_E＝ignore_TIE_bWriteData_E；
wire ignore_TIE_LSSize_R＝-TIE_Load_R&-TIE_Store_R；
wire ignore_TIE_LSIndexed_R＝-TIE_Load_R&-TIE_Store_R；
wire ignore_TIE_LSOffset_R＝-TIE_Load_R&-TIE_Store_R|TIE_LSIndexed_R；
wire ignore_TIE_MemStoreData128_E＝(TIE_LSSize_R！＝5′b10000)|
-TIE_Store_R；
wire ignore_TIE_MemStoreData64_E＝(TIE_LSSize_R！＝5′b01000)|
-TIE_Store_R；
wire ignore_TIE_MemStoreData32_E＝(TIE_LSSize_R！＝5′b00100)|
-TIE_Store_R；
wire ignore_TIE_MemStoreData16_E＝(TIE_LSSize_R！＝5′b00010)|
-TIE_Store_R；
wire ignore_TIE_MemStoreData8_E＝(TIE_LSSize_R_！＝5′b00001)|
-TIE_Store_R；
//clock and instructions
assign clk＝G1WCLK；
assign Inst_C0＝Instr_R；
asgign TIE_inst_R＝TIE_Inst_C0；
//AR-related signals to/from core
assign TIE_asRead_R＝ars_use_C0；
assign TIE_atRead_R＝art_use_C0；
assign TIE_atWrite_R＝art_def_C0；
assign TIE_arWrite_R＝arr_def_C0；
assign TIE_asWrite_R＝ars_def_C0；
assign TIE_aWriteM_R＝0；
assign TIE_aWriteData_E＝ignore_TIE_aWriteData_E？0：AR_wd_data32_C1；
assign TIE_aWriteData_M＝ignore_TIE_aWriteData_M？0：0；
assign TIE_aDataKill_E＝AR_wd_kill_C1；
assign TIE_aDataKill_M＝0；
assign AR_rd0_data_C1＝SBus_E；
assign AR_rd1_data_C1＝TBus_E；
//BR-related signals to/from core
assign TIE_bsRead_R＝1′b0|bs_use_C0|bs4_use_C0|bs8_use_C0；
assign TIE_btRead_R＝1′b0|bt_use_C0；
assign TIE_btWrite_R＝1′b0|bt_def_C0；
assign TIE_bsWrite_R＝1′b0|bs_def_C0|bs4_def_C0|bs8_def_C0；
assign TIE_brWrite_R＝1′b0|br_def_C0；
assign TIE_bWriteData16_E＝ignore_TIE_bWriteData16_E？0：0；
assign TIE_bWriteData8_E＝ignore_TIE_bWriteData8_E？0：0；
assign TIE_bWriteData4_E＝ignore_TIE_bWriteData4_E？0：0；
assign TIE_bWriteData2_E＝ignore_TIE_bWriteData2_E？0：0；
assign TIE_bWriteData1_E＝ignore_TIE_bWriteData1_E？0：0；
<dp n="d320"/>
assign TIE_bDataKill_E＝0；
assign TIE_bWriteSize_R＝{1′b0，1′b0，1′b0，1′b0，1′b0}；
assign TIE_bsReadSize_R＝{1′b0，1′b0，1′b0，1′b0，1′b0}；
assign TIE_btReadSize_R＝{1′b0，1′b0，1′b0，1′b0，1′b0}；
//Load/store signals to/from core
assign TIE_Load_R＝load_instruction_C0；
assign TIE_Store_R＝store_instruction_C0；
assign TIE_LSSize_R＝ignore_TIE_LSSize_R？0：LSSize_C0；
assign TIE_LSIndexed_R＝ignore_TIE_LSIndexed_R？0：LSIndexed_C0；
assign TIE_LSOffset_R＝ignore_TIE_LSOffseT_R？0：VAddrOffseT_C0；
assign TIE_MemStoreData128_E＝ignore_TIE_MemStoreData128_E？0：
MemDataOut128_C1；
assign TIE_MemStoreData64_E＝ignore_TIE_MemStoreData64_E？0：
MemDataOut64_C1；
assign TIE_MemStoreData32_E＝ignore_TIE_MemStoreData32_E？0：
MemDataOut32_C1；
assign TIE_MemStoreData16_E＝ignore_TIE_MemStoreData16_E？0：
MemDataOut16_C1；
assign TIE_MemStoreData8_E＝ignore_TIE_MemStoreData8_E？0：
MemDataOut8_C1；
assign MemDataIn128_C2＝TIE_MemLoadData_M；
assign MemDataIn64_C2＝TIE_MemLoadData_M；
assign MemDataIn32_C2＝TIE_MemLoadData_M；
assign MemDataIn16_C2＝TIE_MemLoadData_M；
assign MemDataIn8_C2＝TIE_MemLoadData_M；
assign VAddrIn_C1＝MemOpAddr_E；
//CPEnable and control signals to/from core
assign CPEnable_C1＝CPEnable；
assign TIE_Exception_E＝Exception_C1；
assign TIE_ExcCause_E＝ExcCause_C1；
assign KillPipe_W＝Except_W|Replay_W；
endmodule
module xtdelay1(xtout，xtin，clk)；
parameter size＝1；
output [size-1：0] xtout；
input [size-1：0] xtin；
input clk；
assign xtout＝xtin；
endmodule
module xtdelay2(xtout，xtin，clk)；
parameter size＝1；
output [size-1：0] xtout；
input [size-1：0] xtin；
input clk；
assign xtout＝xtin；
endmodule
module xtRFenlatch(xtRFenlatchout，xtin，xten，clk)；
parameter size＝32；
output [size-1：0] xtRFenlatchout；
input [size-1：0] xtin；
input xten；
input clk；
reg[size-1：0] xtRFenlatchout；
always@(clk or xten or xtin or xtRFenlatchout)begin
<dp n="d321"/>
if (clk)begin
xtRFenlatchout＜＝#1(xten)？xtin：xtRFenlatchout；
end
end
endmodule
module xtRFlatch(xtRFlatchout，xtin，clk)；
parameter size＝32；
output [size-1：0] xtRFlatchout；
input [size-1：0] xtin；
input clk；
reg[size-1：0] xtRFlatchout；
always@(clk or xtin) begin
if(clk)begin
xtRFlatchout＜＝#1 xtin；
end
end
endmodule
module xtadd(xtout，a，b)；
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] a；
input [size-1：0] b；
assign xtout＝a+b；
endmodule
module xtaddc(sum，carry，a，b，c)；
parameter size＝32；
output [size-1：0]sum；
output carry；
input [size-1：0] a；
input [size-1：0] b；
input c；
wire junk；
assign{carry，sum，junk}＝{a，c}+{b，c}；
endmodule
module xtaddcin(xtout，a，b，c)；
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] a；
input [size-1：0] b；
input c；
assign xtout＝({a，c}+{b，c})＞＞1；
endmodule
module xtaddcout(sum，carry，a，b)；
parameter size＝1；
output [size-1：0] sum；
<dp n="d322"/>
output carry；
input [size-1：0] a；
input [size-1：0] b；
assign{carry，sum}＝a+b；
endmodule
module xtbooth(out，cin，a，b，sign，negate)；
parameter size＝16；
output [size+1：0] out；
output cin；
input [size-1：0] a；
input [2：0]b；
input sign，negate；
wire ase＝sign & a[size-1]；
wire [size+1：0] ax1＝{ase，ase，a}；
wire [size+1：0] ax2＝{ase，a，1′d0}；
wire one＝b[1] ^b[0]；
wire two＝b[2]？-b[1]&-b[0]：b[1]&b[0]；
wire cin＝negate？ (-b[2]&(b[1]|b[0]))：(b[2]&-(b[1]&b[0]))；
assign out＝{size+2{cin}}^(ax1&{size+2{one}}|ax2&{size+2{two}})；
endmodule
module xtclock_gate_nor(xtout，xtin1，xtin2)；
output xtout；
input xtin1，xtin2；
assign xtout＝-(xtin1||xtin2)；
endmodule
module xtclock_gate_or(xtout，xtin1，xtin2)；
output xtout；
input xtin1，xtin2；
assign xtout＝(xtin1||xtin2)；
endmodule
module xtcsa(sum，carry，a，b，c)；
parameter size＝1；
output [size-1：0] sum；
output [size-1：0] carry；
input [size-1：0] a；
input [size-1：0] b；
input [size-1：0] c；
assign sum＝a^b^c；
assign carry＝(a&b)|(b&c)|(c&a)；
endmodule
module xtenflop(xtout，xtin，en，clk)；
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] xtin；
input en；
input clk；
reg [size-1：0] tmp；
assign xtout＝tmp；
always@(posedge clk) begin
<dp n="d323"/>
if(en)
tmp＜＝#1 xtin；
end
endmodule
module xtfa(sum，carry，a，b，c)；
output sum，carry；
input a，b，c；
assign sum＝a^b^c；
assign carry＝a&b|a&c|b&c；
endmodule
module xtflop(xtout，xtin，clk)；
parameter size＝32；
output[size-1：0] xtout；
input[size-1：0] xtin；
input clk；
reg[size-1：0] tmp；
assign xtout＝tmp；
always@(posedge clk) begin
tmp＜＝#1 xtin；
end
endmodule
module xtha(sum，carry，a，b)；
output sum，carry；
input a，b；
assign sum＝a^b；
assign carry＝a&b；
endmodule
module xtinc(xtout，a)；
parameter size＝32；
output[size-1：0] xtout；
input[size-1：0] a；
assign xtout＝a+1；
endmodule
module xtmux2e(xtout，a，b，sel)；
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] a；
input [size-1：0] b；
input sel；
assign xtout＝(-sel)？a：b；
endmodule
module xtmux3e(xtout，a，b，c，sel)；
parameter size＝32；
outpit [size-1：0]xtout；
input [size-1：0] a；
input [size-1：0] b；
input [size-1：0] c；
input [1：0] sel；
reg [size-1：0] xtout；
<dp n="d324"/>
always@(a or b or cor sel) begin
xtout＝sel[1]？c：(sel[0]？b：a)；
end
endmodule
module xtmux4e(xtout，a，b，c，d，sel)；
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] a；
input [size-1：0] b；
input [size-1：0] c；
input [size-1：0] d；
input [1：0] sel；
reg [size-1：0] xtout；
//synopsys infer_mux″xtmux4e″
always@(sel or a or b or c or d)begin：xtmux4e
case(sel)//synopsys parallel_case full_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@(sel or a or b or c or d)
endmodule
module xtnflop(xtout，xtin，clk)；
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] xtin；
input clk；
reg [size-1：0] tmp；
assign xtout＝tmp；
always@(negedge clk) begin
tmp＜＝#1 xtin；
end//always@(negedge clk)
endmodule
module xtscflop(xtout，xtin，clrb，clk)；//sync clear ff
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] xtin；
input clrb；
input clk；
reg [size-1：0] tmp；
assign xtout＝tmp；
always@(posedge clk) begin
if(！clrb)tmp＜＝0；
<dp n="d325"/>
else tmp＜＝#1 xtin；
end
endmodule
module xtscenflop(xtout，xtin，en，clrb，clk)；//sync clear
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] xtin；
input en；
input clrb；
input clk；
reg [size-1：0] tmp；
assign xtout＝tmp；
always@(posedge clk) begin
if(！clrb)tmp＜＝0；
else if(en)
tmp＜＝#1 xtin；
end
endmodule
verysys/verify ref.v
module xmTIE_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，wd def2_Co，wd_data8_C1，wd_data8_C2，wd_wen_C1，wd_wen_C2，
kill_E，KillPipe_W，Stall_R，clk)；
output [7：0] rd0_data_C1；
input [3：0] rd0_addr_C0；
input rd0_width8_C0；
input rd0_use1_C0；
output [7：0] rd1_data_C1；
input [3：0] rd1_addr_C0；
input rd1_width8_C0；
input rd1_use1_C0；
output [7：0] rd2_data_C1；
input [3：0] rd2_addr_C0；
input rd2_width8_C0；
input rd2_use1_C0；
input [3：0] wd_addr_C0；
input wd_width8_C0；
input wd_def1_C0；
input wd_def2_C0；
input [7：0] wd_data8_C1；
input [7：0] wd_data8_C2；
input wd_wen_C1；
input wd_wen_C2；
input Kill_E；
input KillPipe_W；
output Stall_R；
input clk；
/***********************************************************************
<dp n="d326"/>
READ PORT rd0
***********************************************************************/
//compute the address mask
wire rd0_addr_mask_C0＝1′d0；
//masked address pipeline
wire rd0_maddr_C0＝1′d0；
//bank-qualified use
wire rd0_use1_bank0_C0＝(rd0_use1_C0&(rd0_maddr_C0＝＝(1′d0 &
rd0_addr_mask_C0)))；
//alignment mux for use 1
wire[7：0] rd0_data_bank0_C1；
assign rd0_data_C1[7：0]＝rd0_data_bank0_C1；
/***********************************************************************
READ PORT rd1
***********************************************************************/
//compute the address mask
wire rd1_addr_mask_C0＝1′d0；
//masked address pipeline
wire rd1_maddr_C0＝1′d0；
//bank-qualified use
wire rd1_use1_bank0_C0＝(rd1_use1_C0&(rd1_maddr_C0＝＝(1′d0 &
rd1_addr_mask_C0)))；
//alignment mux for use 1
wire[7：0] rd1_data_bank0_C1；
assign rd1_data_C1[7：0]＝rd1_data_bank0_C1；
/***********************************************************************
READ PORT rd2
***********************************************************************/
//compute the addresg mask
wire rd2_addr_mask_C0＝1′d0；
//masked address pipeline
wire rd2_maddr_C0＝1′d0；
//bank-qualified use
wire rd2_use1_bank0_C0＝(rd2_use1_C0&(rd2_maddr_C0＝＝(1′d0 &
rd2_addr_mask_C0)))；
//alignment mux for use 1
wire[7：0]rd2_data_bank0_C1；
assign rd2_data_C1[7：0]＝rd2_data_bank0_C1；
/***********************************************************************
<dp n="d327"/>
WRITE PORT wd
***********************************************************************/
//compute the address mask
wire wd_addr_mask_C0＝1′d0；
//bank-qualified write def for port wd
wire wd_def1_bank0_C0＝(wd_def1_C0&((wd_addr_C0&wd_addr_mask_C0)
＝＝(1′d0 & wd_addr_mask_C0)))；
wire wd_def2_bank0_C0＝(wd_def2_C0&((wd_addr_C0&wd_addr_mask_C0)
＝＝(1′d0&wd_addr_mask C0)))；
//write mux for def 1
wire [7：0] wd_wdata_C1；
assign wd_wdata_C1＝{1{wd_data8_C1[7：0]}}；
//write mux for def 2
wire [7：0] wd_wdata_C2；
assign wd_wdata_C2＝{1{wd_data8_C2[7：0]}}；
wire Stall_R0；
/***********************************************************************
PIPELINED BANK
***********************************************************************/
xmTIE_gf_Regfile_bank TIE_gf_Regfile_snk0(rd0_data_bank0_C1，
rd0_addr_C0[3：0]，rd0_use1_bank0_C0，rd1_data_bank0_C1，
rd1_addr_C0[3：0]，
rd1_use1_bank0_C0，rd2_data_bank0_C1，rd2_addr_C0[3：0]，
rd2_use1_bank0_C0，
wd_addr_C0[3：0]，wd_def1_bank0_C0，wd_def2_bank0_C0，
wd_wdata_C1[7：0]，
wd_wdata_C2[7：0]，wd_wen_C1，wd_wen_C2，Kill_E，KillPipe_W，
Stall_R0，
clk)；
assign Stall_R＝Stall_R0|1′b0；
endmodule
module xmTIE_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 wer_C1，wd_wen_C2，Kill_E，KillPipe_W，stall_R，clk)；
output [7：0] rd0_data_C1；
input [3：0] rd0_addr_C0；
input rd0_use1_C0；
output [7：0] rd1_data_C1；
input [3：0] rd1_addr_C0；
input rd1_use1_C0；
output [7：0] rd2_data_C1；
input [3：0] rd2_addr_C0；
input rd2_use1_C0；
input [3：0] wd_addr_C0；
input wd_def1_C0；
input wd_def2_C0；
input [7：0] wd_data_C1；
<dp n="d328"/>
input [7：0] wd_data_C2；
input wd_wen_C1；
input wd_wen_C2；
input Kill_E；
input KillPipe_W；
output Stall_R；
input clk；
wire rd0_use2_C0＝1′d0；
wire rdl_use2_C0＝1′d0；
wire rd2_use2_C0＝1′d0；
wire kill_C0＝KillPipe_W；
wire kill_C1＝KillPipe_W|Kill_E；
wire kill_C2＝KillPipe_W；
wire kill_C3＝KillPipe_W；
//write definition pipeline
wire wd_ns_def1_C0＝wd_def1_C0 & 1′b1 & -kill_C0；
wire wd_def1_C1；
xtdelay1 #(1) iwd_def1_C1(wd_def1_c1，wd_ns_def1_C0，clk)；
wire wd_ns_def2_C0＝wd_def2_C0 & 1′b1 & -kill_C0；
wire wd_def2_C1；
xtdelay1 #(1) iwd_def2_C1(wd_def2_C1，wd_ns_def2_C0，clk)；
wire wd_ns_def2_C1＝wd_def2_C1 & wd_wen_C1 & -kill_C1；
wire wd_def2_C2；
xtdelay1 #(1) iwd_def2_C2(wd_def2_C2，wd_ns_def2_C1，clk)；
//write enable pipeline
wire wd_we_C2；
wire wd_we_C3；
wire wd_ns_we_C1＝(1′d0|(wd_defl_C1 & wd_wen_C1)) &-kill_C1；
wire wd_ns_we_C2＝(wd_we_C2|(wd_def2_C2 & wd_wen_C2))&-kill_C2；
wire wd_ns_we_C3＝(wd_we_C3|(1′d0 & 1′d0)) & -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)；
//write address pipeline
wire [3：0] wd_addr_C1；
wire [3：0] wd_addr_C2；
wire [3：0] 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)；
//write data pipeline
wire [7：0] wd_result_C2；
wire [7：0] wd_result_C3；
wire [7：0] wd_mux_C1＝wd_data_C1；
wire [7：0] wd_mux_C2＝wd_def2_C2？wd_data_C2：wd_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 [7：0] rd0_data_C0；
wire [7：0] rd1_data_C0；
wire [7：0] 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)；
<dp n="d329"/>
xtdelay1 #(8) ird2_data_C1(rd2_data_C1，rd2_data_C0，clk)；
assign Stall_R＝
((wd_addr_C1＝＝rd0_addr_C0)&(
(rd0_use1_C0&(wd_ns_def2_C1))))|
((wd_addr_C1＝＝rd1_addr_C0)&(
(rd1_use1_C0&(wd_ns_def2_C1))))|
((wd_addr_C1＝＝rd2_addr_C0)&(
(rd2_use1_C0&(wd_ns_def2_C1))))|
1′b0；
//verification register file replacement
wire [7：0] 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_data_C0，xwd_verify，c1k)；
xtflop #(8) rd2_verify(rd2_data_C0，xwd_verify，clk)；
endmodule
module xmTIE_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[7：0] ps_data_C1；
input ps_width8_C0；
input ps_use1_C0；
input ns_width8_C0；
input ns_def1_C0 ；
input [7：0] ns_data8_C1；
input ns_wen_C1；
input Kill_E；
input KillPipe_W；
output Stall_R；
input clk；
wire ps_addr_C0＝1′d0；
wire ns_addr_C0＝1′d0；
wire ns_wen_C2＝1′d1；
/*****************************************************************************************
READ PORT ps
*********************************************************************************************/
//compute the address mask
wire ps_addr_mask_C0＝1′d0；
//masked address pipeline
wire ps_maddr_C0＝1′d0；
//bank-qualified use
wire ps_use1_bank0_C0＝(ps_use1_C0 & (ps_maddr_C0＝＝(1′d0 &
ps_addr__mask_C0)))；
//alignment mux for use 1
wire [7：0] ps_data_bank0_C1；
assign ps_data C1[7：0]＝ps_data_bank0_C1；
<dp n="d330"/>
/**************************************************************************************
WRITE PORT ns
****************************************************************************/
//compute the address mask
wire ns_addr_mask_C0＝1′d0；
//bank-qualified write def for port ns
wire ns_def1_bank0_C0＝(ns_def1_C0&((ns_addr_C0 & ns_addr mask_C0)
＝＝(1′d0 & ns_addr_mask_C0)))；
//write mux for def 1
wire[7：0]ns_wdata_C1；
assign ns_wdata_C1＝{1{ns_data8_C1[7：0]}}；
wire Stall_R0；
/*********************************************************************************************
PIPELINED BANK
*****************************************************************************************************/
xmTIE_gfmod_State_bank TIE_gfmod_State_bank0(ps_data_bank0_C1，
ps_use1_bank0_C0，ns_def1_bank0_C0，ns_wdata_C1[7：0]，ns_wen_C1，
ns_wen_C2，Kill_E，KillPipe_W，Stall_R0，clk)；
assign Stall_R＝Stall_R0|1′b0；
endmodule
module xmTIE_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 [7：0]ps_data_C1；
input ps_use1_C0；
input ns_def1_C0；
input [7：0] ns_data_C1；
input ns_wen_C1；
input ns_wen_C2；
input Kill_E；
input KillPipe_W；
output Stall_R；
input clk；
wire ps_addr_C0＝1′d0；
wire ps_use2_C0＝1′d0；
wire ns_addr_C0＝1′d0；
wire ns_def2_C0＝1′d0；
wire [7：0] ns_data_C2＝0；
wire kill_C0＝KillPipe_W；
wire kill_C1＝KillPipe_W|Kill_E；
wire kill_C2＝KillPipe_W；
wire kill_C3＝KillPipe_W；
//write definition Pipeline
wire ns_ns_def1_C0＝ns_def1_C0 & 1′b1 & -kill_C0；
wire ns_def1_C1；
<dp n="d331"/>
xtde1ay1 #(1)ins_def1_C1(ns_def1_C1，ns_ns_def1_C0，clk)；
wire ns_ns_def2_C0＝1′d0；
wire ns_def2_C1＝1′d0；
wire ns_ns_def2 C1＝1′d0；
wire ng_def2_C2＝1′d0；
//write enable pipeline
wire ns_we_C2；
wire ns_we_C3；
wire ns_ns_we_C1＝(1′d0|(ns_def1_C1 & ns_wen_C1)) & -kill_C1；
wire ns_ns_we_C2＝(ns_we_C2|(ns_def2_C2 & ns_wen_C2)) & -kill_C2；
wire ns_ns_we_C3＝(ns_we_C3|(1′d0 & 1′d0)) & -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)；
//write address pipeline
wire ns_addr_C1；
wire ns_addr_C2 ；
wire ns_addr_C3；
assign ns_addr_C1＝1′d0；
assign ns_addr_C2＝1′d0；
assign ns_addr_C3＝1′d0；
//write data pipeline
wire [7：0] ns_result_C2；
wire [7：0] ns_result_C3；
wire [7：0] ns_mux_C1＝ns_data_C1；
wire [7：0] ns_mux_C2＝ns_def2_C2？ns_data_C2：ns_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[7：0]ps_data_C0；
xtdelay1 #(8)ips_data_C1(ps_data_C1，ps_data_C0，clk)；
assign Stall_R＝
((ns_addr_C1＝＝ps_addr_C0)&(
(ps_usel_C0&(ns_ns_def2_C1))))|
1′b0；
//verification register file replacement
wire[7：0]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)；
endmodule
module xmTIE_decoder(
GFADD8，
GFADD8I，
GFMULX8
GFRWMOD8，
LGF8_I，
SGF8_I，
LGF8_IU，
SGF8_IU，
LGF8_X，
SGF8_X，
LGF8_XU，
SGF8_XU，
<dp n="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，
<dp n="d333"/>
WUR0_semantic，
load_instruction，
store_instruction，
TIE_Inst，
Inst
)；
output GFADD8；
output GFADD8I；
output GFMULX8；
output GFRWMOD8；
output LGF8_I；
output SGF8_I；
output LGF8_IU；
output SGF8_IU；
output LGF8_X；
output SGF8_X；
output LGF8_XU；
output SGF8_XU；
output RUR0；
output WUR0；
output [31：0]imm4；
output [7：0]imm8；
output art_use；
output art_def；
output ars_use；
output ars_def；
output arr_use；
output arr_def；
output br_use；
output br_def；
output bs_use；
output bs_def；
output bt_use；
output bt_def；
output bs4_use；
output bs4_def；
output bs8_use；
output bs8_def；
output gr_use；
output gr_def；
output gs_use；
output gs_def；
output gt_use；
output gt_def；
output gfmod_use1；
output gfmod_def1；
output AR_rd0_use1；
output AR_rd0_width32；
output AR_rd1_use1；
output AR_rd1_width32；
output AR_wd_def1；
output AR_wd_width32；
output [3：0]gf_rd0_addr；
output gf_rd0_use1；
output gf_rd0_width8 ；
output [3：0]gf_rd1_addr；
output gf_rd1_use1；
output gf_rd1_width8；
output [3：0]gf_rd2_addr；
output gf_rd2_use1；
<dp n="d334"/>
output gf_rd2_width8；
output [3：0]gf_wd_addr；
output gf_wd_def2；
output gf_wd_def1；
output gf_wd_width8；
output GFADD8_semantic；
output GFADD8I_semantic；
output GFMULX8_semantic；
output GFRWMOD8_semantic；
output LGF8_I_semantic；
output LGF8_IU_semantic；
output LGF8_X_semantic；
output LGF8_XU_semantic；
output SGF8_I_semantic；
output SGF8_IU_semantic；
output SGF8_X_semantic；
output SGF8_XU_semantic；
output RUR0_semantic；
output WUR0_semantic；
output load_instruction；
output store_instruction；
output TIE_Inst；
input [23：0]Inst；
wire [3：0]op2＝{Inst[23：20])；
wire [3：0]op1＝{Inst[19：16]}；
wire [3：0]op0＝{Inst[3：0]}；
wire QRST＝(op0＝＝4′b0000)；
wire CUST0＝(op1＝＝4′b0110) & QRST；
assign GFADD8＝(op2＝＝4′b0000) & CUST0；
assign GFADD8I＝(op2＝＝4′b0100) & CUST0；
assign GFMULX8＝(op2＝＝4′b0001) & CUST0；
assign GFRWMOD8＝(op2＝＝4′b0010) & CUST0；
wire [3：0]r＝{Inst[15：12]}；
wire LSCI＝(op0＝＝4′b0011)；
assign LGF8_I＝(r＝＝4′b0000) & LSCI；
assign SGF8_I＝(r＝＝4′b0001) & LSCI；
assign LGF8_IU＝(r＝＝4′b0010) & LSCI；
assign SGF8_IU＝(r＝＝4′b0011) & LSCI；
wire LSCX＝(op1＝＝4′b1000) & QRST；
assign LGF8_X＝(op2＝＝4′b0000) & LSCX；
assign SGF8_X＝(op2＝＝4′b0001) & LSCX；
assign LGF8_XU＝(op2＝＝4′b0010) & LSCX；
assign SGF8_XU＝(op2＝＝4′b0011) & LScX；
wire [3：0]s＝{Inst[11：8]}；
wire [3：0]t＝{Inst[7：4]}；
wire [7：0]st＝{s，t}；
wire RST3＝(op1＝＝4′b0011) & QRST；
wire RUR＝(op2＝＝4 ′b1110) & RST3；
assign RUR0＝(st＝＝8′b00000000) & RUR；
wire [7：0]sr＝{r，s}；
wire WUR＝(op2＝＝4′b1111) & RST3；
assign WUR0＝(sr＝＝8′b00000000) & WUR；
assign gfmod_use1＝GFMULX8|GFRWMOD8|RUR0|1′b0；
assign gfmod_def1＝GFRWMOD8|WUR0|1′b0；
assign AR_rd0_use1＝1′b0
|LGF8_I
| SGF8_I
|LGF8_IU
|SGF8_IU
<dp n="d335"/>
|LGF8_X
|SGF8_X
|LGF8_XU
|SGF8_XU；
assign AR_rd0_width32＝1′b0；
assign AR_rd1_use1＝1′b0
|LGF8_X
|SGF8_X
|LGF8_XU
|SGF8_XU
|WUR0；
assign AR_rd1_width32＝1′b0；
assign AR_wd_def1＝1′b0
|LGF8_IU
|SGF8_IU
|LGF8_XU
|SGF8_XU
|RUR0；
assign AR_wd_width32＝1′b0；
assign gf_rd0_use1＝1′b0
|GFADD8
|GFADD8I
|GFMUX8；
assign gf_rd0_width8＝1′b0；
assign gf_rd1_use1＝1′b0
|GFADD8
|GFRWMOD8
|SGF8_I
|SGF8_IU；
assign gf_rd1_width8＝1′b0；
assign gf_rd2_use1＝1′b0
|SGF8_X
|SGF8_XU；
assign gf_rd2_width8＝1′b0；
assign gf_wd_def2＝1′b0
|LGF8_I
|LGF8_IU
|LGF8_X
|LGF8_XU；
assign gf_wd_def1＝1′b0
|GFADD8
|GFADD8I
|GFMULX8
|GFRWMOD8；
assign gf_wd_width8＝1′b0；
assign art_def＝1′b0；
assign art_use＝LGF8_X|SGF8_X|LGF8_XU|SGF8_XU|WUR0|1′b0；
assign ars_def＝LGF8_IU|SGF8_IU|LGF8_XU|SGF8_XU|1′b0；
assign ars_use＝LGF8_I|SGF8_I|LGF8_IU|SGF8_IU|LGF8_X|SGF8_X|
LGF8_XU|SGF8_XU|1′b0；
assign arr_def＝RUR0|1′b0；
assign arr_use＝1′b0；
assign br_def＝1′b0；
assign br_use＝1′b0；
assign bs_def＝1′b0；
assign bs_use＝1′b0；
assign bt_def＝1′b0；
assign bt_use＝1′b0；
assign bs4_def＝1′b0；
assign bs4_use＝1′b0；
<dp n="d336"/>
assign bs8_def＝1′b0；
assign bs8_use＝1′b0；
assign gr_def＝GFADD8|GFADD8I|GFMULX8|LGF8_X|LGF8_XU|1′b0；
assign gr_use＝SGF8_X|SGF8_XU|1′b0；
assign gs_def＝1′b0；
assign gs_use＝GFADD8|GFADD8I|GFMULX8|1′b0；
assign gt_def＝GFRWMOD8|LGF8_I|LGF8_IU|1′b0；
assign gt_use＝GFADD8|GFRWMOD8|SGF8_I|SGF8_IU|1′b0；
wire [3：0]gr_addr＝r；
wire [3：0]gs_addr＝s；
wire [3：0]gt_addr＝t；
assign gf_wd_addr＝4′b0
|{4{gr_def}}& gr_addr
|{4{gt_def}}& gt_addr；
assign gf_rd0_addr＝gs_addr；
assign gf_rd1_addr＝gt_addr；
assign gf_rd2_addr＝gr_addr；
assign GFADD8_semantic＝GFADD8|1′b0；
assign GFADD8I_semantic＝GFADD8I|1′b0；
assign GFMULX8_semantic＝GFMULX8|1′b0；
assign GFRWMOD8_semantic＝GFRWMOD8|1′b0；
assign LGF8_I_semantic＝LGF8_I|1′b0；
assign LGF8_IU_semantic＝LGF8_IU|1′b0；
assign LGF8_X_semantic＝LGF8_X|1′b0；
assign LGF8_XU_semantic＝LGF8_XU|1′b0；
assign SGF8_I_semantic＝SGF8_I|1′b0；
assign SGF8_IU_semantic＝SGF8_IU|1′b0；
assign SGF8_X_semantic＝ SGF8_X|1′b0；
assign SGF8_XU_semantic＝SGF8_XU|1′b0；
assign RUR0_semantic＝RUR0|1′b0；
assign WUR0_semantic＝WUR0|1′b0；
assign imm4＝t；
wire[7：0]imm8＝{Inst[23：16]}；
assign load_instruction＝1′b0
|LGF8_I
|LGF8_IU
|LGF8_X
|LGF8_XU；
assign store_instruction＝1′b0
|SGF8_I
|SGF8_IU
|SGF8_X
|SGF8_XU；
assign TIE_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
<dp n="d337"/>
module xmTIE_GFADD8(
GFADD8_C0，
gr_o_C1，
gr_kill_C1，
gs_i_C1，
gt_i_C1，
clk
)；
input GFADD8_C0；
output[7：0]gr_o_C1；
output gr_ki1l_C1；
input[7：0]gs_i_C1；
input[7：0]gt_i_C1；
input clk；
assign gr_o_C1＝(gs_i_C1)＾(gt_i_C1)；
wire GFADD8_C1；
xtdelay1 #(1)iGFADD8_C1(.xtin(GFADD8_C0)，.xtout(GFADD8_C1)，.clk(clk))；
assign gr_kill_C1＝(1′b0)&(GFADD8_C1)；
endmodule
module xmTIE_GFADD8I(
GFADD8I_C0，
gr_o_C1，
gr_kill_C1，
gs_i_C1，
imm4_C0，
clk
)；
input GFADD8I_C0；
output[7：0]gr_o_C1；
output gr_kill_C1；
input [7：0]gs_i_C1；
input [31：0]imm4_C0；
input clk；
wire [31：0]imm4_C1；
xtdelay1 #(32)iimm4_C1(.xtin(imm4_C0)，.xtout(imm4_C1)，.clk(clk))；
assign gr_o_C1＝(gs_i_C1)^(imm4_C1)；
wire GFADD8I_C1；
xtdelayl #(1)iGFADD8I_C1(.xtin(GFADD8I_C0)，.xtout(GFADD8I_C1)，
.clk(clk))；
assign gr_kill_C1＝(1′b0)&(GFADD8I_C1)；
endmodule
module xmTIE_GFMULX8(
GFMULX8_C0，
gr_o_C1，
gr_kill_C1，
gs_i_C1，
gfmod_ps_C1，
clk
)；
input GFMULX8_C0；
output[7：0]gr_o_C1；
output gr_kill_C1 ；
input [7：0]gs_i_C1；
input [7：0]gfmod_ps_C1；
input clk；
assigu gr_o_C1＝(gs_i_C1[7])？(({gs_i_C1[6：0]，1′b0})＾(gfmod_ps_C1))：
({gs_i_C1[6：0]，1′b0})；
wire GFMULX8_C1；
<dp n="d338"/>
xtdelay1 #(1) iGFMULX8_C1(.xtin(GFMULX8_C0)，.xtout(GFMULX8_C1)，
.clk(clk))；
assign gr_kill_C1＝(1′b0)&(GFMULX8_C1)；
endmodule
module xmTIE_GFRWMOD8(
GFRWMOD8_C0，
gt_i_C1，
gt_o_C1，
gt_kill_C1，
gfmod_ps_C1，
gfmod_ns_C1，
gfmod_kill_C1，
clk
)；
input GFRWMOD8_C0；
input [7：0] gt_i_C1；
output [7：0] gt_o_C1；
output gt_kill_C1；
input [7：0] gfmod_ps_C1；
output [7：0] gfmod_ns_C1；
output gfmod_kill_C1；
input clk；
wire [7：0] t1_C1；
assign t1_C1＝gt_i_C1；
wire [7：0] t2_C1；
assign t2_C1＝gfmod_ps_C1；
assign gfmod_ns_C1＝t1_C1；
assign gt_o_C1＝t2_C1；
wire GFRWMOD8_C1；
xtdelay1 #(1) iGFRWMOD8_C1(.xtin(GFRWMOD8_C0)，.xtout(GFRWMOD8_C1)，
.clk(clk))；
assign gfmod_kill_C1＝(1′b0)&(GFRWMOD8_C1)；
assign gt_kill_C1＝(1′b0)&(GFRWMOD8_C1)；
endmodule
module xmTIE_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
)；
input LGF8_I_C0；
output [7：0] gt_o_C2；
output gt_kill_C2；
input [31：0] ars_i_C1；
input [7：0]imm8_C0；
input [7：0] MemDataIn8_C2；
output [4：0] LSSize_C0；
output [31：0] VAddrBase_C1；
output [31：0] VAddrOffset_C0；
output LSIndexed_C0；
input clk；
<dp n="d339"/>
assign LSSize_C0＝32′h1；
assign VAddrBase_C1＝ars_i_C1；
assign LSIndexed_C0＝1′b0；
assign VAddrOffset_C0＝imm8_C0；
assign gt_o_C2＝MemDataIn8_C2；
wire LGF8_I_C2；
xtdelay2 #(1) iLGF8_I_C2(.xtin(LGF8_I_C0)，.xtout(LGF8_I_C2)，.clk(clk))；
assign gt_kill_C2＝(1′b0)&(LGF8_I_C2)；
endmodule
module xmTIE_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
)；
input LGF8_IU_C0；
output [7：0] gt_o_C2；
output gt_kill_C2；
input [31：0] ars_i_C1；
output [31：0] ars_o_C1；
output ars_kill_C1；
input [7：0] imm8_C0；
input [7：0] MemDataIn8_C2；
input [31：0] VAddrIn_C1；
output [4：0] LSSize_C0；
output [31：0] VAddrBase_C1；
output [31：0] VAddrOffset_C0；
output LSIndexed_C0；
input clk；
assign LSSize_C0＝32′h1；
assign VAddrBase_C1＝ars_i_C1；
assign LSIndexed_C0＝1′b0；
assign VAddrOffset_C0＝imm8_C0；
assign gt_o_C2＝MemDataIn8_C2；
assign ars_o_C1＝VAddrIn_C1；
wire LGF8_IU_C2；
xtdelay2 #(1) iLGF8_IU_C2(.xtin(LGF8_IU_C0)，.xtout(LGF8_IU_C2)，
.clk(clk))；
assign gt_kill_C2＝(1′b0)&(LGF8_IU_C2)；
wire LGF8_IU_C1；
xtdelayl #(1) iLGF8_IU_C1(.xtin(LGF8_IU_C0)，.xtout(LGF8_IU_C1)，
.clk(clk))；
assign ars_kill_C1＝(1′b0)&(LGF8_IU_C1)；
endmoduIe
module xmTIE_LGF8_X(
LGF8_X_C0，
gr_o_C2，
gr_kill_C2，
<dp n="d340"/>
ars_i_C1，
art_i_C1，
MemDataIn8_C2，
VAddrIn_C1，
LSSize_C0，
VAddrBase_C1，
VAddrIndex_C1，
LSIndexed_C0，
clk
)；
input LGF8_X_C0；
output [7：0] gr_o_C2；
output gr_kill_C2；
input [31：0] ars_i_C1；
input [31：0] art_i_C1；
input [7：0] MemDataIn8_C2；
input [31：0] VAddrIn_C1；
output [4：0] LSSize_C0；
output [31：0] VAddrBase_C1；
output [31：0] VAddrIndex_C1；
output LSIndexed_C0；
input clk；
assign LSSize_C0＝32′h1；
assign VAddrBase_C1＝ars_i_C1；
assign LSIndexed_C0＝1′b1；
assign VAddrIndex_C1＝arti_C1；
assign gr_c_C2＝MemDataIn8_C2；
assign ars_o_C1＝VAddrIn_C1；
wire LGF8_X_C2；
xtdelay2 #(1) iLGF8_X_C2(.xtin(LGF8_X_C0)，.xtout(LGF8_X_C2)，.clk(clk))；
assign gr_kill_C2＝(1′b0)&(LGF8_X_C2)；
endmodule
module xmTIE_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
)；
input LGF8_XU_C0；
output [7：0] gr_o_C2；
output gr_kill_C2；
input [31：0] ars_i_C1；
output [31：0] ars_o_C1；
output ars_kill_C1；
input [31：0] art_i_C1；
input [7：0] MemDataIn8_C2；
input [31：0]VAddrIn_C1；
output [4：0] LSSize_C0；
output [31：0] VAddrBase_C1；
<dp n="d341"/>
output [31：0] VAddrIndex_C1；
output LSIndexed_C0；
input clk；
assign LSSize_C0＝32′h1；
assign VAddrBase_C1＝ars_i_C1；
assign LSIndexed_C0＝1′b1；
assign VAddrIndex_C1＝arti_C1；
assign gr_o_C2＝MemDataIn8_C2；
assign ars_o_C1＝VAddrIn_C1；
wire LGF8_XU_C2；
xtdelay2 #(1) iLGF8_XU_C2(.xtin(LGF8_XU_C0)，.xtout(LGF8_XU_C2)，
.clk(clk))；
assign gr_kill_C2＝(1′b0)&(LGF8_XU_C2)；
wire LGF8_XU_C1；
xtdelay1 #(1) iLGF8_XU_C1(.xtin(LGF8_XU_C0)，.xtout(LGF8_XU_C1)，
.clk(clk))；
assign ars_kill_C1＝(1′b0)&(LGF8_XU_C1)；
endmodule
module xmTIE_SGF8_I(
SGF8_I_C0，
gt_i_C1，
ars_i_C1，
imm8_C0，
LSSize_C0，
MemDataOut8_C1，
VAddrBase_C1，
VAddrOffset_C0，
LSIndexed_C0，
clk
)；
input SGF8_I_C0；
input [7：0] gt_i_C1；
input [31：0] arsi_C1；
input [7：0] imm8_C0；
output [4：0] LSSize_C0；
output [7：0] MemDataOut8_C1；
output [31：0] VAddrBase_C1；
output [31：0] VAddrOffset_C0；
output LSIndexed_C0；
input clk；
assign LSSize_C0＝32′h1；
assign VAddrBase_C1＝ars_i_C1；
assign LSIndexed_C0＝1′b0；
assign VAddrOffset_C0＝imm8_C0；
assign MemDataOut8_C1＝gt_i_C1；
endmodule
module xmTIE_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，
<dp n="d342"/>
LSIndexed_C0，
clk
)；
input SGF8_IU_C0；
input [7：0]gt_i_C1；
input [31：0] ars_i_C1；
output [31：0] ars_o_C1；
output ars_kill_C1；
input [7：0] imm8_C0；
input [31：0] VAddrIn_C1；
output [4：0] LSSize_C0；
output [7：0] MemDataOut8_C1；
output [31：0] VAddrBase_C1；
output [31：0] VAddrOffset_C0；
output LSIndexed_C0；
input clk；
assign LSSize_C0＝32′h1；
assign VAddrBase_C1＝ars_i_C1；
assign LSIndexed_C0＝1′b0；
assign VAddrOffset_C0＝imm8_C0；
assign MemDataOut8_C1＝gt_i_C1；
assign ars_o_C1＝VAddrIn_C1；
wire SGF8_IU_C1；
xtdelay1 #(1) iSGF8_IU_C1(.xtin(SGF8_IU_C0)，.xtout(SGF8_IU_C1)，
.clk(clk))；
assign ars_kill_C1＝(1′b0)&(SGF8_It_C1)；
endmodule
module xmTIE_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
)；
input SGF8_x_C0；
input [7：0] gr_i_C1；
input [31：0] ars_i_C1；
input [31：0] art_i_C1；
output [4：0] LSSize_C0；
output [7：0] MemDataOut8_C1；
output [31：0] VAddrBase_C1；
output [31：0] VAddrIndex_C1；
output LSIndexed_C0；
input clk；
assign LSSize_C0＝32′h1；
assign VAddrBase_C1＝ars_i_C1；
assign LSIndexed_C0＝1′b1；
assign VAddrIndex_C1＝art_i_C1；
assign MemDataOut8_C1＝gr_i_C1；
endmodule
module xmTIE_SGF8_XU(
SGF8_XU_C0，
gr_i_C1，
<dp n="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
)；
input SGF8_XU_C0；
input [7：0] gr_i_C1；
input [31：0] ars_i_C1；
output [31：0] ars_o_C1；
output ars_kill_C1；
input [31：0] art_i_C1；
input [31：0] VAddrIn_C1；
output [4：0] LSSize_C0；
output [7：0] MemDataOut8_C1；
output [31：0] VAddrBase_C1；
output [31：0] VAddrIndex_C1；
output LSIndexed_C0；
input clk；
assign LSSize_C0＝32′h1；
assign VAddrBase_C1＝ars_i_C1；
assign LSIndexed_C0＝1′b1；
assign VAddrIndex_C1＝art_i_C1；
assign MemDataOut8_C1＝gr_i_C1；
assign ars_o_C1＝VAddrIn_C1；
wire SGF8_XU_C1；
xtdelay1 #(1) iSGF8_XU_C1(.xtin(SGF8_XU_C0)，.xtout(SGF8_XU_C1)，
.clk(clk))；
assign ars_kill_C1＝(1′b0)&(SGF8_XU_C1)；
endmodule
module xmTIE_RUR0(
RUR0_C0，
arr_o_C1，
arr_kill_C1，
gfmod_ps_C1，
clk
)；
input RUR0_C0；
output [31：0] arr_o_C1；
output arr_kill_C1；
input [7：0] gfmod_ps_C1；
input clk；
assign arr_o_C1＝{gfmod_ps_C1}；
wire RUR0_C1；
xtdelay1 #(1) iRUR0_C1(.xtin(RUR0_C0)，.xtout(RUR0_C1)，.clk(clk))；
assign arr_kill_C1＝(1′b0)&(RUR0_C1)；
endmodule
module xmTIE_WUR0(
WUR0_C0，
art_i_C1，
gfmod_ns_C1，
gfmod_kill_C1，
<dp n="d344"/>
clk
)；
input WUR0_C0；
input [31：0] art_i_C1；
output [7：0] gfmod_ns_C1；
output gfmod_kill_C1；
input clk；
assign gfmod_ns_C1＝{art_i_C1[7：o]}；
wire WUR0_C1；
xtdelay1 #(1) iWUR0_C1(..xtin(WUR0_C0)，.xtout(WUR0_C1)，.clk(clk))；
assign gfmod_kill_C1＝(1′b0)&(WUR0_C1)；
endmodule
module xmTIE_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，
<dp n="d345"/>
Kill_E，
Except_W，
Replay_W，
G1WCLK，
Reset
)；
output TIE_inst_R；
output TIE_asRead_R；
output TIE_atRead_R；
output TIE_atWrite_R；
output TIE_arWrite_R；
output TIE_asWrite_R；
output TIE_aWriteM_R；
output TIE_aDataKill_E；
output [31：0] TIE_aWriteData_E；
output TIE_aDataKill_M；
output [31：0] TIE_aWriteData_M；
output TIE_Load_R；
output TIE_Store_R；
output [4：0] TIE_LSSize_R；
output TIE_LSIndexed_R；
output [31：0] TIE_LSOffset_R；
input [127：0] TIE_MemLoadData_M；
output [7：0] TIE_MemStoreData8_E；
output [15：0] TIE_MemStoreData16_E；
output [31：0] TIE_MemStoreData32_E；
output [63：0] TIE_MemStoreData64_E；
output [127：0] TIE_MemStoreData128_E；
output TIE_Stall_R；
output TIE_Exception_E；
output [5：0] TIE_ExcCause_E；
output TIE_bsRead_R；
output TIE_btRead_R；
output TIE_btWrite_R；
output TIE_brWrite_R；
output TIE_bsWrite_R；
output [4：0] TIE_bsReadSize_R；
output [4：0] TIE_btReadSize_R；
output [4：0] TIE_bWriteSize_R；
input [15：0] TIE_bsReadData_E；
input [15：0] TIE_btReadData_E；
output TIE_bWriteData1_E；
output [1：0] TIE_bWriteData2_E；
output [3：0] TIE_bWriteData4_E；
output [7：0] TIE_bWriteData8_E；
output [15：0] TIE_bWriteData16_E；
output TIE_bDataKill_E；
input [7：0] CPEnable；
input [23：0] Instr_R；
input [31：0] SBus_E；
input [31：0] TBus_E；
input [31：0] MemOpAddr_E；
input Kill_E；
input Except_W；
input Replay_W；
input GlWCLK；
input Reset；
//unused signals
wire TMode＝0；
<dp n="d346"/>
//control signals
wire KillPipe_W；
wire clk；
//decoded signals
wire GFADD8_C0；
wire GFADD8I_C0；
wire GFMULX8_C0；
wire GFRWMOD8_C0；
wire LGF8I_C0；
wire SGF8I_C0；
wire LGF8_IU_C0；
wire SGF8_IU_C0；
wire LGF8_X_C0；
wire SGF8_X_C0；
wire LGF8_XU_C0；
wire SGF8_XU_C0；
wire RUR0_C0；
wire WUR0_C0；
wire[31：0] imm4_C0；
wire[7：0] imm8_C0；
w1re art_use C0；
wire art_def C0；
wire ars_use_C0；
wire ars_def_C0；
wire arr_use_C0；
wire arr_def_C0；
wire br_use_C0；
wire br_def_C0；
w1re bs_use_C0；
wire bs_def_C0；
w1re bt_use_C0；
wire bt_def_C0；
wire bs4_use_C0；
wire bs4_def_C0；
wire bs8_use_C0；
wire bs8_def_C0；
wire gr_use_C0；
wire gr_def_C0；
wire gs_use_C0；
wire gs_def_C0；
wire gt_use_C0；
wire gt_def_C0；
wIre gfmod_use1_C0；
wire gfmod_def1_C0；
wire AR_rd0_use1_C0；
wire AR_rd0_width32_C0；
wire AR_rd1_use1_C0；
wire AR_rd1_width32_C0；
wire AR_wd_def1_C0；
wire AR_wd_width32_C0；
wire [3：0] gf_rd0_addr_C0；
wire gf_rd0_use1_C0；
wire gf_rd0_width8_C0；
wire [3：0] gf_rd1_addr_C0；
wire gf_rd1_usel_C0；
wire gf_rd1_width8_C0；
wire [3：0] gf_rd2_addr_C0；
wire gf_rd2_use1_C0；
<dp n="d347"/>
wire gf_rd2_width8_C0；
wire [3：0] gf_wd_addr_C0；
wire gf_wd_def2_C0；
wire gf_wd_def1_C0；
wire gf_wd_width8_C0；
wire GFADD8_semantic_C0；
wire GFADD8I_semantic_C0；
wire GFMULX8_semantic_C0；
wire GFRWMOD8_semantic_C0；
wire LGF8_I_semantic_C0；
wire LGF8_IU_semantic_C0；
wire LGF8_X_semantic_C0；
wire LGF8_XU_semantic_C0；
wire SGF8_I_semantic_C0；
wire SGF8_IU_semantic_C0；
wire SGF8_X_semantic_C0；
wire SGF8_XU_semantic_C0；
wire RUR0_semantic_C0；
wire WUR0_semantic_C0；
wire load_instruction_C0；
wire store_instruction_C0；
wire TIE_Inst_C0；
wire [23：0] Inst_C0；
//state data，write_enable and stall signals
wire [7：0] gfmod_ps_C1；
wire [7：0] gfmod_ns_C1；
wire gfmod_kill_C1；
wire gfmod_Stall_C1；
//register data，write_enable and stall signals
wire [31：0] AR_rd0_data_C1；
wire [31：0] AR_rd1_data_C1；
wire [31：0] AR_wd_data32_C1；
wire AR_wd_kill_C1；
wire [7：0] gf_rd0_data C1；
wire [7：0] gf_rd1_data_C1；
wire [7：0] gf_rd2_data_C1；
wire [7：0] gf_wd_data8_C2；
wire gf_wd_kill_C2；
wire [7：0] gf_wd_data8_C1；
wire gf_wd_kill_C1；
wire gf_Stall_C1；
//operands
wire [31：0] art_i_C1；
wire [31：0] art_o_C1；
wire art_kill_C1；
wire [31：0] ars_i_C1；
wire [31：0] ars_o_C1；
wire ars_kill_C1；
wire [31：0] arr_o_C1；
wire arr_kill_C1；
wire [7；0] gr_i_C1；
wire [7；0] gr_o_C2；
wire gr_kill_C2；
wire [7：0] gr_o_C1；
wire gr_kill_C1；
wire [7：0] gs_i_C1；
wire [7：0] gt_i_C1；
<dp n="d348"/>
wire [7：0] gt_o_C2_；
wire gt_kill_C2；
wire [7：0] gt_o C1；
wire gt_kill_C1；
//output state of semantic GFADD8
//output interface of semantic GFADD8
//output operand of semantic GFADD8
wire [7：0] GFADD8_gr_o_C1；
wire GFADD8_gr_kill_C1；
//output state of semantic GFADD8I
//output interface of semantic GFADD8I
//output operand of semantic GFADD8I
wire [7：0] GFADD8I_gr_o_C1；
wire GFADD8I_gr_kill_C1；
//output state of semantic GFMULX8
//output interface of semantic GFMULX8
//output operand of semantic GFMULX8
wire [7：0] GFMUIX8_gr_o_C1；
wire GFMULX8_gr_kill_C1；
//output state of semantic GFRWMOD8
wire [7：0] GFRWMOD8_gfmod_ns_C1；
wire GFRWMOD8_gfmod_kill_C1；
//output interface of semantic GFRWMOD8
//output operand of semantic GFRWMOD8
wire [7：0] GFRWMOD8_gt_o_C1；
wire GFRWMOD8_gt_kill_C1；
//output state of semantic LGF8_I
//output interface of semantic LGF8_I
wire [4：0] LGF8_I_LSSize_C0；
wire [31：0] LGF8_I_VAddrBase_C1；
wire [31：0] LGF8_I_VAddrOffset_C0：
wire LGF8_I_LSIndexed_C0；
//output operand of semantic LGF8_I
wire [7：0] LGF8_I_g_to_C2；
wire LGF8_I_gt_kill_C2；
//output state of semantic LGF8_IU
//output interface of semantic LGF8_IU
wire [4：0] LGF8_IU_LSSize_C0；
wire [31：0] LGF8_IU_VAddrBase_C1；
wire [31：0] LGF8_IU_VAddrOffset_C0；
wire LGF8_IU_LSIndexed_C0；
//output operand of semantic LGF8_IU
<dp n="d349"/>
wire [7：0] LGF8_IU_gt_o_C2；
wire LGF8_IU_gt_kill_C2；
wire [31：0] LGF8_IU_ars_o_C1；
wire LGF8_IU_ars_kill_C1；
//output state of semantic LGF8_X
//output interface of semantic LGF8_X
wire [4：0] LGF8_X_LSSize_C0；
wire [31：0] LGF8_X_VAddrBase_C1；
wire [31：0] LGF8_X_VAddrIndex_C1；
wire LGF8_X_LSIndexed_C0；
//output operand of semantic LGF8_X
wire [7：0] LGF8_X_gr_o_C2；
wire LGF8_X_gr_kill_C2；
//output state of semantic LGF8_XU
//output interface of semantic LGF8_XU
wire [4：0] LGF8_XU_LSSize_C0；
wire [31：0] LGF8_XU_VAddrBase_C1；
wire [31：0] LGF8_XU_VAddrIndex_C1；
wire LGF8_XU_LSIndexed_C0；
//output operand of semantic LGF8_XU
wire [7：0] LGF8_XU_gr_o_C2；
wire LGF8_XU_gr_kill_C2；
wire [31：0] LGF8_XU_ars_o_C1；
wire LGF8_XU_ars_kill_C1；
//output state of semantic SGF8_I
//output interface of semantic SGF8_I
wire [4：0] SGF8_I_LSSize_C0；
wire [7：0] SGF8_I_MemDataOut8_C1；
wire [31：0] SGF8_I_VAddrBase_C1；
wire [31：0] SGF8_I_VAddrOffset_C0；
wire SGF8_I_LSIndexed_C0；
//output operand of semantic SGF8_I
//output state of semantic SGF8_IU
//output interface of semantic SGF8_IU
wire [4：0] SGF8_IU_LSSize_C0；
wire [7：0] SGF8_IU_MemDataOut8_C1；
wire [31：0] SGF8_IU_VAddrBase_C1；
wire [31：0] SGF8_IU_VAddrOffset_C0；
wire SGF8_IU_LSIndexed_C0；
//output operand of semantic SGF8_IU
wire [31：0] SGF8_IU_ars_o_C1；
wire SGF8_IU_ars_kill_C1；
//output state of semantic SGF8_X
//output interface of semantic SGF8_X
wire [4：0] SGF8_X_LSSize_C0；
wire [7：0] SGF8_X_MemDataOut8_C1；
<dp n="d350"/>
wire [31：0] SGF8_X_VAddrBase_C1；
wire [31：0] SGF8_X_VAddrIndex_C1；
wire SGF8_X_LSIndexed_C0；
//output operand of semantic SGF8_X
//output state of semantic SGF8_XU
//output interface of semantic SGF8_XU
wire [4：0] SGF8_XU_LSSize_C0；
wire [7：0] SGF8_XU_MemDataOut8_C1；
wire [31：0] SGF8_XU_VAddrBase_C1；
wire [31：0] SGF8_XU_VAddrIndex_C1；
wire SGF8_XU_LSIndexed_C0；
//output operand of semantic SGF8_XU
wire [31：0] SGF8_XU_ars_o_C1；
wire SGF8_XU_ars_kill_C1；
//output state of semantic RUR0
//output interface of semantic RUR0
//output operand of semantic RUR0
wire [31：0] RUR0_arr_o_C1；
wire RUR0_arr_kill_C1；
//output state of semantic WUR0
wire [7：0] WUR0_gfmod_ns_C1；
wire WUR0_gfmod_kill_C1；
//output interface of semantic WUR0
//output operand of semantic WUR0
//TIE-defined interface signals
wire [31：0] VAddr_C1；
wire [31：0] VAddrBase_C1；
wire [31：0] VAddrOffset_C0；
wire [31：0] VAddrIndex_C1；
wire [31：0] VAddrIn_C1；
wire [4：0] LSSize_C0；
wire LSIndexed_C0；
wire [127：0] MemDataIn128_C2；
wire [63：0] MemDataIn64_C2；
wire [31：0] MemDataIn32_C2；
wire [15：0] MemDataIn16_C2；
wire [7：0] MemDataIn8_C2；
wire [127：0] MemDataOut128_C1；
wire [63：0] MemDataOut64_C1；
wire [31：0] MemDataOut32_C1；
wire [15：0] MemDataOut16_C1；
wire [7：0] MemDataOut8_C1；
wire Exception_C1；
wire [5；0] ExcCause_C1；
wire [7：0] CpEnable_C1；
xtflop #(1) reset(localReset，Reset，GlWCLK)；
xmTIE_decoder TIE_decoder(
.GFADD8(GFADD8_C0)，
<dp n="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(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_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(gf wd_def1_C0)，
.gf_wd_width8(gf_wd_width8_C0)，
.GFADD8_semantic(GFADD8_semantic_C0)，
.GFADD8I_semantic(GFADD8I_semantic_C0)，
<dp n="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_GFADD8 TIE_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_GFADD8I TIE_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_GFMULX8 TIE_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_GFRWMOD8 TIE_GFRWMOD8(
.GFRWMOD8_C0(GFRWMOD8_C0)，
.gt_i_C1(gt_i_C1)，
.gt_o_C1(GFRWMOD8_gt o_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)，
<dp n="d353"/>
.VAddrBase_C1(LGF8_I_VAddrBase_C1)，
.VAddrOffset_C0(LGF8_I_VAddrOffset_C0)，
.LSIndexed_C0(LGF8_I_LSIndexed_C0)，
.clk(clk))；
xmTIE_LGF8_IU TIE_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_X TIE_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)，
<dp n="d354"/>
.LSIndexed_C0(SGF8_I_LSIndexed_C0)，
.clk(clk))；
xmTIE_SGF8_IU TIE_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_X TIE_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_XU TIE_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_RUR0 TIE_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_WUR0 TIE_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_State TIE_gfmod_State(
<dp n="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_Regfile TIE_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)
)；
//Stall logic
assign TIE_Stall_R＝1′b0
|gf_Stall_C1
|gfmod_Stall_C1；
//pipeline semantic select signals to each stage
wire LGF8_I_semantic_C1；
xtdelay1 #(1) iLGF8_I_semantic_C1(.xtin(LGF8_I_semantic_C0)，
.xtout(LGF8_I_semantic_C1)，.clk(clk))；
wire LGF8_IU_semantic_C1；
xtdelay1 #(1) iLGF8_IU_semantic_C1(.xtin(LGF8_IU_semantic_C0)，
.xtout(LGF8_IU_semantic_C1)，.clk(clk))；
wire LGF8_X_semantic_C1；
xtdelay1 #(1) iLGF8_X_semantic_C1(.xtin(LGF8_X_semantic_C0)，
.xtout(LGF8_X_semantic_C1)，.clk(clk))；
wire LGF8_XU_semantic_C1；
xtdelay1 #(1) iLGF8_XU_semantic_C1(.xtin(LGF8_XU_semantic_C0)，
.xtout(LGF8_XU_semantic_C1)，.clk(clk))；
wire SGF8_I_semantic_C1；
<dp n="d356"/>
xtdelay1 #(1) iSGF8_I_semantic_C1(.xtin(SGF8_I_semantic_C0)，
.xtout(SGF8_I_semantic_C1)，.clk(clk))；
wire SGF8_IU_semantic_C1；
xtdelay1 #(1) iSGF8_IU_semantic_C1(.xtin(SGF8_IU_semantic_C0)，
.xtout(SGF8_IU_semantic_C1)，.clk(clk))；
wire SGF8_X_semantic_C1；
xtdelay1 #(1) iSGF8_X_semantic_C1(.xtin(SGF8_X_semantic_C0)，
.xtout(SGF8_X_semantic_C1)，.clk(clk))；
wire SGF8_XU_semantic_C1；
xtdelay1 #(1) iSGF8_XU_semantic_C1(.xtin(SGF8_XU_semantic_C0)，
.xtout(SGF8_XU_semantic_C1)，.clk(clk))；
wire GFRWMOD8_semantic_C1；
xtdelay1 #(1) iGFRWMOD8_semantic_C1(.xtin(GFRWMOD8_semantic_C0)，
.xtout(GFRWMOD8_semantic_C1)，.clk(clk))；
wire WUR0_semantic_C1；
xtdelay1 #(1) iWUR0_semantic_C1(.xtin(WUR0_semantic_C0)，
.xtout(WUR0_semantic_C1)，.clk(clk))；
wire RUR0_semantic_C1；
xtdelay1 #(1) iRUR0_semantic_C1(.xtin(RUR0_semantic_C0)，
.xtout(RUR0_semantic_C1)，.clk(clk))；
wire LGF8_X_semantic_C2；
xtdelay2 #(1) iLGF8_X_semantic_C2(.xtin(LGF8_X_semantic_C0)，
.xtout(LGF8_X_semantic_C2)，.clk(clk))；
wire LGF8_XU_semantic_C2 ；
xtdelay2 #(1) iLGF8_XU_semantic_C2(.xtin(LGF8_XU_semantic_C0)，
.xtout(LGF8_XU_semantic_C2)，.clk(clk))；
wire GFADD8_semantic_C1；
xtdelay1 #(1) iGFADD8_semantic_C1(.xtin(GFADD8_semantic_C0)，
.xtout(GFADD8_semantic_C1)，.clk(clk))；
wire GFADD8I_semantic_C1；
xtdelay1 #(1) iGFADD8I_semantic_C1(.xtin(GFADD8I_semantic_C0)，
.xtout(GFADD8I_semantic_C1)，.clk(clk))；
wire GFMULX8_semantic_C1；
xtdelay1 #(1) iGFMULX8_semantic_C1(.xtin(GFMULX8_semantic_C0)，
.xtout(GFMULX8_semantic_C1)，.clk(clk))；
wire LGF8_I_semantic_C2；
xtdelay2 #(1) iLGF8_I_semantic_C2(.xtin(LGF8_I_semantic_C0)，
.xtout(LGF8_I_semantic_C2)，.clk(clk))；
wire LGF8_IU_semantic_C2；
xtdelay2 #(1) iLGF8_IU_semantic_C2(.xtin(LGF8_IU_semantic_C0)，
.xtout(LGF8_IU_semantic_C2)，.clk(clk))；
//combine output interface signals from all semantics
assign VAddr_C1＝32′b0；
assign VAddrBase_C1＝32′b0
|(LGF8_I_VAddrBase_C1&{32{LGF8_I_semantic_C1}})
|(LGF8_IU_VAddrBase_C1&{32{LGF8_IU_semantic_C1}})
|(LGF8_X_VAddrBase_C1&{32{LGF8_X_semantic_C1}})
|(LGF8_XU_VAddrBase_C1&{32 {LGF8_XU_semantic_C1}})
|(SGF8_I_VAddrBase_C1&{32{SGF8_I_semantic_C1}})
|(SGF8_IU_VAddrBase_C1&{32{SGF8_IU_semantic_C1}})
|(SGF8_X_VAddrBase_C1&{32{SGF8_X_semantic_C1}})
|(SGF8_XU_VAddrBase_C1&{ 32{SGF8_XU_semantic_C1}})；
assign VAddrOffset_C0＝32′b0
|(LGF8_I_VAddrOffset_C0&{32{LGF8_I_semantic_C0}})
|(LGF8_IU_VAddrOffset_C0&{32{LGF8_IU_semantic_C0}})
|(SGF8_I_VAddrOffset_C0&{32{SGF8_I_semantic_C0}})
|(SGF8_IU_VAddrOffset_C0&{32{SGF8_IU_semantic_C0}})；
assign VAddrIndex_C1＝32′b0
|(LGF8_X_VAddrIndex_C1&{32{LGF8_X_semantic_C1}})
<dp n="d357"/>
|(LGF8_XU_VAddrIndex_C1&{32{LGF8_XU_semantic_C1}})
|(SGF8_X_VAddrIndex_C1&{32{SGF8_X_semantic_C1}})
|(SGF8_XU_VAddrIndex_C1&{32{SGF8_XU_semantic_C1}})；
assign LSSize_C0＝5′b0
|(LGF8_I_LSSize_C0&{5{LGF8_I_semantic_C0}})
|(LGF8_IU_LSSize_C0&{5{LGF8_IU_semantic_C0}})
|(LGF8_X_LSSize_C0&{5{LGF8_X_semantic_C0}})
|(LGF8_XU_LSSize_C0&{5{LGF8_XU_semantic_C0}})
|(SGF8_I_LSSize_C0&{5{SGF8_I_semantic_C0}})
|(SGF8_IU_LSSize_C0&{5{SGF8_IU_semantic_C0}})
|(SGF8_X_LSSize_C0&{5{SGF8_X_semantic_C0}})
|(SGF8_XU_LSSize_C0&{5{SGF8_XU_semantic_C0}})；
assign LSIndexed_C0＝1′b0
|(LGF8_ILSIndexed_C0&LGF8_I_semantic_C0)
|(LGE8_IU_LSIndexed_C0&LGF8_IU_semantic_C0)
|(LGF8_X_LSIndexed_C0&LGF8_X_semantic_C0)
|(LGF8_XU_LSIndexed_C0&LGF8_XU_semantic_C0)
|(SGF8_I_LSIndexed_C0&SGF8_I_semantic_C0)
|(SGF8_IU_LSIndexed_C0&SGF8_IU_semantic_C0)
|(SGF8_X_LSIndexed_C0&SGF8_X_semantic_C0)
|(SGF8_XU_LSIndexed_C0&SGF8_XU_semantic_C0)；
assign MemDataOut128_C1＝128′b0；
assign MemDataOut64_C1＝64′b0；
assign MemDataOut32_C1＝32′b0；
assign MemDataOut16_C1＝16′b0；
assign MemDataOut8_C1＝8′b0
|(SGF8_I_MemDataOut8_C1&{8{SGF8_I_semantic_C1}})
|(SGF8_IU_MemDataOut8_C1&{8{SGF8_IU_semantic_C1}})
|(SGF8_X_MemDataOut8_C1&{8{SGF8_X_semantic_C1}})
|(SGF8_XU_MemDataOut8_C1&{8{SGF8_XU_semantic_C1}})；
assign Exception_C1＝1′b0；
assign ExcCause_C1＝6′b0；
//combine output state signals from a11 semantics
assign gfmod_ns_C1＝8′b0
|(GFRWMOD8_gfmod_ns_C1&{8{GFRWMOD8_semantic_C1}})
|(WUR0_gfmod_ns_C1&{8{WUR0_semantic_C1}})；
assign gfmod_kill_C1＝1′b0
|(GFRWMOD8_gfmod_kill_C1&GFRWMOD8_semantic_C1)
|(WUR0_gfmod_kill_C1&WUR0_semantic_C1)；
//combine output operand signals from all semantics
assign art_o_C1＝32′b0；
assign art_kill_C1＝1′b0；
assign ars_o_C1＝32′b0
|(LGF8_IU_ars_o_C1&{32{LGF8_IU_semantic_C1}})
|(LGF8_XU_ars_o_C1&{32{LGF8_XU_semantic_C1}})
|(SGF8_IU_ars_o_C1&{32{SGF8_IU_semantic_C1}})
|(SGF8_XU_ars_o_C1&{32{SGF8_XU_semantic_C1}})；
assign ars_kill_C1＝1′b0
|(LGF8_IU_ars_ki1l_C1&LGF8_IU_semantic_C1)
|(LGF8_XU_ars_kill_C1&LGF8_XU_semantic_C1)
|(SGF8_IU_ars_kill_C1&SGF8_IU_semantic_C1)
|(SGF8_XU_ars_kill_C1&SGF8_XU_semantic_C1)；
assign arr_o_C1＝32′b0
|(RUR0_arr_o_C1&{32{RUR0_semantic_C1}})；
assign arr_kill_C1＝1′b0
|(RUR0_arr_kill_C1&RUR0_semantic_C1)；
assign gr_o_C2＝8′b0
|(LGF8_X_gr_o_C2&{8{LGF8_X_semantic_C2}})
<dp n="d358"/>
|(LGF8_XU_gr_o_C2 & {8{LGF8_XU_semantic_C2}})；
assign gr_kill_C2＝1′b0
|(LGF8_X_gr_ki11_C2 & LGF8_X_semantic_C2)
|(LGF8_XU_gr_kill_C2 & LGF8_XU_semantic_C2)；
assign gr_o_C1＝8′b0
|(GFADD8_gr_o_C1 & {8{GFADD8_semantic_C1}})
|(GFADD8I_gr_o_C1 & {8{GFADD8I_semantic_C1}})
|(GFMULX8_gr_o_C1 & {8{GFMULX8_semantic_C1}})；
assign gr_kill_C1＝1′b0
|(GFADD8_gr_kill_C1 & GFADD8_semantic_C1)
|(GFADD8I_gr_kill_C1 & GFADD8I_semantic_C1)
|(GFMULX8_gr_kill_C1 & GFMULX8_semantic_C1)；
assign gt_o_C2＝8′b0
|(LGF8_I_gt_o_C2 & {8{LGF8_I_semantic_C2}})
|(LGF8_IU_gt_o_C2 & {8{LGF8_IU_semantic_C2}})；
assign gt_kill_C2＝1′b0
|(LGF8_I_gt_kill_C2 & LGF8_I_semantic_C2)
|(LGF8_IU_gt_kill_C2 & LGF8_IU_semantic_C2)；
assign gt_o_C1＝8′b0
|(GFRWMOD8_gt_o_C1 & {8{GFRWMOD8_semantiC_C1}})；
assign gt_kill_C1＝1′b0
|(GFRWMOD8_gt_kill_C1 & GFRWMOD8_semantic_C1)；
//output operand to write port mapping logic
assign AR_wd_data32_C1＝ars_o_C1|arr_o_C1|32′b0；
assign AR_wd_kill_C1＝ars_kill_C1|arr_kill_C1|1′b0；
assign gf_wd_data8_C2＝gt_o_C2|gr_o_C2|8′b0；
assign gf_wd_kill_C2＝gt_kill_C2|gr_kill_C2|1′b0；
assign gf_wd_data8_C1＝gr_o_C1|gt_o_C1|8′b0；
assign gf_wd_ki1l_C1＝gr_kill_C1|gt_kill_C1|1′b0；
//read port to input operand mapping 1ogic
assign ars_i_C1＝AR_rd0_data_C1；
assign art_i_C1＝AR_rd1_data_C1；
assign gs_i_C1＝gf_rd0_data_C1；
assign gt_i_C1＝gf_rd1_data_C1；
assign gr_i_C1＝gf_rd2_data_C1；
//logic to support verification
wire ignore_TIE_aWriteData_E＝-(AR_wd_def1_C0 & (TIE_arWrite_R|
TIE_asWrite_R|TIE_atWrite_R) &-TIE_aDataKill_E)；
wire ignore_TIE_aWriteData_M＝-(1′b0 & (TIE_arWrite_R|TIE_asWrite_R|
TIE_atWrite_R) &-TIE_aDataKill_M)；
wire ignore_TIE_bWriteData_E＝(-TIE_btWrite_R &-TIE_btWrite_R)|
TIE_bDataKill_E；
wire ignore_TIE_bWriteData16_E＝ignore_TIE_bWriteData_E；
wire ignore_TIE_bWriteData8_E＝ignore_TIE_bWriteData_E；
wire ignore_TIE_bWriteData4_E＝ignore_TIE_bWriteData_E；
wire ignore_TIE_bWriteData2_E＝ignore_TIE_bWriteData_E；
wire ignore_TIE_bWriteData1_E＝ignore_TIE_bWriteData_E；
wire ignore_TIE_LSSize_R＝-TIE_Load_R &-TIE_Store_R；
wire ignore_TIE_LSIndexed_R＝-TIE_Load_R &-TIE_Store_R；
wire ignore_TIE_LSOffset_R＝-TIE_Load_R &-TIE_Store_R|TIE_LSIndexed_R；
wire ignore_TIE_MemStoreData128_E＝(TIE_LSSize_R！＝5′b10000)|
_TIE_Store_R；
wire ignore_TIE_MemStoreData64_E＝(TIE_LSSize_R！＝5′b01000)|
_TIE_Store_R；
wire ignore_TIE_MemStoreData32_E＝(TIE_LSSize_R！＝5′b00100)|
_TIE_Store_R；
<dp n="d359"/>
wire ignore_TIE_MemStoreData16_E＝(TIE_LSSize_R！＝5′b00010)|
-TIE_Store_R；
wire ignore_TIE_MemStoreData8_E＝(TIE_LSSize_R！＝5′b00001)|
-TIE_Store_R；
//clock and instructions
assign clk＝G1WCLK；
assign Inst_C0＝Instr_R；
assign TIE_inst_R＝TIE_Inst_C0；
//AR-related signals to/from core
assign TIE_asRead_R＝ars_use_C0；
assign TIE_atRead_R＝art_use_C0；
assign TIE_atWrite_R＝art_def_C0；
assign TIE_arWrite_R＝arr_def_C0；
assign TIE_asWrite_R＝ars_def_C0；
assign TIE_aWriteM_R＝0；
assign TIE_aWriteData_E＝ignore_TIE_aWriteData_E？0：AR_wd_data32_C1；
assign TIE_aWriteData_M＝ignore_TIE_aWriteData_M？0：0；
assign TIE_aDataKill_E＝AR_wd_kill_C1；
assign TIE_aDataKill_M＝0；
assign AR_rd0_data_C1＝SBus_E；
assign AR_rdl_data_C1＝TBus_E；
//BR-related signals to/from core
assign TIE_bsRead_R＝1′b0|bs_use_C0|bs4_use_C0|bs8_use_C0；
assign TIE_btRead_R＝1′b0|bt_use_C0；
assign TIE_btWrite_R＝1′b0|bt_def_C0；
assign TIE_bsWrite_R＝1′b0|bs_def_C0|bs4_def_C0|bs8_def_C0；
assign TIE_brWrite_R＝1′b0|br_def_C0；
assign TIE_bWriteData16_E＝ignore_TIE_bWriteData16_E？0：0；
assign TIE_bWriteData8_E＝ignore TIE bWriteData8_E？0：0；
assign TIE_bWriteData4_E＝ignore TIE bWriteData4_E？0：0；
assign TIE_bWriteData2_E＝ignore_TIE_bWriteData2_E？0：0；
assign TIE_bWriteData1_E＝ignore_TIE_bWriteData1 E？0：0；
assign TIE_bDataKill_E＝0；
assign TIE_bWriteSize_R＝{1′b0，1′b0，1′b0，1′b0，1′b0}；
assign TIE_bsReadSize_R＝{1′b0，1′b0，1′b0，1′b0，1′b0}；
assign TIE_btReadSize_R＝{1′b0，1′b0，1′b0，1′b0，1′b0}；
//Load/store signals to/from core
assign TIE_Load_R＝load_instruction_C0；
assign TIE_Store_R＝store_instruction_C0；
assign TIE_LSSize_R＝ignore_TIE_LSSize_R？0：LSSize_C0；
assign TIE_LSIndexed_R＝ignore_TIE_LSIndexed_R？0：LSIndexed_C0；
assign TIE_LSOffset_R＝ignore_TIE_LSOffset_R？0：VAddrOffset_C0；
assign TIE_MemStoreData128_E＝ignore_TIE_MemStoreData128_E？0：
MemDataOut128_C1；
assign TIE_MemStoreData64_E＝ignore_TIE_MemStoreData64_E？0：
MemDataOut64_C1；
assign TIE_MemStoreData32_E＝ignore_TIE_MemStoreData32_E？0：
MemDataOut32_C1；
assign TIE_MemStoreDatal6_E＝ignore_TIE_MemStoreData16_E？0：
MemDataOutl6_C1；
assign TIE_MemStoreData8_E＝ignore_TIE_MemStoreData8_E？0：
MemDataOut8_C1；
assign MemDataInl28_C2＝TIE_MemLoadData_M；
assign MemDataIn64_C2＝TIE_MemLoadData_M；
assign MemDataIn32_C2＝TIE_MemLoadData_M；
assign MemDataIn16_C2＝TIE_MemLoadData_M；
<dp n="d360"/>
assign MemDataIn8_C2＝TIE_MemLoadData_M；
assign VAddrIn_C1＝MemOpAddr_E；
//CpEnable and control signals to/from core
assign CPEnable_C1＝CPEnable；
assign TIE_Exception_E＝Exceptio_C1；
assign TIE_ExcCause_E＝ExcCause_C1；
assign KillPipe_W＝Except_W|Replay_W；
endmodule
module xtdelay1(xtout，xtin，clk)；
parameter size＝1；
output [size-1：0] xtout；
input [size-1：0] xtin；
input clk；
assign xtout＝xtin；
endmodule
module xtdelay2(xtout，xtin，clk)；
parameter size＝1；
output [size-1：0] xtout；
input [size-1：0] xtin；
input clk；
assign xtout＝xtin；
endmodule
module xtRFenlatch(xtRFenlatchout，xtin，xten，clk)；
parameter size＝32；
output [size-1：0] xtRFenlatchout；
input [size-1：0] xtin；
input xten；
input clk；
reg[size-1：0] xtRFenlatchout；
always@(clk or xten or xtin or xtRFenlatchout)begin
if(clk)begin
xtRFenlatchout＜＝#1(xten)？xtin：xtRFenlatchout；
end
end
endmodule
module xtRFlatch(xtRFlatchout，xtin，clk)；
parameter size＝32；
output [size-1：0] xtRFlatchout；
input [size-1：0] xtin；
input clk；
reg [size-1：0] xtRFlatchout；
always @(clk or xtin) begin
if(clk)begin
xtRFlatchout＜＝#1 xtin；
end
end
endmodule
module xtadd(xtout，a，b)；
parameter size＝32；
output[size-1：0]xtout；
<dp n="d361"/>
input [size-1：0] a；
input [size-1：0] b；
assign xtout＝a+b；
endmodule
module xtaddc(sum，carry，a，b，c)；
parameter size＝32；
output [size-1：0] sum；
output carry；
input [size-1：0] a；
input [size-1：0] b；
input c；
wire junk；
assign{carry，sum，junk}＝{a，c}+{b，c}；
endmodule
module xtaddcin(xtout，a，b，c)；
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] a；
input [size-1：0] b；
input c；
assign xtout＝({a，c}+{b，c})＞＞1；
endmodule
module xtaddcout(sum，carry，a，b)；
parameter size＝1；
output [size-1：0] sum；
output carry；
input [size-1：0] a；
input [size-1：0] b；
assign{carry，sum}＝a+b；
endmodule
module xtbooth(out，cin，a，b，sign，negate)；
parameter size＝16；
output[size+1：0]out；
output cin；
input [size-1：0]a；
input [2：0]b；
input sign，negate；
wire ase＝sign & a[size-1]；
wire [size+1：0]ax1＝{ase，ase，a}；
wire [size+1：0]ax2＝{ase，a，1′d0}；
wire one＝b[1]＾b[0]；
wire two＝b [2]？-b[1] & -b[0]：b[1] & b[0]；
wire cin＝negate？(-b[2] & (b[1]|b[0]))：(b[2] &-(b[1] &b[0]))；
assign out＝{size+2{cin}}^(axl&{size+2{one}}|ax2&{size+2{two}})；
endmodule
module xtclock_gate_nor(xtout，xtin1，xtin2)；
output xtout；
input xtin1，xtin2；
<dp n="d362"/>
assign xtout＝-(xtin1||xtin2)；
endmodule
module xtclock_gate_or(xtout，xtin1，xtin2)；
output xtout；
input xtin1，xtin2；
assign xtout＝(xtin1||xtin2)；
endmodule
module xtcsa(sum，carry，a，b，c)；
parameter size＝1；
output [size-1：0] sum；
output [size-1：0] carry；
input [size-1：0] a；
input [size-1：0] b；
input [size-1：0] c；
assign sum＝a^b^c；
assign carry＝(a & b)|(b & c)|(c & a)；
endmodule
module xtenflop(xtout，xtin，en，clk)；
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] xtin；
input en；
input clk；
reg [size-1：0] tmp；
assign xtout＝tmp；
always @ (posedge clk) begin
if (en)
tmp＜＝#1 xtin；
end
endmodule
module xtfa(sum，carry，a，b，c)；
output sum，carry；
input a，b，c；
assign sum＝a^b^c；
assign carry＝a & b|a & c|b & c；
endmodule
module xtflop(xtout，xtin，clk)；
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] xtin；
input clk；
reg [size-1：0] tmp；
assign xtout＝tmp；
always @ (posedge clk)begin
tmp＜＝#1 xtin；
end
endmodule
<dp n="d363"/>
module xtha(sum，carry，a，b)；
output sum，carry；
input a，b；
assign sum＝a＾b；
assign carry＝a & b；
endmodule
module xtinc(xtout，a)；
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] a；
assign xtout＝a+1；
endmodule
module xtmux2e(xtout，a，b，sel)；
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] a；
input [size-1：0] b；
input sel；
assign xtout＝(-sel)？a：b；
endmodule
module xtmux3e(xtout，a，b，c，sel)；
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] a；
input [size-1：0] b；
input [size-1：0] c；
input [1：0] sel；
reg [size-1：0] xtout；
always @ (a or b or cor sel) begin
xtout＝sel[1]？c：(sel[0]？b：a)；
end
endmodule
module xtmux4e(xtout，a，b，c，d，sel)；
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] a；
input [size-1：0] b；
input [size-1：0] c；
input [size-1：0] d；
input [1：0] sel；
reg [size-1：0] xtout；
//synopsys infer_mux″xtmux4e″
always@(sel or a or b or c or d)begin：xtmux4e
case(sel) //synopsys parallel_case full_case
2′b00：
xtout＝a；
2′b01：
xtout＝b；
2′b10；
<dp n="d364"/>
xtout＝c；
2′b11：
xtout＝d；
default：
xtout＝{size{1′bx}}；
endcase//case(sel)
end//always @ (sel or a or b or c or d)
endmodule
module xtnflop(xtout，xtin，clk)；
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] xtin；
irput clk；
reg[size-1：0] tmp；
assign xtout＝tmp；
always @ (negedge clk) begin
tmp＜＝#1 xtin；
end//always @ (negedge clk)
endmodule
module xtscflop(xtout，xtin，clrb，clk)；//sync clear ff
parameter size＝32；
output [size-1：0] xtout；
input [size-1：0] xtin；
input clrb；
input clk；
reg[size-1：0] tmp；
assign xtout＝tmp；
always @(posedge clk)begin
if(！clrb) tmp＜＝0；
else tmp＜＝#1 xtin；
end
endmodule
module xtscenflop(xtout，xtin，en，clrb，clk)；//sync clear
parameter size＝32；
output[size-1：0] xtout；
input[size-1：0] xtin；
input en；
input clrb；
input clk；
reg[size-1：0] tmp；
assign xtout＝tmp；
always @(posedge clk) begin
if(！clrb)tmp＜＝0；
else if(en)
tmp＜＝#1 xtin；
end
endmodule
xtensa-gf.h
<dp n="d365"/>
#ifndef XTENSA_NO_INTRINSICS
#ifdef_XTENSA_
/*Do not modify.This is automatically generated.*/
typedef int gf8_attribute_((user(″gf8″)))；
#define GFADD8_ASM(gr，gs，gt){\
_asm_(″gfadd8 ％0，％1，％2″：″＝v″(gr)：″v″(gs)，″v″(gt))；\
}
#define GFADD8(gs，gt)({\
gf8_gr；\
gf8_gs＝gs；\
gf8_gt＝gt；\
GFADD8_ASM(_gr，_gs，_gt)；\
_gr；\
})
#define GFADD8I_ASM(gr，gs，imm4){\
_asm_(″gfadd8i ％0，％1，％2″：″＝v″(gr)：″v″(gs)，″i″(imm4))；\
}
#define GFADD8I(gs，imm4)({\
gf8 _gr；\
gf8 _gs＝gs；\
GFADD8I_ASM(_gr，_gs，imm4)；\
_gr；\
})
#define GFMULX8_ASM(gr，gs){\
register int_xt_state asm(″state″)；\
_asm_(″gfmulx8 ％1，％2″：″+t″(_xt_state)，″＝v″(gr)：″v″(gs))；
\
}
#define GFMUIX8(gs)({\
gf8_gr；\
gf8_gs＝gs；\
GFMULX8_ASM(_gr，_gs)；\
_gr；\
})
#define GFRWMOD8_ASM(gt){\
register int_xt_state asm(″state″)；\
_asm_(″gfrwmod8 ％1″：″+t″(_xt_state)，″＝v″(gt)：″1″(gt))；\
}
#define GFRWMOD8(gt)({\
gf8_gt＝gt；\
GFRWMOD8_ASM(_gt)；\
gt＝_gt；\
})
#define LGF8_I_ASM(gt，ars，imm8){\
_asm_volatile(″lgf8_i ％0，％1，％2″：″＝v″(gt)：″a″(ars)，″i″
(imm8))；\
}
#define LGF8_I(ars，imm8)({\
gf8_gt；\
<dp n="d366"/>
const unsigned_ars＝ars；\
LGF8_I_ASM(_gt，_ars，imm8)；\
_gt；\
})
#define SGF8_I_ASM(gt，ars，imm8){\
_asm_volatile(″sgf8_i ％0，％1，％2″：：″v″(gt)，″a″(ars)，″i″
(imm8))；\
}
#define SGF8_I(gt，ars，imm8)({\
gf8_gt＝gt；\
unsigned_ars＝ars；\
SGF8_I_ASM(_gt，_ars，imm8)；\
})
#define LGF8_IU_ASM(gt，ars，imm8){\
_asm_volatile(″lgf8_iu ％0，％1，％3″：″＝v″(gt)，″＝a″(ars)：″1″
(ars)，″i″(imm8))；\
}
#define LGF8_IU(ars，imm8)({\
gf8_gt；\
unsigned_ars＝ars；\
LGF8_IU_ASM(_gt，_ars，imm8)；\
ars＝_ars；\
_gt；\
})
#define SGF8_IU_ASM(gt，ars，imm8){\
_asm_volatile(″sgf8_iu ％1，％0，％3″：″＝a″(ars)：″v″(gt)，″0″(ars)，
″i″(imm8))；\
}
#define SGF8_IU(gt，ars，imm8)({\
gf8_gt＝gt；\
unsigned_ars＝ars；\
SGF8_IU_ASM(_gt，_ars，imm8)；\
ars＝_ars；\
})
#define LGF8_X_ASM(gr，ars，art){\
_asm_volatile(″lgf8_x ％0，％1，％2″：″＝v″(gr)：″a″(ars)，″a″
(art))；\
}
#define LGF8_X(ars，art)({\
gf8_gr；\
const unsigned_ars＝ars；\
unsigned_art＝art；\
LGF8_X_ASM(_gr，_ars，_art)；\
_gr；\
})
#define SGF8_X_ASM(gr，ars，art){\
_asm_volatile(″sgf8_x ％0，％1，％2″：：″v″(gr)，″a″(ars)，″a″
(art))；\
}
#define SGF8_X(gr，ars，art)({\
<dp n="d367"/>
gf8_gr＝gr；\
unsigned_ars＝ars；\
unsigned_art＝art；\
SGF8_X_ASM(_gr，_ars，_art)；\
})
#define LGF8_XU_ASM(gr，ars，art){\
_asm_volatile(″lgf8_xu ％0，％1，％3″：″＝v″(gr)，″＝a″(ars)：″1″
(ars)，″a″(art))；\
}
#define LGF8_XU(ars，art)({\
gf8_gr；\
unsigned_ars＝ars；\
unsigned_art＝art ；\
LGF8_XU_ASM(_gr，_ars，_art)；\
ars＝_ars；\
_gr；\
})
#define SGF8_XU_ASM(gr，ars，art){\
_asm_volatile(″sgf8_xu ％1，％0，％3″：″＝a″(ars)：″v″(gr)，″0″(ars)，
″a″(art))；\
}#define SGF8_XU(gr，ars，art)({\
gf8_gr＝gr；\
unsigned_ars＝ars ；\
unsigned_art＝art；\
SGF8_XU_ASM(_gr，_ars，_art)；\
ars＝_ars ；\
})
#define RUR0_ASM(arr){\
register int_xt_state asm(″state″)；\
_asm_(″rur0 ％1″：″+t″(_xt_state)，″＝a″(arr)：)；\
}
#define RUR0()({\
unsigned_arr；\
RUR0_ASM(_arr)；\
_arr；\
})
#define WUR0_ASM(art){\
register int_xt_state asm(″state″)；\
_asm_(″wur0 ％1″：″+t″(_xt_state)：″a″(art))；\
}
#define WUR0(art)({\
unsigned_art＝art；\
WUR0_ASM(_art)；\
})
#define gf8_loadi(_s，o)({\
gf8 t；\
gf8*s＝_s；\
LGF8_I_ASM(t，s，o)；\
t；\
})
<dp n="d368"/>
#define gf8_storei(_t，_s，o)({\
gf8 t＝_t；\
gf8*s＝_s；\
SGF8_I_ASM(t，s，o)；\
})
#define gf8_move(_r，_s)({\
gf8 r＝_r；\
gf8 s＝_s；\
GFADD8_ASM(r，s，0)；\
})
#define RUR(n)({\
int v；\
register int_xt_state asm(″state″)；\
_asm_(″rur ％1，％2″：″+t″(_xt_state)，″＝a″(v)：″i″(n))；\
v；\
})
#define WUR(v，n)({\
register int_xt_state asm(″state″)；\
_asm_(″wur ％1，％2″：″+t″(_xt_state)：″a″(v)，″i″(n))；\
})
#endif
#endif
附录B
#！/usr/xtensa/tools/bin/perl-w
use Getopt：：Long；
use strict；
$main：：inline_mux_count＝0；
sub inline_mux{
my($data，$se1，$width，$out，$style，$code)＝@_；
my($i，$n，$n1，$module，$inst，$d，$fail，@data，@data_uniq)；
$n＝@$data；
if($style eq″encoded″){
$module＝″xtmux${n}e″；
$fail＝0；
}elsif($style eq″priority″){
$fail＝scalar(@$data)！＝scalar(@$sel)+1；
$module＝″xtmux${n}p″；
}elsif($style eq″selector″){
$fail＝scalar(@$data)！＝scalar(@$sel)；
$module＝″xtmux${n}″；
}else{
die″inline_mux：bad style $style″；
}
if($fail){
die″inline_mux：data/selection mismatch for $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($style eq″priority″&&($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{
# drop an instance of the mux
$inst＝$main：：inline_mux_count++；
print″ $module #($width) m$inst($out″；
print map(″，$_″，@$data)；
if($style eq″priority″||$style eq″selector″){
print map(″，$_″，@$sel)；
print″)；\n″；
}else{
print″，$sel)；\n″；
}
<dp n="d371"/>
}
}
}
#min of a list
sub min{
my($min，$v)；
$min＝$_[0]；
foreach $v(@_){
$min＝$v＜$min？$v：$min；
}
return $min；
}
# max of a list
sub max{
my($max，$v)；
$max＝$_[0]；
foreach $v(@_){
$max＝$v＞$max？$v：$max；
}
return $max；
}
# ceil(log2(x))
sub ceil_log2{
my($x)＝@_；
my($n)；
for($n＝0，$x-＝1；$x＞0 ；$x＞＞＝1，$n++){
}
return $n；
}
#2＾x
sub pow2{
my($x)＝@_；
return 1＜＜$x；
}
# uniqify an array
sub uniq{
my(％seen)；
return grep(！$seen{$_}++，@_)；
}
# difference between two arrays
sub diff{
my($aref，$bref)＝@_；
my(％hash)；
grep($hash{$_}＝1，@$bref)；
return grep(！defined $hash{$_}，@$aref)；
}
<dp n="d372"/>
sub wfield{
my($name，$port，$stage)＝@_；
$name＝″$port-＞{NAME}_$name″；
return $stage＞＝0？″${name}_C$stage″：$name；
}
gub rfield{
my($name，$port，$stage)＝@_；
$name＝″$port-＞{NAME}_$name″；
return $stage＞＝0？″${name}_C$stage″：$name；
}
sub write_def{
my($write_port，$stage)＝@_；
return grep($_＝＝$stage，@{$write_port-＞{DEF}})；
}
sub read_$use{
my($read_port，$stage)＝@_；
return grep($_＝＝$stage，@{$read_port-＞{USE}})；
}
sub init_print_break{
my($indent)＝@_；
$main：：col＝0；
$main：：indent＝$indent；
}
sub print_break{
my($d)＝@_；
if($main：：col+length($d)+1＞＝85){
$main：：col＝4；
print(″\n″.(′′x$main：：indent))；
}
print″$d″；
$main：：col+＝length($d)+1；
}
<dp n="d373"/>
sub doc{
my($a)＝＜＜′END_OF_DOCUMENTATION′；
The pipelined register file instantiates a number of pipelined
register file
banks，each of which contains a register file core.
The core is a simple multiple-read port multiple-write port register
file.The
address size is $rf-＞{ADDR_SIZE}(lg2 $rf-＞{MIN_HEIHGT})and its
declaration is
. $rf-＞{ADDR_DECL}.The data size is $rf-＞{DECL_SIZE}($rf-
＞{MIN_WIDTH})and its
declaration is $rf-＞{DECL_DECL}.
Multiple banks are used to support multiple widths for read and write
ports.
We build NUM_BANK($rf-＞MAX_WIDTH/$rf-＞MIN_WIDTH)pipelined
register banks，
each of which has MIN_HEIGHT words and MIN_WIDTH bits in each word.
Each width
must be a power of 2 multiple of the minimum width；in particular，
NUM_BANK
must also be a power of 2.
A final read alignment mux looks at the low-order address bits and
the
read-width mask to mux the correct data onto the output.This splits
the
address into HI_ADDR_SIZE and LO_ADDR_SIZE fields.The high order
bits go
directly to the register file core；the low address bits are fed to
the
alignment mux.The read output is always MAX_WIDTH in size and
smaller data
values are shifted to the LSB of the output word.
As a concrete example，consider a register file of size 1024 bits
(32x32)with
read widths of 32 and 128.
NUM_BANK＝4
MIN_HEIGHT＝32
MIN_WIDTH＝32
MAX_HEIGHT＝8
MAX_WIDTH＝128
ADDR_SIZE＝5
ADDR_DECL＝[4：0]
WORD_SIZE＝32
WORD_DECL＝[31：0]
HI_ADDR_SIZE＝3
LO_ADDR_SIZE＝2
The read mask is：
11 to read width 32
10 to read width 64(not used in this case)
00 to read width 128
END_OF_DOCUMENTATION
<dp n="d374"/>
return $a；
}
sub derive_constants{
my($rf)＝@_；
my($read_port，$write_Port，$n，$w，@width)；
#determine parameters for register file banks
foreach $read port(@{$rf-＞{READ_PORT}}){
push(@width，@{$read port-＞{WIDTH}})；
}
foreach $write_port(@{$rf-＞{WRITE_PORT}}){
push(@width，@{$write_port-＞{WIDTH}})；
}
@width＝sort{$a＜＝＞$b}(&uniq(@width))；
$rf-＞{MIN_WIDTH}＝$width[0]；
$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 $w not valid multiple of $rf-＞{MIN_WIDTH}\n″；
}
}
#register file core parameters
$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(&uniq(@{$write_port-＞{DEF}}))；
$write_port-＞{DEF}＝\@def；
$write_port-＞{MAX_DEF}＝&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(&uniq(@{$read_port-＞{USE}}))；
$read_port-＞{USE}＝\@use；
$read_port-＞{MIN_USE}＝min(@{$read_port-＞{USE}})；
<dp n="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}){#an old name for it
$rf-＞{TEST_TRANSPARENT_LATCHES}＝1；
}
$rf-＞{DESIGN_PREFIX}＝$rf-＞{DESIGN_PREFIX}||″″；
}
sub write_regfile{
my($rf)＝@_；
my($lo_addr decl，@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′t need an address for a single word register file
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′t need an address for a single word register file
if($rf-＞{HI_ADDR_SIZE}＞0){
my($addr)＝wfield(″addr″，$write_port，0)；
my($decl)＝″[″.($rf-＞{HI_ADDR_SIZE}-1).″：0]″；
<dp n="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＞ &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，″input Kill_E；\n″)；
print_break(″KillPipe_W，″)；
push(@iolist，″input KillPipe_w；\n″)；
print_break(″Stall_R，″)；
push(@iolist，″output Stall_R；\n″)；
if($rf-＞{USE_LATCHES} && $rf-＞{TEST_TRANSPARENT_LATCHES}){
print_break(″TMode，″)；
push(@iolist，″input TMode；\n″)；
}
print_break(″clk)；\n″)；
push(@iolist，″input clk；\n″)；
print join(′′，@iolist)；
print″\n″；
print join(′′，@defer)；
print″\n″；
foreach $read_port(@{$rf-＞{READ_PORT}}){
<dp n="d377"/>
print″ /*″.(′*′x 70).″\n″；
print″ READ PORT $read_port-＞{NAME}\n″；
print″ *″. (′*′x 70).″/\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) & ((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″//masked address pipeline\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 &
$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-qualified use\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 & ($maddr＝＝($i &
$addr_mask)))；\n″；
}
}
print″\n″；
<dp n="d378"/>
# determine which banks need to be muxed into which output
ports
my(@align)；
for($i＝0；$i＜$rf-＞{NUM_BANK}；$i++){
$align[$i]＝[]；
}
for($w＝1；$w＜＝$rf-＞{NUM_BANK}；$w *＝2){
#does this port need this read-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}(&uniq(@{$align[$i]}))；
}
# print STDOUT″Read table\n″；
# for($i＝0；$i＜$rf-＞{NUM_BANK}；$i++){
# print STDOUT″set $i：″.join(′′，@{$align[$i]}).″\n″；
# }
foreach $s(@{$read_port-＞{USE}}){
print″//alignment mux for use $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″；
}
<dp n="d379"/>
foreach $write_port (@{$rf-＞{WRITE_PORT}}){
print″ /*″.(′*′x70).″\n″；
print″ WRITE PORT $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) & ((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″//width pipeline\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-qualified write def for port $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 &(($addr &
$addr_mask)＝＝($i & $addr_mask)))；\n″；
}
}
print″\n″；
foreach $s(@{$write_port-＞{DEF}}){
my(@data，@sel)；
print″//write mux for def $s\n″；
my($wdata)＝wfield(″wdata″，$write_port，$s)；
foreach $w(@{$write_port-＞{WIDTH}}){
<dp n="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″；
}
#drop n copies of the pipelined regfile
print″ /*″.(′*′x70).″\n″；
print″ PIPELINED BANK\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′t need an address for a single word register file
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]，″)；
<dp n="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} && $rf-＞{TEST_TRANSPARENT_LATCHES}){
print_break(″TMode ，″)；
}
print_break(″clk)；\n″)；
print″\n″；
}
print″ assign Stall_R＝″；
for($i＝0；$i＜$rf-＞{NUM_BANK}；$i++){
print″Stall_R$i|″；
}
print″1′b0；\n″；
print″\n″；
print″endmodule\n″；
}
sub write_regfile_bank{
my($rf)＝@_；
my(@defer，@iolist，$s，$s1，$rs，$ws，$i，$j，$read_port，
$write port，$result)；
init_print_break(2)；
print_break(″module $rf-＞{DESIGN_PREFIX}$rf-＞{NAME}_bank(″)；
#read_port I/O list
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′t need an address for a single wotd register file
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″)；
<dp n="d382"/>
}else{
push(@defer，″wire $use＝0；\n″)；
}
}
}
# write port I/O list
foreach $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，″ input Kill_E；\n″)；
print_break(″KillPipe_W，″)；
push(@iolist，″ input KillPipe_W；\n″)；
print_break(″Stall_R，″)；
push(@iolist，″ output Stall_R；\n″)；
if ($rf->{USE_LATCHES} && $rf->{TEST_TRANSPARENT_LATCHES}){
print_break(″TMode，″)；
push(@iolist，″input TMode；\n″)；
}
print_break(″clk)；\n″)；
push(@iolist，″input clk；\n″)；
<dp n="d383"/>
print join(′′，@iolist)；
print″\n″；
print join(′′，@defer)；
print″\n″；
for($s＝0；$s＜＝$rf-＞{MAX_LATENCY}+1；$s++){
#can′t kill after commit point which is C3
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-port information
###########################################################################
foreach $write_port(@{$rf-＞{WRITE_PORT}}){
#write definition pipeline
print″//write definition pipeline\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 & $wen & -$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″；
# write enable pipeline
print″//write enable pipeline\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)；
<dp n="d384"/>
my $kill＝″kill_C$s″；
my $ns_we＝wfield(″ns_we″，$write_port，$s)；
print″wire $ns_we＝($we|($def & $wen)) &
-$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″；
#Write address pipeline
print″//write address pipeline\n″；
for($s＝1；$s＜＝$write_port-＞{MAX_DEF}+1；$s++){
my $addr＝wfield(″addr″，$write port，$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″；
# Write data pipeline
print″//write data pipeline\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″；
<dp n="d385"/>
}
###########################################################################
# Read-port information
###########################################################################
foreach $read_port(@{$rf-＞{READ_PORT}}){
#need to declare read data which aren′t ports
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″//read address pipeline for port $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；
Bypass logic generation is somewhat tricky.For the first use
(typically use1)the data comes from
(a)write data coming from the datapath(wr0_data_Ci，
i＝1..n)
(b)data stored in the write pipeline(wr0_result_Cn，
i＝2..n+1)
(c)the register file(rd0_data_C0)
For later uses(e.g.，use 2)the data comes from
(a)write data coming from the datapath(wr0_data_Ci，
i＝2..n)
(b)the read pipeline previous stage(rd0_data_C{i-1})
To avoid WAW hazards，there is a defined priority on this data.
Consider a use 1，2，3，4 read pipe and a def 1，2，3，4 write pipe.
<dp n="d386"/>
The priority order for use 1 is：
wr0_data_C1，
wr0_data_C2，
wr0_result_C2，
wr0_data_C3，
wr0_result_C3，
wr0_data_C4，
wr0_result_C4，
wr0_result_C5，
register file.
The priority order for use 2 is similar，except for all places
where
the write pipeline would be used，we use the previous stage
read
pipeline instead. This is because the data stored in the write
pipeline has already been bypassed into the read pipeline
ea rlier.
Hence，the unique sources are wr0_data_C2，wr0_data_C3，
wr0_data_C4，
rd0_data_C1 with a priority order of：
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.
Because of all of the write pipeline data is available very
early，we
build a special mux for the first stage bypass.We first mux
together
all of the stored data in the write pipe with the read data
from the
register file.Then we mux together all of the data coming
from the
datapath.Finally，we select between these two.
DOCUMENTATION
if($main：：verify){
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″//Read bypass controls for port $read_port-
＞{NAME}\n″；
# bypass the data being defined in stage $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++){
<dp n="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)&
$def & $wen & -$kill；\n″；
}
}
}
}
# bypass the old data in the write pipeline in stage $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 && $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) &
$we & -$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″//Read bypass for port $read_port-＞{NAME}use
″.($rs+1).″\n″；
if($rs＝＝$read_port-＞{MIN_USE}-1){
my(@data，@sel)；
#bypass the results from the write pipeline(s)
for($ws＝$rs+1；$ws＜＝$rf-＞{MAX_LATENCY}+1；$ws++)
{ foreach $write_port(@{$rf-＞{WRITE_PORT}}) {
if($ws＞1 && $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)；
}
<dp n="d388"/>
}
}
#lowest priority is data from register file
push(@data，$rdata)；
print″wire $rf-＞{WORD_DECL}$mux_result；\n″；
inline_mux(\@data，\@sel，$rf-＞{WORD_SIZE}，
$mux_result，″priority″)；
$rdata ＝$mux_result；
}
# choose binary encoding for the data bypass mux
# order stage 2 last，read data first
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 && 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++；
}
}
#bui1d the priority-encoded bypass mux
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)；
<dp n="d389"/>
print″xtdelay1 #($rf-＞{WORD_SIZE})i$rdata1($rdatal，
$mux，clk)；\n″；
print″\n″；
}
}
}
print″assign Stall_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) & (\n″；
for($i＝1；$i＜＝$write_port-＞{MAX_DEF}-$s；$i++){
my($use)＝rfield(″use$i″，$read_port，0)；
print″ ($use & (″；
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″；
###########################################################################
# Drop the core-cell
###########################################################################
if($main：：verify){
print″ //verification register file core--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)；
<dp n="d390"/>
print″ xtflop #($rf-＞{WORD_SIZE})x$data($data，$last，
clk)；\n″；
}
}else{
print″//register file core\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} && $rf-＞{TEST_TRANSPARENT_LATCHES}){
print_break(″TMode，″)；
}
print_break(″clk)；\n″)；
}
print″endmodule\n″；
}
sub set_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}；
<dp n="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＜＝&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；
}；
sub regfile_stall_write{
my($rf，$time，$addr，$width)＝@_；
my(si)；
<dp n="d392"/>
for($i＝0；$i＜$width / $rf-＞{MIN_WIDTH}；$i++){
$main：：regfile_stall-＞{$time}-＞{$addr+$i}＝1；
}
}
sub regfile_stall_read{
my($rf，$time，$addr，$width)＝@_；
my($i，$stall)；
$stall＝0；
for($i＝0；$i＜$width/$rf-＞{MIN_WIDTH}；$i++){
$stall|＝defined $main：：regfile_stall-＞{$time}-＞{$addr+$i}；
}
return $stall；
}
sub regfile_write{
my($rf，$time，$addr，$data，$width)＝@_；
my($i)；
for($i＝0；$i＜$width/$rf-＞{MIN_WIDTH}；$i++){
$main：：regfile-＞{$time}-＞{$addr+$i}＝
($data＞＞($i*$rf-＞{MIN_WIDTH}))&((1＜＜$rf-
＞{MIN_WIDTH})-1)；
}
}
sub regfile_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＝$main：：regfile-＞{$t}-＞{$addr+$i}；
if(defined $value){
last；
}
}
if(！defined $value){
die″regfile_read：time＝$time addr＝$addr value undefined″；
}
$out_value|＝$value＜＜($i * $rf-＞{MIN_WIDTH})；
}
return $out_value ；
}
sub init_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($dir eq″in″&& $size＞0){
if($default eq″0″){
$value＝0；
} elsif($default eq″x″){
$value＝$size.″′b″.(′x′x $size)；
<dp n="d393"/>
}else{
die″Bad init. field in $field\n″；
}
add_field($rf，$time，$field，$value)；
}elsif($field eq″Stall_R″){
add_field($rf，$time，$field，″1：0″)；
}
}
}
sub add_field{
my($rf，$time，$field，$value)＝@_；
my($info)＝$rf-＞{SIGNALS}-＞{$field}；
die″add_field：field\″$field\″not found″if！defined $info ；
return if $info-＞{SIZE}＝＝0；
if(！defined $main：：vector-＞{$time}){
$main：：vector-＞{$time}＝{ }；
init_field($rf，$time)；
}
$main：：vector-＞{$time}-＞{$field}＝$value；
}
sub make_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，″)；
print TEST″ wire $decl $data；\n″；
}
# don′t need an address for a single word register file
if($rf-＞{HI_ADDR_SIZE}＞0){
my($addr)＝rfield(″addr″，$read_port，0)；
my($decl)＝″[″.($rf-＞{HI_ADDR_SIZE}-1).″：0]″；
push(@iolist，″$addr，″)；
print TEST″ reg $decl $addr；\n″；
}
foreach $w(@{$read_port-＞{WIDTH}}){
my($width)＝rfield(′width$w″，$read_port，0)；
push(@iolist，″$width，″)；
print TEST″ reg $width；\n″；
}
foreach $s(@{$read_port-＞{USE}}){
my($use)＝rfield(″use$s″，$read_port，0)；
push(@iolist，″$use，″)；
print TEST″reg $use；\n″；
}
}
foreach $write_port(@{$rf-＞{WRITE_PORT}}){
# don′t need an address for a single word register file
if($rf-＞{HI_ADDR_SIZE}＞0){
my($addr)＝wfield(″addr″，$write_port，0)；
my($decl)＝″[″.($rf-＞{HI_ADDR_SIZE}-1).″：0]″；
<dp n="d394"/>
push(@iolist，″$addr，″)；
print TEST″reg $decl $addr；\n″；
}
foreach $w(@{$write_port-＞{WIDTH}}){
my($width)＝rfield(″width$w″，$write_port，0)；
push(@iolist，″$width，″)；
print TEST″ reg $width；\n″；
}
foreach $s(@{$write_port-＞{DEF}}){
my($def)＝wfield(″def$s″，$write port，0)；
push(@iolist，″$def，″)；
print TEST″ 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，″)；
print TEST″reg $decl $data；\n″；
}
}
foreach $s(1..$write_port-＞{MAX_DEF}){
if($s＜＝&max(@{$write_port-＞{DEF}})){
my($wen)＝wfield(″wen″，$write_port，$s)；
push(@iolist，″$wen，″)；
print TEST″ reg $wen；\n″；
}
}
}
push(@iolist，″Kill_E，″)；
print TEST″// reg Kill_E；\n″；
push(@iolist，″KillPipe_W，″)；
print TEST″ reg KillPipe_W；\n″；
push(@iolist，″Stall_R，″)；
print TEST″ wire Stall_R；\n″；
push(@iolist，″clk)；\n″)；
print TEST″ reg clk；\n″；
print TEST″ $rf-＞{NAME}io(″；
print TEST join(″，@iolist)；
print TEST″\n″；
}
sub print_vector{
my($rf)＝@_；
my($time，$size，$value，$width，$last_value，$mask，$addr，$dir，
$field)；
my($max_time)＝max(keys(％$main：：vector))；
print TEST″module driver ；\n″；
make_view_pipeline_register_cell($rf)；
print TEST″ initial begin\n″；
<dp n="d395"/>
print TEST″ #2；\n″；
for($time＝0；$time＜＝$max_time；$time++){
print TEST″\n″；
print TEST″\n″；
print TEST″//time：$time\n″；
foreach $field(sort(keys(％{$main：：vector-＞{$time}}))){
$dir＝$rf-＞{SIGNALS}-＞{$field}-＞{DIR}；
next if $dir ne″in″；
$value＝$main：：vector-＞{$time}-＞{$field}；
$last_value＝$main：：vector-＞{$time-1}-＞{$field}；
if($time＝＝0||！defined $last_value||$value ne
$last_value){
print TEST″ $field＝$value；\n″；
}
}
print TEST″ #5；\n″；
if(defined $main：：print_vector{$time}){
print TEST″
\$display(\″$main：：print_vector{$time}\″)；\n″；
}
foreach $field(sort(keys(％{$main：：vector-＞{$time}}))){
$dir＝$rf-＞{SIGNALS}-＞{$field}-＞{DIR}；
next if $dir ne″out″；
($width，$value)＝split(′：，$main：：vector-＞{$time}-
＞{$field})；
if($field ne″Stall_R″){
$field＝$field.″[″.($width-1).″：0]″；
}
print TEST″if($field！＝$value)begin\n″；
print TEST″ \$display(\″FAIL！％d $field％d
$value\″，\$time，$field)；\n″；
print TEST″ end\n″；
}
print TEST″ #5 ；\n″；
}
print TEST″ end\n″；
print TEST′xtflop #(1)dummy(Kill_E，Stall_R，clk)；\n\n″；
print TEST″initial begin clk＝1；end\n″；
print TEST″always begin #5 clk＝～clk；end\n\n′；
print TEST″always begin #(″.($max_time+10).″*10)\$finish；
end\n″；
print TEST″endmodule\n″；
}
<dp n="d396"/>
$main：：try_kill＝0；
$main：：time＝0；
$main：：nop_count＝0；
sub inst{
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＝$main：：time++；
@operand＝split(′′，$arg)；
$arg_print＝″″；
#check for stall on any read port
$stall＝0；
foreach $op(@operand){
next if substr($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″，″1：1″)；
}
# if there is no stall，try a random killpipe when this
# instruction reaches W
if($main：：try_ki1l && $kill && $stall＝＝0 && int(rand(20))＝＝
0) {
$main：：nop_count＝4；
add_field($rf，$time+3，″KillPipe_W″，1)；
$arg_print.＝sprintf(″％-10s″，″Kill！″)；
}
# process the read(s)
foreach $op(@operand){
next if substr($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″)；
}
# process the write(s)
<dp n="d397"/>
foreach $op(@operand){
next if substr($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($main：：nop_count＝＝0){
regfile_write($rf，$time，$addr，$data，$width)；
}
}
$arg_print.＝sprintf(″％-20s″，″$op＝$data″)；
}
if($main：：nop_count＞0){
$main：：nop_count--；
}
$main：：print_vector{$time}＝sprintf(″％4d：％d ％s″，$time，$stall，
$arg_print)；
# replay the instruction on a stall
if($stall){
inst($rf，$arg，$kill)；
}
}
<dp n="d398"/>
sub test_view_pipeline_regfile {
my($rf)＝@_；
my($i，$num，$port，$addr，$use，$def，$width，$op，$read_port，
$write_port)；
# write each address using max write-width，min def，min port #
$write_port＝$rf-＞{WRITE_PORT}-＞[0]；
$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}}[0]；
$op＝″＞0-$a-$def-$width″；
inst($rf，$op，0)；
}
#flush the pipeline
for($i＝0；$i＜10；$i++){
inst($rf，″″，0)；
}
# read each address using each read-width，each use，each port
$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($main：：time＜$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))]；
<dp n="d399"/>
$op.＝″＞$port-$addr-$def-$width″；
}
}
inst($rf，$op，1)；
}
#flush the pipeline
for($i＝0；$i＜10；$i++){
inst($rf，″″，0)；
}
print_yector($rf)；
}
my($rf，$rf_all，$i，$TEST，$usage，$ret}；
srand 1；
#default values
$main：：verify＝0；
$usage＝＜＜EOF；
usage：$0[options]
EOF
#parse the command line
$ret ＝GetOptions(
″verify″＝＞\$main：：verify，
)；
if(！$ret){
print″$usage″；
exit 1：
}
$rf_all＝′$rf_all＝[′.join(′′，＜＞).，]；′；
eval($rf_all)||die″Syntax error in input description″；
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′t open $TEST：$！″；
test_view_pipeline_regfile($rf)；
close TEST；
}
}
附录C
#！/usr/xtensa/tools/bin/perl-w
# Generate ISA documentation from TIE files.
# $Id：GenISAHTML，v 1.6 2000/01/06 00：53：16 earl Exp $
# Copyright 1999-2000 Tensilica Inc.
# These coded instructions，statements，and computer
programs are
# Confidential Proprietary Information of Tensilica Inc.
and may not be
# disclosed to third parties or copied in any form，in
whole or in part，
# without the prior written consent of Tensilica Inc.
package Xtensa：：GetISAHTML；
# Imports
# Use this to find library files
use lib $ENV{′TENSILICA_TOOLS′}.′/lib′；
#use lib′@xtools@/lib′；
# perl library modules
use strict；
use Getopt：：Long；
# Other modules
use HTML；
use Xtensa：：TargetISA ；
use Xtensa：：GenISA；
# program
# prevent use strict errors for our global variables
use vars qw(％idiom)；
{
$：：myname＝′GetISAHTML′；
# command line
my $htmldir＝undef；
my $tpp＝undef；
die(″Usage is：$：：myname -htmldir dir [options...]
file\n″)
unless &GetOptions(″htmldir＝s″＝＞\$htmldir，
″tpp＝s″＝＞\$tpp)
&& defined($htmldir)
&& @ARGV＝＝1；
<dp n="d402"/>
if(！-d $htmldir){
mkdir($htmldir，0777)
||die(″$：：myname：$！，creating $htmldir.\n″)；
}
$htmldir.＝′/′unless $htmldir＝-m|/$|；# ready for
catenating filenames
my($isafile)＝@ARGV；
my $isa＝new Xtensa：：TargetISA($tpp，$isafile)；
GenISAHTML($htmldir，$isa)；
}
sub GenISAHTML{
my($htmldir，$isa)＝@_；
my $indexfh＝new FileHandle($htmldir.′index.html′，
′＞′)；
die(″$：：my-name：$！，opening ${htmldir}index.html for
output.\n″)
unless $indexfh；
my $index＝new HTML($indexfh，2)；
$index-＞hbegin(′Instructions′)；
$index-＞block(′h1′，′Instructions′)；
$index-＞block(′h2′，′Alphabetic by mnemonic′)；
$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)){
print STDERR(″$：：myname：No synopsis for
$instname\n″)；
$synopsis＝″；
}
$＝$instname；
s/\.//g；
my $instfile＝$-.′.html′；
$index-＞bblock(′tr′)；
<dp n="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＝new FileHandle($htmldir.$instfile，
′＞′)；
die(″$：：myname：$！，opening $htmldir$instfile for
output.\n″)
unless $instfh；
my$html＝new HTML($instfh，2)；
$html-＞hbegin(″$instname-$synopsis″)；
instdoc($html，$isa，$inst)；
$html-＞hend()；
$html-＞close()；
$instfh-＞close()；
} #foreach inst
$index-＞eblock(′tbody′)；
$index-＞eblock(′table′)；
$index-＞hend()；
$index-＞close()；
$indexfh-＞close()；
}
#Generate the instruction word box
sub instbox{
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″)；# something to force a mismatch
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))；
<dp n="d404"/>
if(defined($caption) && $caption ne ′′){
$html-＞inline(′caption′，$caption)
}
#column groups
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))；
}
#bit numbers
$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′)；
<dp n="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 && $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) &1；
$html-＞block(′td′，$b，attribute(′width′，
$cellwidth)，
attribute(′align′，′center′)，
attribute(′bgcolor′，′#FFF0F5′))；
$j＝$i-1；
}
}
if($j！＝-1){
$html-＞block(′td′，$fields[0]，attribute(′colspan′，
$j+1)，
attribute(′width′，($j+1)*
$cellwidth)，
attribute(′align′，′center′))；
}
$html-＞eblock(′tr′)；
$html-＞eblock(′tbody′)；
#field widths
$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)，
<dp n="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
# Generate documentation for instrution $inst to HTML
object $hmtl.
sub instdoc {
my ($html，$isa，$inst)＝@_；
my $instname＝uc($inst-＞mnemonic())；
my $synopsis＝$inst-＞synopsis()；
if (！defined($synopsis)){
print STDERR(″$：：myname：No synopsis for
$instname\n″)；
$synopsis＝″；
}
$html-＞block(′h1′，″$instname &#8212；$synopsis″)；
$html-＞block(′h2′，′Instruction Word′)；
instbox ($html，$isa，$inst)；
$html-＞block(′h2′，′Package′)；
if($idiom{$instname}){
$_＝′Assembler Macro′；
} else{
$_＝$inst-＞package()；
s/：.$//；
my $pkglong＝$pkglong{$_}；
if(defined($pkglong)){
$_＝$pkglong；
} else{
tr/a-z/A-Z/；
}
}
$html-＞block(′p′，$)；
$html-＞block(′h2′，′Assembler Syntax′)；
$html-＞bblock(′p′)；
my @iasm＝map($_-＞name，$inst-＞operands)；
<dp n="d407"/>
$html-＞inline(′code′，@iasm＝＝0？$instname
：($instname.′′.join(′，′，
@iasm)))；
$html-＞eblock(′p ′)；
$html-＞block(′h2′，′Description′)；
my $idesc＝$inst-＞description()；
if(！defined($idesc)) {
print STDERR ″$：：myname：No description for
$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′，′Assembler Note′)；
$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 &#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＝$ename unless defined($elong)；
$html-＞block(′li′，$elong)；
}
$html-＞eblock(′ul′)；
} else{
$html-＞block(′p′，′None′)；
<dp n="d408"/>
}
}
my $iimpnote＝$inst-＞impnote()；
if(defined($iimpnote)){
$iimpnote＝～s|＜INSTREF＞([A-
Z.]+？)＜/INSTREF＞|insthref($1)|gei ；
$html-＞block(′h2′，′Implementation Note′)；
$html-＞iprint($iimpnote)；
}
} # instdoc
# Return HTML fragment for referencing another
instruction
sub insthref{
my($inst)＝@_；
$＝$inst；
s/\.//g；
′＜CODE＞＜A HREF＝″′.$_.′.html″＞′.$inst.
′＜/A＞＜/CODE＞′；
}
# Local Variables：
# mode：perl
# perl-indent-level：2
# cperl-indent-level：2
# End：
# Stuff common to GenISAHTML and GenISAMIF
# $Id：GenISA.pm，v 1.7 1999/12/19 08：10：38 earl Exp $
# Copyright 1999-2000 Tensilica Inc.
# These coded instructions，statements，and computer
programs are
# Confidential Proprietary Information of Tensilica Inc.
and may not be
# disclosed to third parties or copied in any form，in
whole or in part，
# without the prior written consent of Tensilica Inc.
package Xtensa：：GenISA；
# Exports
use Exporter()；
@Xtensa：：GenISA：：ISA＝qw(Exporter)；
@Xtensa：：GenISA：：EXPORT＝qw(％pkglong ％pkgchapter
％exclong &isort &generated)；
@Xtensa：：GenISA：：EXpORT_OK＝@Xtensa：：GenISA：：EXPORT；
％Xtensa：：GenISA：：EXPORT_TAGS＝()；
<dp n="d409"/>
# Imports
# perl library modules
use strict；
# Module body begins here
# prevent use strict errors for our global variables
use vars qw(％pkglong ％pkgchapter ％exclong)；
％pkglong＝(
′32bitdiv′＝＞′32-bit Integer Divide′，
′32bitmul′＝＞′32-bit Integer Multiply′，
′athens′＝＞′Xtensa V1′，
′booleans′＝＞′Coprocessor Option′，
′coprocessor′＝＞′Coprocessor Option′，
′core′＝＞′Core Architecture′，
′datacache′＝＞′Data Cache ′，
′debug′＝＞′Debug Option′，
′density′＝＞′Code Density Option′，
′exception′＝＞′Exception Option′，
′fp′＝＞′Floatinq Point′，
′instcache′＝＞′Instruction Cache′，
′interrupt′＝＞′Interrupt Option′，
′mac16′＝＞′MAC16 Option′，
′misc′＝＞′Miscellaneous′，
′mul16′＝＞′Mul16 Option′，
′regwin′＝＞′Windowed Registers Option′，
′spec′＝＞′Speculation Option′，
′sync′＝＞′Multiprocessor Synchronization Option′，
′timer′＝＞′Timer Option′，
′vectorinteger′＝＞′Vector Integer Coprocessor′)；
％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′，
<dp n="d410"/>
′regwin′＝＞′ch5′，
′spec′＝＞′ch5′，
′sync′＝＞′ch5′，
′timer′＝＞′ch5′，
′Vectorinteger′＝＞′vec′)；
％exclong＝(
′SystemCall′＝＞′System Call′，
′LoadStoreError′＝＞′Load Store Error′，
′FloatingPoint′＝＞′Floating Point Exception′，
′InstructionFetchError′＝＞′Instruction Fetch
Error′，
′IntegerDivideByZero′＝＞′Integer Divide by Zero′)；
# Instruction name sort
sub isort{
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($a1 cmp $b1)||($a2＜＝＞$b2)||($a3 cmp
$b3)；
}
}
$am cmp $bm；
}
#Generated output file comment
sub generated{
my($handle，$cstart，$cend，@files)＝@_；
my $date；
chomp($date＝`date`)；
$handle-＞print($cstart，′This file is automatically
generated--DO NOT EDIT′，$cend，″\n″)；
$handle-＞print($cstart，′Generated from′，join(′′，
@files)，$cend，″\n″)；
$handle-＞print($cstart，′by′，$：：myname，′on′，
$date，$cend，″\n″)；
}
1；
# Local Variables：
# mode：perl
# cperl-indent-level：2
# perl-indent-level：2
# End：
Claims (49)
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.处理器仿真系统，包括：
硬件仿真装置，用于执行对可扩充处理器的硬件描述；
软件仿真装置，用于执行可扩充处理器的软件参考模型；以及
联合仿真装置，用于使用硬件仿真装置和软件仿真装置，并比较所得到的仿真结果，从而建立可扩充处理器硬件描述和可扩充处理器软件参考模型之间的对应关系。
Applications Claiming Priority (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| US09/506,502 US7036106B1 (en) | 2000-02-17 | 2000-02-17 | Automated processor generation system for designing a configurable processor and method for the same |
| US09/506,502 | 2000-02-17 |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN1436335A true CN1436335A (zh) | 2003-08-13 |
| CN1288585C CN1288585C (zh) | 2006-12-06 |
Family
ID=24014856
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CNB018052401A Expired - Lifetime CN1288585C (zh) | 2000-02-17 | 2001-02-15 | 用于设计可配置处理器的自动处理器生成系统及方法 |
Country Status (8)
| Country | Link |
|---|---|
| US (4) | US7036106B1 (zh) |
| JP (1) | JP4619606B2 (zh) |
| KR (1) | KR100589744B1 (zh) |
| CN (1) | CN1288585C (zh) |
| AU (1) | AU2001238403A1 (zh) |
| GB (1) | GB2376546B (zh) |
| TW (1) | TW571206B (zh) |
| WO (1) | WO2001061576A2 (zh) |
Cited By (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN100389419C (zh) * | 2004-12-11 | 2008-05-21 | 鸿富锦精密工业（深圳）有限公司 | 系统设定档案储存系统及方法 |
| CN102144167A (zh) * | 2008-08-20 | 2011-08-03 | 国立大学法人九州工业大学 | 生成装置、生成方法以及程序 |
| CN108920232A (zh) * | 2018-06-20 | 2018-11-30 | 维沃移动通信有限公司 | 一种目标对象的处理方法及终端设备 |
| CN109101239A (zh) * | 2018-08-30 | 2018-12-28 | 杭州电子科技大学 | 一种在线Verilog代码自动判决系统的标准答案生成方法 |
| CN111523283A (zh) * | 2020-04-16 | 2020-08-11 | 北京百度网讯科技有限公司 | 一种验证处理器的方法、装置、电子设备及存储介质 |
Families Citing this family (109)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN1378665A (zh) | 1999-06-10 | 2002-11-06 | Pact信息技术有限公司 | 编程概念 |
| AU2001243463A1 (en) * | 2000-03-10 | 2001-09-24 | Arc International Plc | Memory interface and method of interfacing between functional entities |
| FR2811093A1 (fr) * | 2000-06-30 | 2002-01-04 | St Microelectronics Sa | Dispositif et procede d'evaluation d'algorithmes |
| DE10034869A1 (de) * | 2000-07-18 | 2002-02-07 | Siemens Ag | Verfahren zum automatischen Gewinnen einer funktionsfähigen Reihenfolge von Prozessen und Werkzeug hierzu |
| US8058899B2 (en) | 2000-10-06 | 2011-11-15 | Martin Vorbach | Logic cell array and bus system |
| GB0028079D0 (en) * | 2000-11-17 | 2001-01-03 | Imperial College | System and method |
| US9552047B2 (en) | 2001-03-05 | 2017-01-24 | Pact Xpp Technologies Ag | Multiprocessor having runtime adjustable clock and clock dependent power supply |
| US9250908B2 (en) | 2001-03-05 | 2016-02-02 | Pact Xpp Technologies Ag | Multi-processor bus and cache interconnection system |
| US9411532B2 (en) | 2001-09-07 | 2016-08-09 | Pact Xpp Technologies Ag | Methods and systems for transferring data between a processing device and external devices |
| US9436631B2 (en) | 2001-03-05 | 2016-09-06 | Pact Xpp Technologies Ag | Chip including memory element storing higher level memory data on a page by page basis |
| US10031733B2 (en) | 2001-06-20 | 2018-07-24 | Scientia Sol Mentis Ag | Method for processing data |
| US6941548B2 (en) | 2001-10-16 | 2005-09-06 | Tensilica, Inc. | Automatic instruction set architecture generation |
| DE10305584A1 (de) * | 2002-02-04 | 2003-08-07 | Arthrex Inc | Knotenschieber und Fadengreifer |
| DE10205523A1 (de) * | 2002-02-08 | 2003-08-28 | Systemonic Ag | Verfahren zum Bereitstellen einer Entwurfs-, Test- und Entwicklungsumgebung sowie ein System zur Ausführung des Verfahrens |
| US9170812B2 (en) | 2002-03-21 | 2015-10-27 | Pact Xpp Technologies Ag | Data processing system having integrated pipelined array data processor |
| JP2003316838A (ja) * | 2002-04-19 | 2003-11-07 | Nec Electronics Corp | システムｌｓｉの設計方法及びこれを記憶した記録媒体 |
| JP4202673B2 (ja) * | 2002-04-26 | 2008-12-24 | 株式会社東芝 | システムｌｓｉ開発環境生成方法及びそのプログラム |
| US7346881B2 (en) | 2002-05-13 | 2008-03-18 | Tensilica, Inc. | Method and apparatus for adding advanced instructions in an extensible processor architecture |
| US7937559B1 (en) | 2002-05-13 | 2011-05-03 | Tensilica, Inc. | System and method for generating a configurable processor supporting a user-defined plurality of instruction sizes |
| US7376812B1 (en) | 2002-05-13 | 2008-05-20 | Tensilica, Inc. | Vector co-processor for configurable and extensible processor architecture |
| GB0215034D0 (en) * | 2002-06-28 | 2002-08-07 | Critical Blue Ltd | Architecture generation method |
| GB0215033D0 (en) * | 2002-06-28 | 2002-08-07 | Critical Blue Ltd | Instruction set translation method |
| FR2843214B1 (fr) * | 2002-07-30 | 2008-07-04 | Bull Sa | Procede de verification fonctionnelle d'un modele de circuit integre pour constituer une plate-forme de verification, equipement emulateur et plate-forme de verification. |
| WO2004038599A1 (de) | 2002-09-06 | 2004-05-06 | Pact Xpp Technologies Ag | Rekonfigurierbare sequenzerstruktur |
| US7228531B1 (en) * | 2003-02-03 | 2007-06-05 | Altera Corporation | Methods and apparatus for optimizing a processor core on a programmable chip |
| WO2004072797A2 (en) * | 2003-02-07 | 2004-08-26 | Safenet, Inc. | System and method for determining the start of a match of a regular expression |
| US7194705B1 (en) * | 2003-03-14 | 2007-03-20 | Xilinx, Inc. | Simulation of integrated circuitry within a high-level modeling system using hardware description language circuit descriptions |
| US8612992B2 (en) * | 2003-04-09 | 2013-12-17 | Jaluna Sa | Operating systems |
| EP1467282B1 (en) * | 2003-04-09 | 2008-10-01 | Jaluna SA | Operating systems |
| EP1503286B1 (en) * | 2003-07-30 | 2014-09-03 | Jaluna SA | Multiple operating system networking |
| KR20070005917A (ko) * | 2003-09-30 | 2007-01-10 | 쟈루나 에스에이 | 운영체제 |
| US7290174B1 (en) * | 2003-12-03 | 2007-10-30 | Altera Corporation | Methods and apparatus for generating test instruction sequences |
| US7770147B1 (en) * | 2004-03-08 | 2010-08-03 | Adaptec, Inc. | Automatic generators for verilog programming |
| US20050216900A1 (en) * | 2004-03-29 | 2005-09-29 | Xiaohua Shi | Instruction scheduling |
| US7398492B2 (en) * | 2004-06-03 | 2008-07-08 | Lsi Corporation | Rules and directives for validating correct data used in the design of semiconductor products |
| US7404156B2 (en) * | 2004-06-03 | 2008-07-22 | Lsi Corporation | Language and templates for use in the design of semiconductor products |
| US7334201B1 (en) * | 2004-07-02 | 2008-02-19 | Tensilica, Inc. | Method and apparatus to measure hardware cost of adding complex instruction extensions to a processor |
| US7324106B1 (en) * | 2004-07-27 | 2008-01-29 | Nvidia Corporation | Translation of register-combiner state into shader microcode |
| US7389490B2 (en) * | 2004-07-29 | 2008-06-17 | International Business Machines Corporation | Method, system and program product for providing a configuration specification language supporting selective presentation of configuration entities |
| US7386825B2 (en) | 2004-07-29 | 2008-06-10 | International Business Machines Corporation | Method, system and program product supporting presentation of a simulated or hardware system including configuration entities |
| DE602005019448D1 (de) * | 2004-10-28 | 2010-04-01 | Ip Flex Inc | Datenverarbeitungsgerät mit rekonfigurierbarer logischer schaltung |
| US7712081B2 (en) * | 2005-01-19 | 2010-05-04 | International Business Machines Corporation | Using code motion and write and read delays to increase the probability of bug detection in concurrent systems |
| US7664928B1 (en) * | 2005-01-19 | 2010-02-16 | Tensilica, Inc. | Method and apparatus for providing user-defined interfaces for a configurable processor |
| US7386814B1 (en) | 2005-02-10 | 2008-06-10 | Xilinx, Inc. | Translation of high-level circuit design blocks into hardware description language |
| JP4342464B2 (ja) * | 2005-03-29 | 2009-10-14 | 富士通マイクロエレクトロニクス株式会社 | マイクロコントローラ |
| US7676783B2 (en) * | 2005-06-27 | 2010-03-09 | Ikoa Corporation | Apparatus for performing computational transformations as applied to in-memory processing of stateful, transaction oriented systems |
| DE102005041312A1 (de) * | 2005-08-31 | 2007-03-15 | Advanced Micro Devices, Inc., Sunnyvale | Speicherzugriff auf virtuelles Targetgerät |
| US7523434B1 (en) | 2005-09-23 | 2009-04-21 | Xilinx, Inc. | Interfacing with a dynamically configurable arithmetic unit |
| US20070074078A1 (en) * | 2005-09-23 | 2007-03-29 | Potts Matthew P | Test replication through revision control linking |
| US7478356B1 (en) * | 2005-09-30 | 2009-01-13 | Xilinx, Inc. | Timing driven logic block configuration |
| US7366998B1 (en) * | 2005-11-08 | 2008-04-29 | Xilinx, Inc. | Efficient communication of data between blocks in a high level modeling system |
| US8250503B2 (en) * | 2006-01-18 | 2012-08-21 | Martin Vorbach | Hardware definition method including determining whether to implement a function as hardware or software |
| US7757224B2 (en) * | 2006-02-02 | 2010-07-13 | Microsoft Corporation | Software support for dynamically extensible processors |
| JP2007272797A (ja) * | 2006-03-31 | 2007-10-18 | Toshiba Corp | パイプライン高位合成システム及び方法 |
| US7827517B1 (en) * | 2006-05-19 | 2010-11-02 | Altera Corporation | Automated register definition, builder and integration framework |
| JP4707191B2 (ja) * | 2006-09-26 | 2011-06-22 | 富士通株式会社 | 検証支援プログラム、該プログラムを記録した記録媒体、検証支援装置、および検証支援方法 |
| US8935512B2 (en) * | 2006-11-21 | 2015-01-13 | Nec Corporation | Instruction operation code generation system |
| US7529909B2 (en) * | 2006-12-28 | 2009-05-05 | Microsoft Corporation | Security verified reconfiguration of execution datapath in extensible microcomputer |
| US7971132B2 (en) * | 2007-01-05 | 2011-06-28 | Dialogic Corporation | Universal multimedia engine and method for producing the same |
| JP2008176453A (ja) * | 2007-01-17 | 2008-07-31 | Nec Electronics Corp | シミュレーション装置 |
| US8726241B1 (en) * | 2007-06-06 | 2014-05-13 | Rockwell Collins, Inc. | Method and system for the development of high-assurance computing elements |
| US7913203B1 (en) | 2007-11-23 | 2011-03-22 | Altera Corporation | Method and apparatus for designing a system on multiple field programmable gate array device types |
| US7873934B1 (en) | 2007-11-23 | 2011-01-18 | Altera Corporation | Method and apparatus for implementing carry chains on field programmable gate array devices |
| US8176406B2 (en) * | 2008-03-19 | 2012-05-08 | International Business Machines Corporation | Hard error detection |
| US7974967B2 (en) * | 2008-04-15 | 2011-07-05 | Sap Ag | Hybrid database system using runtime reconfigurable hardware |
| US8136063B2 (en) * | 2008-11-14 | 2012-03-13 | Synopsys, Inc. | Unfolding algorithm in multirate system folding |
| US8843862B2 (en) * | 2008-12-16 | 2014-09-23 | Synopsys, Inc. | Method and apparatus for creating and changing logic representations in a logic design using arithmetic flexibility of numeric formats for data |
| US8127262B1 (en) * | 2008-12-18 | 2012-02-28 | Xilinx, Inc. | Communicating state data between stages of pipelined packet processor |
| KR101553652B1 (ko) * | 2009-02-18 | 2015-09-16 | 삼성전자 주식회사 | 이종 프로세서에 대한 명령어 컴파일링 장치 및 방법 |
| KR101401244B1 (ko) * | 2009-09-04 | 2014-05-28 | 실리콘 하이브 비.브이. | 방법 및 장치 및 기록 매체 |
| US8156459B1 (en) * | 2009-11-10 | 2012-04-10 | Xilinx, Inc. | Detecting differences between high level block diagram models |
| US8548798B2 (en) * | 2010-02-26 | 2013-10-01 | International Business Machines Corporation | Representations for graphical user interfaces of operators, data types, and data values in a plurality of natural languages |
| US8972953B2 (en) * | 2010-04-16 | 2015-03-03 | Salesforce.Com, Inc. | Methods and systems for internally debugging code in an on-demand service environment |
| US8839214B2 (en) * | 2010-06-30 | 2014-09-16 | Microsoft Corporation | Indexable type transformations |
| US8358653B1 (en) * | 2010-08-17 | 2013-01-22 | Xilinx, Inc. | Generating a pipeline of a packet processor from a parsing tree |
| US8385340B1 (en) * | 2010-08-17 | 2013-02-26 | Xilinx, Inc. | Pipeline of a packet processor programmed to concurrently perform operations |
| JP2012099035A (ja) * | 2010-11-05 | 2012-05-24 | Fujitsu Ltd | プロセッサの動作検証方法、プロセッサの動作検証装置、及びプロセッサの動作検証プログラム |
| CN102567149B (zh) * | 2010-12-09 | 2016-03-23 | 上海华虹集成电路有限责任公司 | Soc系统验证方法 |
| US8341565B2 (en) | 2010-12-20 | 2012-12-25 | International Business Machines Corporation | Task-based multi-process design synthesis with reproducible transforms |
| US8392866B2 (en) * | 2010-12-20 | 2013-03-05 | International Business Machines Corporation | Task-based multi-process design synthesis with notification of transform signatures |
| US8407652B2 (en) | 2010-12-20 | 2013-03-26 | International Business Machines Corporation | Task-based multi-process design synthesis |
| US8423343B2 (en) * | 2011-01-24 | 2013-04-16 | National Tsing Hua University | High-parallelism synchronization approach for multi-core instruction-set simulation |
| US8707266B2 (en) * | 2011-03-21 | 2014-04-22 | Cisco Technology, Inc. | Command line interface robustness testing |
| US8520428B2 (en) * | 2011-03-25 | 2013-08-27 | Intel Corporation | Combined data level-shifter and DE-skewer |
| CN102521011B (zh) * | 2011-11-18 | 2014-08-06 | 华为技术有限公司 | 一种模拟器的生成方法及装置 |
| TWI505636B (zh) * | 2012-04-10 | 2015-10-21 | Univ Lunghwa Sci & Technology | 具有最佳多重取樣率之有限脈衝濾波器及其製造方法 |
| CN103543983B (zh) * | 2012-07-11 | 2016-08-24 | 世意法（北京）半导体研发有限责任公司 | 用于提高平衡吞吐量数据路径架构上的fir操作性能的新颖数据访问方法 |
| GB2508233A (en) | 2012-11-27 | 2014-05-28 | Ibm | Verifying logic design of a processor with an instruction pipeline by comparing the output from first and second instances of the design |
| US9696998B2 (en) * | 2013-08-29 | 2017-07-04 | Advanced Micro Devices, Inc. | Programmable substitutions for microcode |
| US9811335B1 (en) | 2013-10-14 | 2017-11-07 | Quicklogic Corporation | Assigning operational codes to lists of values of control signals selected from a processor design based on end-user software |
| US9336072B2 (en) * | 2014-02-07 | 2016-05-10 | Ralph Moore | Event group extensions, systems, and methods |
| US9660650B1 (en) * | 2014-03-13 | 2017-05-23 | Altera Corporation | Integrated circuits with improved register circuitry |
| US9268597B2 (en) | 2014-04-01 | 2016-02-23 | Google Inc. | Incremental parallel processing of data |
| CN106664441A (zh) * | 2014-07-07 | 2017-05-10 | 汤姆逊许可公司 | 根据元数据增强视频内容 |
| CN105279062A (zh) * | 2014-07-24 | 2016-01-27 | 上海华虹集成电路有限责任公司 | 调整随机权重的方法 |
| US9250900B1 (en) | 2014-10-01 | 2016-02-02 | Cadence Design Systems, Inc. | Method, system, and computer program product for implementing a microprocessor with a customizable register file bypass network |
| US10528443B2 (en) * | 2015-01-30 | 2020-01-07 | Samsung Electronics Co., Ltd. | Validation of multiprocessor hardware component |
| US9507891B1 (en) | 2015-05-29 | 2016-11-29 | International Business Machines Corporation | Automating a microarchitecture design exploration environment |
| US10642617B2 (en) * | 2015-12-08 | 2020-05-05 | Via Alliance Semiconductor Co., Ltd. | Processor with an expandable instruction set architecture for dynamically configuring execution resources |
| US9542290B1 (en) | 2016-01-29 | 2017-01-10 | International Business Machines Corporation | Replicating test case data into a cache with non-naturally aligned data boundaries |
| CN105912264A (zh) * | 2016-04-01 | 2016-08-31 | 浪潮电子信息产业股份有限公司 | 一种升级硬盘扩展器的方法及系统、一种硬盘扩展器 |
| US10169180B2 (en) | 2016-05-11 | 2019-01-01 | International Business Machines Corporation | Replicating test code and test data into a cache with non-naturally aligned data boundaries |
| US10055320B2 (en) | 2016-07-12 | 2018-08-21 | International Business Machines Corporation | Replicating test case data into a cache and cache inhibited memory |
| US10223225B2 (en) | 2016-11-07 | 2019-03-05 | International Business Machines Corporation | Testing speculative instruction execution with test cases placed in memory segments with non-naturally aligned data boundaries |
| US10261878B2 (en) | 2017-03-14 | 2019-04-16 | International Business Machines Corporation | Stress testing a processor memory with a link stack |
| CN111814093A (zh) * | 2019-04-12 | 2020-10-23 | 杭州中天微系统有限公司 | 一种乘累加指令的处理方法和处理装置 |
| US11662988B2 (en) * | 2020-09-29 | 2023-05-30 | Shenzhen GOODIX Technology Co., Ltd. | Compiler for RISC processor having specialized registers |
| TWI783310B (zh) * | 2020-11-26 | 2022-11-11 | 華邦電子股份有限公司 | 計數方法以及計數裝置 |
| CN113392603B (zh) * | 2021-08-16 | 2022-02-18 | 北京芯愿景软件技术股份有限公司 | 门级电路的rtl代码生成方法、装置和电子设备 |
Family Cites Families (45)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US5287511A (en) * | 1988-07-11 | 1994-02-15 | Star Semiconductor Corporation | Architectures and methods for dividing processing tasks into tasks for a programmable real time signal processor and tasks for a decision making microprocessor interfacing therewith |
| US5544067A (en) | 1990-04-06 | 1996-08-06 | Lsi Logic Corporation | Method and system for creating, deriving and validating structural description of electronic system from higher level, behavior-oriented description, including interactive schematic design and simulation |
| US5572437A (en) * | 1990-04-06 | 1996-11-05 | Lsi Logic Corporation | Method and system for creating and verifying structural logic model of electronic design from behavioral description, including generation of logic and timing models |
| US5623418A (en) | 1990-04-06 | 1997-04-22 | Lsi Logic Corporation | System and method for creating and validating structural description of electronic system |
| US5867399A (en) | 1990-04-06 | 1999-02-02 | Lsi Logic Corporation | System and method for creating and validating structural description of electronic system from higher-level and behavior-oriented description |
| US5555201A (en) | 1990-04-06 | 1996-09-10 | Lsi Logic Corporation | Method and system for creating and validating low level description of electronic design from higher level, behavior-oriented description, including interactive system for hierarchical display of control and dataflow information |
| US5613098A (en) | 1991-03-07 | 1997-03-18 | Digital Equipment Corporation | Testing and debugging new Y architecture code on existing X architecture system by using an environment manager to switch between direct X code execution and simulated Y code execution |
| US5361373A (en) | 1992-12-11 | 1994-11-01 | Gilson Kent L | Integrated circuit computing device comprising a dynamically configurable gate array having a microprocessor and reconfigurable instruction execution means and method therefor |
| US5748979A (en) | 1995-04-05 | 1998-05-05 | Xilinx Inc | Reprogrammable instruction set accelerator using a plurality of programmable execution units and an instruction page table |
| US5918035A (en) | 1995-05-15 | 1999-06-29 | Imec Vzw | Method for processor modeling in code generation and instruction set simulation |
| DE69631278T2 (de) | 1995-10-23 | 2004-11-18 | Interuniversitair Micro-Electronica Centrum Vzw | Entwurfssystem und -verfahren zum kombinierten Entwurf von Hardware und Software |
| US6035123A (en) | 1995-11-08 | 2000-03-07 | Digital Equipment Corporation | Determining hardware complexity of software operations |
| US5696956A (en) | 1995-11-08 | 1997-12-09 | Digital Equipment Corporation | Dynamically programmable reduced instruction set computer with programmable processor loading on program number field and program number register contents |
| US5819064A (en) | 1995-11-08 | 1998-10-06 | President And Fellows Of Harvard College | Hardware extraction technique for programmable reduced instruction set computers |
| US5887169A (en) | 1996-03-15 | 1999-03-23 | Compaq Computer Corporation | Method and apparatus for providing dynamic entry points into a software layer |
| JP2869379B2 (ja) * | 1996-03-15 | 1999-03-10 | 三菱電機株式会社 | プロセッサ合成システム及びプロセッサ合成方法 |
| US5857106A (en) | 1996-05-31 | 1999-01-05 | Hewlett-Packard Company | Runtime processor detection and installation of highly tuned processor specific routines |
| US5748875A (en) | 1996-06-12 | 1998-05-05 | Simpod, Inc. | Digital logic simulation/emulation system |
| US6031992A (en) | 1996-07-05 | 2000-02-29 | Transmeta Corporation | Combining hardware and software to provide an improved microprocessor |
| US5693956A (en) * | 1996-07-29 | 1997-12-02 | Motorola | Inverted oleds on hard plastic substrate |
| US5832205A (en) | 1996-08-20 | 1998-11-03 | Transmeta Corporation | Memory controller for a microprocessor for detecting a failure of speculation on the physical nature of a component being addressed |
| US5889990A (en) | 1996-11-05 | 1999-03-30 | Sun Microsystems, Inc. | Information appliance software architecture with replaceable service module providing abstraction function between system library and platform specific OS |
| US6006022A (en) | 1996-11-15 | 1999-12-21 | Microsystem Synthesis, Inc. | Cross-linked development and deployment apparatus and method |
| US6028996A (en) | 1997-03-18 | 2000-02-22 | Ati Technologies, Inc. | Method and apparatus for virtualizing system operation |
| US6075938A (en) | 1997-06-10 | 2000-06-13 | The Board Of Trustees Of The Leland Stanford Junior University | Virtual machine monitors for scalable multiprocessors |
| US6058466A (en) * | 1997-06-24 | 2000-05-02 | Sun Microsystems, Inc. | System for allocation of execution resources amongst multiple executing processes |
| US6321323B1 (en) | 1997-06-27 | 2001-11-20 | Sun Microsystems, Inc. | System and method for executing platform-independent code on a co-processor |
| US5995736A (en) | 1997-07-24 | 1999-11-30 | Ati Technologies, Inc. | Method and system for automatically modelling registers for integrated circuit design |
| US6078736A (en) | 1997-08-28 | 2000-06-20 | Xilinx, Inc. | Method of designing FPGAs for dynamically reconfigurable computing |
| US6269409B1 (en) | 1997-09-02 | 2001-07-31 | Lsi Logic Corporation | Method and apparatus for concurrent execution of operating systems |
| US5999730A (en) | 1997-10-27 | 1999-12-07 | Phoenix Technologies Limited | Generation of firmware code using a graphic representation |
| US6230307B1 (en) | 1998-01-26 | 2001-05-08 | Xilinx, Inc. | System and method for programming the hardware of field programmable gate arrays (FPGAs) and related reconfiguration resources as if they were software by creating hardware objects |
| US6052524A (en) | 1998-05-14 | 2000-04-18 | Software Development Systems, Inc. | System and method for simulation of integrated hardware and software components |
| US6496847B1 (en) | 1998-05-15 | 2002-12-17 | Vmware, Inc. | System and method for virtualizing computer systems |
| US6275893B1 (en) | 1998-09-14 | 2001-08-14 | Compaq Computer Corporation | Method and apparatus for providing seamless hooking and intercepting of selected kernel and HAL exported entry points in an operating system |
| EP0992916A1 (en) * | 1998-10-06 | 2000-04-12 | Texas Instruments Inc. | Digital signal processor |
| US6216216B1 (en) | 1998-10-07 | 2001-04-10 | Compaq Computer Corporation | Method and apparatus for providing processor partitioning on a multiprocessor machine |
| US6282633B1 (en) | 1998-11-13 | 2001-08-28 | Tensilica, Inc. | High data density RISC processor |
| US6477683B1 (en) | 1999-02-05 | 2002-11-05 | Tensilica, Inc. | Automated processor generation system for designing a configurable processor and method for the same |
| US6477697B1 (en) * | 1999-02-05 | 2002-11-05 | Tensilica, Inc. | Adding complex instruction extensions defined in a standardized language to a microprocessor design to produce a configurable definition of a target instruction set, and hdl description of circuitry necessary to implement the instruction set, and development and verification tools for the instruction set |
| US6295571B1 (en) | 1999-03-19 | 2001-09-25 | Times N Systems, Inc. | Shared memory apparatus and method for multiprocessor systems |
| US6385757B1 (en) * | 1999-08-20 | 2002-05-07 | Hewlett-Packard Company | Auto design of VLIW processors |
| US6640238B1 (en) * | 1999-08-31 | 2003-10-28 | Accenture Llp | Activity component in a presentation services patterns environment |
| US6415379B1 (en) | 1999-10-13 | 2002-07-02 | Transmeta Corporation | Method and apparatus for maintaining context while executing translated instructions |
| US6615167B1 (en) | 2000-01-31 | 2003-09-02 | International Business Machines Corporation | Processor-independent system-on-chip verification for embedded processor systems |
-
2000
- 2000-02-17 US US09/506,502 patent/US7036106B1/en not_active Expired - Lifetime
-
2001
- 2001-02-15 CN CNB018052401A patent/CN1288585C/zh not_active Expired - Lifetime
- 2001-02-15 KR KR1020027010522A patent/KR100589744B1/ko not_active IP Right Cessation
- 2001-02-15 JP JP2001560891A patent/JP4619606B2/ja not_active Expired - Fee Related
- 2001-02-15 WO PCT/US2001/005051 patent/WO2001061576A2/en active Search and Examination
- 2001-02-15 AU AU2001238403A patent/AU2001238403A1/en not_active Abandoned
- 2001-02-15 GB GB0217221A patent/GB2376546B/en not_active Expired - Fee Related
- 2001-05-11 TW TW090103671A patent/TW571206B/zh not_active IP Right Cessation
-
2005
- 2005-11-16 US US11/281,217 patent/US7437700B2/en not_active Expired - Lifetime
-
2008
- 2008-10-09 US US12/248,890 patent/US8161432B2/en not_active Expired - Lifetime
- 2008-10-09 US US12/248,883 patent/US9582278B2/en active Active
Cited By (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN100389419C (zh) * | 2004-12-11 | 2008-05-21 | 鸿富锦精密工业（深圳）有限公司 | 系统设定档案储存系统及方法 |
| CN102144167A (zh) * | 2008-08-20 | 2011-08-03 | 国立大学法人九州工业大学 | 生成装置、生成方法以及程序 |
| CN108920232A (zh) * | 2018-06-20 | 2018-11-30 | 维沃移动通信有限公司 | 一种目标对象的处理方法及终端设备 |
| CN109101239A (zh) * | 2018-08-30 | 2018-12-28 | 杭州电子科技大学 | 一种在线Verilog代码自动判决系统的标准答案生成方法 |
| CN111523283A (zh) * | 2020-04-16 | 2020-08-11 | 北京百度网讯科技有限公司 | 一种验证处理器的方法、装置、电子设备及存储介质 |
| CN111523283B (zh) * | 2020-04-16 | 2023-05-26 | 北京百度网讯科技有限公司 | 一种验证处理器的方法、装置、电子设备及存储介质 |
Also Published As
| Publication number | Publication date |
|---|---|
| CN1288585C (zh) | 2006-12-06 |
| GB0217221D0 (en) | 2002-09-04 |
| US7437700B2 (en) | 2008-10-14 |
| JP2004502990A (ja) | 2004-01-29 |
| US8161432B2 (en) | 2012-04-17 |
| US9582278B2 (en) | 2017-02-28 |
| TW571206B (en) | 2004-01-11 |
| WO2001061576A3 (en) | 2003-03-27 |
| KR100589744B1 (ko) | 2006-06-15 |
| GB2376546B (en) | 2004-08-04 |
| JP4619606B2 (ja) | 2011-01-26 |
| US7036106B1 (en) | 2006-04-25 |
| US20060101369A1 (en) | 2006-05-11 |
| US20090172630A1 (en) | 2009-07-02 |
| US20090177876A1 (en) | 2009-07-09 |
| GB2376546A (en) | 2002-12-18 |
| WO2001061576A2 (en) | 2001-08-23 |
| AU2001238403A1 (en) | 2001-08-27 |
| KR20030016226A (ko) | 2003-02-26 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN1288585C (zh) | 用于设计可配置处理器的自动处理器生成系统及方法 | |
| Marwedel et al. | Code generation for embedded processors | |
| CN100338568C (zh) | 开发片上系统用的开发环境的生成方法 | |
| CN1308818C (zh) | 用于结构仿真的系统 | |
| CN1666202A (zh) | 管理集成电路设计的装置和方法 | |
| CN1728153A (zh) | 支持配置实体的选择性表示的配置说明语言的方法和系统 | |
| Yoshimura et al. | An instruction mapping scheme for FU array accelerator | |
| Malazgirt et al. | Application specific multi-port memory customization in FPGAs | |
| Mishra et al. | Architecture description language (ADL)-driven software toolkit generation for architectural exploration of programmable SOCs | |
| CN1103467C (zh) | 宏指令集对称式并行体系结构微处理器 | |
| Abderazek et al. | Design and Architecture for an Embedded 32-bit QueueCore | |
| CN1223934C (zh) | 处理超长指令控制体系的方法 | |
| Hohenauer et al. | C Compilers for ASIPs | |
| Strozek et al. | Efficient architectures through application clustering and architectural heterogeneity | |
| Skarman et al. | Spade: An HDL Inspired by Modern Software Languages | |
| Hartenstein | Data-stream-based computing: Models and architectural resources | |
| Oh et al. | Architectural Design Issues in a Clockless 32‐Bit Processor Using an Asynchronous HDL | |
| Fiorito et al. | Truefloat: A templatized arithmetic library for hls floating-point operators | |
| Liebig et al. | High-level synthesis of resource-shared microarchitectures from irregular complex c-code | |
| Karthihaa et al. | Design and implementation of VLIW DSP processors for high ended embedded based systems | |
| Qiu et al. | FDRA: A Framework for a Dynamically Reconfigurable Accelerator Supporting Multi-Level Parallelism | |
| Teng | Design of 6-Stage Pipeline Processor | |
| Li | Synthesis Techniques for Power-Efficient Integrated Circuits | |
| Zhang et al. | Trilobite: A Natural Modeling Framework for Processor Design Automation System | |
| Xiao et al. | An Adaptive Instruction Set Encoding Automatic Generation Method for VLIW |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| C06 | Publication | ||
| PB01 | Publication | ||
| C10 | Entry into substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| C14 | Grant of patent or utility model | ||
| GR01 | Patent grant | ||
| CX01 | Expiry of patent term | ||
| CX01 | Expiry of patent term |
Granted publication date: 20061206 |