From bb5a91adcea09861bc5bc18fa70e621b51d44fb3 Mon Sep 17 00:00:00 2001 From: Litvinov Mikhail Date: Mon, 13 Jan 2025 01:04:33 +0300 Subject: [PATCH 01/11] Scheduling revamped (ver. 1). --- .../dfcir/include/dfcir/DFCIROpInterfaces.td | 84 ++- .../dfcir/include/dfcir/DFCIROperations.td | 405 ++++++++------ .../include/dfcir/conversions/DFCIRPasses.h | 11 +- .../include/dfcir/conversions/DFCIRPasses.td | 20 +- .../dfcir/conversions/DFCIRPassesUtils.h | 143 ++--- .../dfcir/conversions/ModuleDefines.inc | 41 ++ src/model/dfcir/lib/dfcir/DFCIROperations.cpp | 48 ++ .../conversions/DFCIRASAPSchedulerPass.cpp | 54 +- .../conversions/DFCIRLinearSchedulerPass.cpp | 48 +- .../dfcir/conversions/DFCIRPassesUtils.cpp | 498 +++++++----------- .../dfcir/conversions/DFCIRToFIRRTLPass.cpp | 484 ++++++++--------- .../conversions/FIRRTLStubsGeneratorPass.cpp | 3 +- src/model/dfcxx/include/dfcxx/typedefs.h | 6 +- src/model/dfcxx/lib/dfcxx/converter.cpp | 14 +- src/options.h | 26 +- 15 files changed, 994 insertions(+), 891 deletions(-) create mode 100644 src/model/dfcir/include/dfcir/conversions/ModuleDefines.inc diff --git a/src/model/dfcir/include/dfcir/DFCIROpInterfaces.td b/src/model/dfcir/include/dfcir/DFCIROpInterfaces.td index 9f5cf93..06f6e54 100644 --- a/src/model/dfcir/include/dfcir/DFCIROpInterfaces.td +++ b/src/model/dfcir/include/dfcir/DFCIROpInterfaces.td @@ -12,13 +12,91 @@ include "mlir/IR/OpBase.td" def NamedOpVal : OpInterface<"NamedOpVal"> { + let cppNamespace = "mlir::dfcir"; + + let methods = [ + InterfaceMethod< + "Get the value name", + "llvm::StringRef", + "getValueName", + (ins), + /*methodBody=*/[{ return $_op.getName(); }], + /*defaultImplementation=*/[{}] + > + ]; +} + +def InputOutputOpInterface : OpInterface<"InputOutputOpInterface"> { + let cppNamespace = "mlir::dfcir"; +} + +def InputOpInterface : OpInterface<"InputOpInterface", [InputOutputOpInterface]> { + let cppNamespace = "mlir::dfcir"; +} + +def OutputOpInterface : OpInterface<"OutputOpInterface", [InputOutputOpInterface]> { + let cppNamespace = "mlir::dfcir"; +} + +def NaryOpInterface : OpInterface<"NaryOpInterface"> { + let cppNamespace = "mlir::dfcir"; +} + +def UnaryOpInterface : OpInterface<"UnaryOpInterface", [NaryOpInterface]> { + let cppNamespace = "mlir::dfcir"; +} + +def BinaryOpInterface : OpInterface<"BinaryOpInterface", [NaryOpInterface]> { + let cppNamespace = "mlir::dfcir"; +} + +def ShiftOpInterface : OpInterface<"ShiftOpInterface"> { + let cppNamespace = "mlir::dfcir"; +} +def Scheduled : OpInterface<"Scheduled"> { let cppNamespace = "mlir::dfcir"; let methods = [ - InterfaceMethod<"Get the value name", - "llvm::StringRef", "getValueName", (ins), - /*methodBody=*/[{ return $_op.getName(); }]> + InterfaceMethod< + "Get clock latency (or -1 if not set).", + "int32_t", + "getLatency", + (ins), + /*methodBody=*/[{ + return static_cast(getLatencyAttr(impl, $_op).getSInt()); + }], + /*defaultImplementation=*/[{}] + >, + InterfaceMethod< + "Get clock latency as an attribute.", + "mlir::IntegerAttr", + "getLatencyAttr", + (ins), + /*methodBody=*/[{ return $_op.getLatencyAttr(); }], + /*defaultImplementation=*/[{}] + >, + InterfaceMethod< + "Set clock latency (-1 means it is not set).", + "void", + "setLatency", + (ins "int32_t":$latency), + /*methodBody=*/[{ + auto attr = + mlir::IntegerAttr::get(IntegerType::get($_op.getContext(), 32), + latency); + return setLatencyAttr(impl, $_op, attr); + }], + /*defaultImplementation=*/[{}] + >, + InterfaceMethod< + "Set clock latency as an attribute.", + "void", + "setLatencyAttr", + (ins "mlir::IntegerAttr":$latency), + /*methodBody=*/[{ return $_op.setLatencyAttr(latency); }], + /*defaultImplementation=*/[{}] + > ]; } diff --git a/src/model/dfcir/include/dfcir/DFCIROperations.td b/src/model/dfcir/include/dfcir/DFCIROperations.td index 1254eef..6e24387 100644 --- a/src/model/dfcir/include/dfcir/DFCIROperations.td +++ b/src/model/dfcir/include/dfcir/DFCIROperations.td @@ -35,7 +35,7 @@ def KernelOp : DFCIR_Op<"kernel", } def ScalarInputOp : DFCIR_Op<"scalarInput", - [DeclareOpInterfaceMethods]> { + [DeclareOpInterfaceMethods, DeclareOpInterfaceMethods]> { let arguments = (ins StrAttr:$name ); @@ -50,7 +50,7 @@ def ScalarInputOp : DFCIR_Op<"scalarInput", } def ScalarOutputOp : DFCIR_Op<"scalarOutput", - [DeclareOpInterfaceMethods]> { + [DeclareOpInterfaceMethods, DeclareOpInterfaceMethods]> { let arguments = (ins StrAttr:$name, Optional:$stream @@ -66,7 +66,7 @@ def ScalarOutputOp : DFCIR_Op<"scalarOutput", } def InputOp : DFCIR_Op<"input", - [DeclareOpInterfaceMethods]> { + [DeclareOpInterfaceMethods, DeclareOpInterfaceMethods]> { let arguments = (ins StrAttr:$name, Optional:$ctrl @@ -82,7 +82,7 @@ def InputOp : DFCIR_Op<"input", } def OutputOp : DFCIR_Op<"output", - [AttrSizedOperandSegments, DeclareOpInterfaceMethods]> { + [AttrSizedOperandSegments, DeclareOpInterfaceMethods, DeclareOpInterfaceMethods]> { let arguments = (ins StrAttr:$name, Optional:$ctrl, @@ -98,6 +98,15 @@ def OutputOp : DFCIR_Op<"output", }]; } +def ConstantOp : DFCIR_Op<"constant", []> { + let arguments = (ins AnyAttrOf<[Builtin_IntegerAttr, + Builtin_FloatAttr]>:$value); + + let hasCustomAssemblyFormat = 1; + + let results = (outs Const:$res); +} + def ConnectOp : DFCIR_Op<"connect", []> { let arguments = (ins Variable:$dest, @@ -107,234 +116,322 @@ def ConnectOp : DFCIR_Op<"connect", []> { let assemblyFormat = "`(` $dest `:` type($dest) `,` $src `:` type($src) `)` attr-dict"; } -def OffsetOp : DFCIR_Op<"offset", []> { - let arguments = (ins - Stream:$stream, - Builtin_IntegerAttr:$offset - ); +def CastOp : DFCIR_Op<"cast", []> { + let arguments = (ins CastVariable:$var); - let hasCustomAssemblyFormat = 1; + let assemblyFormat = "`<` type($res) `>` `(` $var `:` type($var) `)` attr-dict"; - let results = (outs Stream:$res); + let results = (outs CastVariable:$res); } -def ConvertOp : DFCIR_Op<"convert", []> { - let arguments = (ins ConvertVariable:$var); - - let assemblyFormat = "`(` $var `:` type($var) `)` attr-dict `:` type($res)"; - - let results = (outs Stream:$res); -} +def LatencyOp : DFCIR_Op<"latency", []> { + let summary = "Sets a clock latency for the input."; -def MuxOp : DFCIR_Op<"mux", []> { let arguments = (ins - Stream:$control, - Variadic:$vars + Variable:$input, + Builtin_IntegerAttr:$latency ); - let hasCustomAssemblyFormat = 1; - let results = (outs Variable:$res); -} -def LessOp : DFCIR_Op<"less", []> { - let arguments = (ins - Variable:$first, - Variable:$second - ); - - let assemblyFormat = "`(` $first `:` type($first) `,` $second `:` type($second)`)` attr-dict `:` type($res)"; - - let results = (outs Variable:$res); + let hasCustomAssemblyFormat = 1; } -def LessEqOp : DFCIR_Op<"lessEq", []> { +class DFCIR_UnaryOp traits = []> : + DFCIR_Op, DeclareOpInterfaceMethods]> { let arguments = (ins - Variable:$first, - Variable:$second + firstType:$first, + Builtin_IntegerAttr:$latency ); - let assemblyFormat = "`(` $first `:` type($first) `,` $second `:` type($second)`)` attr-dict `:` type($res)"; - - let results = (outs Variable:$res); -} + let results = (outs resultType:$res); + + let builders = [ + OpBuilder<(ins + "Type":$res, + "Value":$first, + CArg<"int32_t", "-1">:$latency + ), [{ + auto attr = + mlir::IntegerAttr::get(IntegerType::get($_builder.getContext(), 32), + latency); + build($_builder, $_state, res, first, attr); + }]> + ]; -def GreaterOp : DFCIR_Op<"greater", []> { - let arguments = (ins - Variable:$first, - Variable:$second - ); + let extraClassDeclaration = [{ + int32_t getValueName(); + }]; - let assemblyFormat = "`(` $first `:` type($first) `,` $second `:` type($second)`)` attr-dict `:` type($res)"; + let hasCustomAssemblyFormat = 1; - let results = (outs Variable:$res); + let extraClassDefinition = [{ + ParseResult $cppClass::parse(OpAsmParser &parser, OperationState &result) { + IntegerAttr latencyAttr; + OpAsmParser::UnresolvedOperand firstRawOperands[1]; + llvm::ArrayRef firstOperands(firstRawOperands); + llvm::SMLoc firstOperandsLoc; + Type firstRawTypes[1]; + llvm::ArrayRef firstTypes(firstRawTypes); + Type resRawTypes[1]; + llvm::ArrayRef resTypes(resRawTypes); + if (parser.parseLSquare()) { + return failure(); + } + + llvm::SMLoc latencyLoc = parser.getCurrentLocation(); + if (auto noQuestion = parser.parseOptionalQuestion()) { + auto noAttr = parser.parseCustomAttributeWithFallback(latencyAttr, Type{}) || + !latencyAttr; + // !XOR(A, B) <=> A == B. + if (bool(noQuestion) == bool(noAttr)) { + return parser.emitError(latencyLoc) << "'" << result.name.getStringRef() << + "' op requires either '?' or valid latency specified"; + } + } else { + latencyAttr = + IntegerAttr::get(IntegerType::get(parser.getContext(), 32), -1); + } + + result.getOrAddProperties().latency = latencyAttr; + + if (parser.parseRSquare() || + parser.parseLParen()) { + return failure(); + } + + firstOperandsLoc = parser.getCurrentLocation(); + if (parser.parseOperand(firstRawOperands[0]) || + parser.parseColon() || + parser.parseCustomTypeWithFallback(firstRawTypes[0]) || + parser.parseRParen() || + parser.parseColon() || + parser.parseCustomTypeWithFallback(resRawTypes[0]) || + parser.parseOptionalAttrDict(result.attributes)) { + return failure(); + } + result.addTypes(resTypes); + if (parser.resolveOperands(firstOperands, firstTypes, firstOperandsLoc, result.operands)) { + return failure(); + } + return success(); + } + + void $cppClass::print(OpAsmPrinter &printer) { + printer << "["; + auto latencyInt = static_cast(getLatency().getSInt()); + if (latencyInt == -1) { + printer << "?"; + } else { + printer << getLatency(); + } + printer << "] ("; + printer << getFirst() << " : " << getFirst().getType() << ") : "; + printer << getRes().getType(); + llvm::SmallVector elidedAttrs; + printer.printOptionalAttrDict((*this)->getAttrs(), elidedAttrs); + } + }]; } -def GreaterEqOp : DFCIR_Op<"greaterEq", []> { - let arguments = (ins - Variable:$first, - Variable:$second - ); +def NotOp : DFCIR_UnaryOp<"not", Variable, Variable, [SameOperandsAndResultType]>; - let assemblyFormat = "`(` $first `:` type($first) `,` $second `:` type($second)`)` attr-dict `:` type($res)"; +def NegOp : DFCIR_UnaryOp<"neg", Variable, Variable, [SameOperandsAndResultType]>; - let results = (outs Variable:$res); -} - -def EqOp : DFCIR_Op<"eq", []> { +class DFCIR_BinaryOp traits = []> : + DFCIR_Op, DeclareOpInterfaceMethods]> { let arguments = (ins - Variable:$first, - Variable:$second + firstType:$first, + secondType:$second, + Builtin_IntegerAttr:$latency ); - let assemblyFormat = "`(` $first `:` type($first) `,` $second `:` type($second)`)` attr-dict `:` type($res)"; + let results = (outs resultType:$res); + + let builders = [ + OpBuilder<(ins + "Type":$res, + "Value":$first, + "Value":$second, + CArg<"int32_t", "-1">:$latency + ), [{ + auto attr = + mlir::IntegerAttr::get(IntegerType::get($_builder.getContext(), 32), + latency); + build($_builder, $_state, res, first, second, attr); + }]> + ]; - let results = (outs Variable:$res); -} - -def NotEqOp : DFCIR_Op<"notEq", []> { - let arguments = (ins - Variable:$first, - Variable:$second - ); + let extraClassDeclaration = [{ + int32_t getValueName(); + }]; - let assemblyFormat = "`(` $first `:` type($first) `,` $second `:` type($second)`)` attr-dict `:` type($res)"; + let hasCustomAssemblyFormat = 1; - let results = (outs Variable:$res); + let extraClassDefinition = [{ + ParseResult $cppClass::parse(OpAsmParser &parser, OperationState &result) { + IntegerAttr latencyAttr; + OpAsmParser::UnresolvedOperand firstRawOperands[1]; + llvm::ArrayRef firstOperands(firstRawOperands); + llvm::SMLoc firstOperandsLoc; + Type firstRawTypes[1]; + llvm::ArrayRef firstTypes(firstRawTypes); + OpAsmParser::UnresolvedOperand secondRawOperands[1]; + llvm::ArrayRef secondOperands(secondRawOperands); + llvm::SMLoc secondOperandsLoc; + Type secondRawTypes[1]; + llvm::ArrayRef secondTypes(secondRawTypes); + Type resRawTypes[1]; + llvm::ArrayRef resTypes(resRawTypes); + if (parser.parseLSquare()) { + return failure(); + } + + llvm::SMLoc latencyLoc = parser.getCurrentLocation(); + if (auto noQuestion = parser.parseOptionalQuestion()) { + auto noAttr = parser.parseCustomAttributeWithFallback(latencyAttr, Type{}) || + !latencyAttr; + // !XOR(A, B) <=> A == B. + if (bool(noQuestion) == bool(noAttr)) { + return parser.emitError(latencyLoc) << "'" << result.name.getStringRef() << + "' op requires either '?' or valid latency specified"; + } + } else { + latencyAttr = + IntegerAttr::get(IntegerType::get(parser.getContext(), 32), -1); + } + + result.getOrAddProperties().latency = latencyAttr; + + if (parser.parseRSquare() || + parser.parseLParen()) { + return failure(); + } + + firstOperandsLoc = parser.getCurrentLocation(); + if (parser.parseOperand(firstRawOperands[0]) || + parser.parseColon() || + parser.parseCustomTypeWithFallback(firstRawTypes[0]) || + parser.parseComma()) { + return failure(); + } + + secondOperandsLoc = parser.getCurrentLocation(); + if (parser.parseOperand(secondRawOperands[0]) || + parser.parseColon() || + parser.parseCustomTypeWithFallback(secondRawTypes[0]) || + parser.parseRParen() || + parser.parseColon() || + parser.parseCustomTypeWithFallback(resRawTypes[0]) || + parser.parseOptionalAttrDict(result.attributes)) { + return failure(); + } + result.addTypes(resTypes); + if (parser.resolveOperands(firstOperands, firstTypes, firstOperandsLoc, result.operands) || + parser.resolveOperands(secondOperands, secondTypes, secondOperandsLoc, result.operands)) { + return failure(); + } + return success(); + } + + void $cppClass::print(OpAsmPrinter &printer) { + printer << "["; + auto latencyInt = static_cast(getLatency().getSInt()); + if (latencyInt == -1) { + printer << "?"; + } else { + printer << getLatency(); + } + printer << "] ("; + printer << getFirst() << " : " << getFirst().getType() << ", "; + printer << getSecond() << " : " << getSecond().getType() << ") : "; + printer << getRes().getType(); + llvm::SmallVector elidedAttrs; + printer.printOptionalAttrDict((*this)->getAttrs(), elidedAttrs); + } + }]; } -def AndOp : DFCIR_Op<"and", []> { +def OffsetOp : DFCIR_Op<"offset", []> { let arguments = (ins - Variable:$first, - Variable:$second + Stream:$stream, + Builtin_IntegerAttr:$offset ); - let assemblyFormat = "`(` $first `:` type($first) `,` $second `:` type($second)`)` attr-dict `:` type($res)"; + let hasCustomAssemblyFormat = 1; - let results = (outs Variable:$res); + let results = (outs Stream:$res); } -def OrOp : DFCIR_Op<"or", []> { - let arguments = (ins - Variable:$first, - Variable:$second - ); +def ConvertOp : DFCIR_Op<"convert", []> { + let arguments = (ins ConvertVariable:$var); - let assemblyFormat = "`(` $first `:` type($first) `,` $second `:` type($second)`)` attr-dict `:` type($res)"; + let assemblyFormat = "`(` $var `:` type($var) `)` attr-dict `:` type($res)"; - let results = (outs Variable:$res); + let results = (outs Stream:$res); } -def XorOp : DFCIR_Op<"xor", []> { +def MuxOp : DFCIR_Op<"mux", []> { let arguments = (ins - Variable:$first, - Variable:$second + Stream:$control, + Variadic:$vars ); - let assemblyFormat = "`(` $first `:` type($first) `,` $second `:` type($second)`)` attr-dict `:` type($res)"; - - let results = (outs Variable:$res); -} - -def NotOp : DFCIR_Op<"not", [SameOperandsAndResultType, ]> { - let arguments = (ins Variable:$first); - - let assemblyFormat = "`(` $first `:` type($first) `)` attr-dict `:` type($res)"; + let hasCustomAssemblyFormat = 1; let results = (outs Variable:$res); } -def NegOp : DFCIR_Op<"neg", [SameOperandsAndResultType, ]> { - let arguments = (ins Variable:$first); - - let assemblyFormat = "`(` $first `:` type($first) `)` attr-dict `:` type($res)"; - - let results = (outs Variable:$res); -} +def LessOp : DFCIR_BinaryOp<"less", Variable, Variable, Variable, []>; -def AddOp : DFCIR_Op<"add", []> { - let arguments = (ins - Variable:$first, - Variable:$second - ); +def LessEqOp : DFCIR_BinaryOp<"lessEq", Variable, Variable, Variable, []>; - let assemblyFormat = "`(` $first `:` type($first) `,` $second `:` type($second)`)` attr-dict `:` type($res)"; +def GreaterOp : DFCIR_BinaryOp<"greater", Variable, Variable, Variable, []>; - let results = (outs Variable:$res); -} +def GreaterEqOp : DFCIR_BinaryOp<"greaterEq", Variable, Variable, Variable, []>; -def SubOp : DFCIR_Op<"sub", []> { - let arguments = (ins - Variable:$first, - Variable:$second - ); +def EqOp : DFCIR_BinaryOp<"eq", Variable, Variable, Variable, []>; - let assemblyFormat = "`(` $first `:` type($first) `,` $second `:` type($second)`)` attr-dict `:` type($res)"; +def NotEqOp : DFCIR_BinaryOp<"notEq", Variable, Variable, Variable, []>; - let results = (outs Variable:$res); -} +def AndOp : DFCIR_BinaryOp<"and", Variable, Variable, Variable, []>; -def MulOp : DFCIR_Op<"mul", []> { - let arguments = (ins - Variable:$first, - Variable:$second - ); +def OrOp : DFCIR_BinaryOp<"or", Variable, Variable, Variable, []>; - let assemblyFormat = "`(` $first `:` type($first) `,` $second `:` type($second)`)` attr-dict `:` type($res)"; +def XorOp : DFCIR_BinaryOp<"xor", Variable, Variable, Variable, []>; - let results = (outs Variable:$res); -} +def AddOp : DFCIR_BinaryOp<"add", Variable, Variable, Variable, []>; -def DivOp : DFCIR_Op<"div", []> { - let arguments = (ins - Variable:$first, - Variable:$second - ); +def SubOp : DFCIR_BinaryOp<"sub", Variable, Variable, Variable, []>; - let assemblyFormat = "`(` $first `:` type($first) `,` $second `:` type($second)`)` attr-dict `:` type($res)"; +def MulOp : DFCIR_BinaryOp<"mul", Variable, Variable, Variable, []>; - let results = (outs Variable:$res); -} +def DivOp : DFCIR_BinaryOp<"div", Variable, Variable, Variable, []>; -def ShiftLeftOp : DFCIR_Op<"shl", []> { +def ShiftLeftOp : DFCIR_Op<"shl", [DeclareOpInterfaceMethods]> { let arguments = (ins Variable:$first, Builtin_IntegerAttr:$bits ); - let assemblyFormat = "`(` $first `:` type($first) `,` $bits `)` attr-dict `:` type($res)"; + let assemblyFormat = "`(` $first `:` type($first) `,` $bits `)` `:` type($res) attr-dict"; let results = (outs Variable:$res); } -def ShiftRightOp : DFCIR_Op<"shr", []> { +def ShiftRightOp : DFCIR_Op<"shr", [DeclareOpInterfaceMethods]> { let arguments = (ins Variable:$first, Builtin_IntegerAttr:$bits ); - let assemblyFormat = "`(` $first `:` type($first) `,` $bits `)` attr-dict `:` type($res)"; + let assemblyFormat = "`(` $first `:` type($first) `,` $bits `)` `:` type($res) attr-dict"; let results = (outs Variable:$res); } -def ConstantOp : DFCIR_Op<"constant", []> { - let arguments = (ins AnyAttrOf<[Builtin_IntegerAttr, - Builtin_FloatAttr]>:$value); - - let hasCustomAssemblyFormat = 1; - - let results = (outs Const:$res); -} - -def CastOp : DFCIR_Op<"cast", []> { - let arguments = (ins CastVariable:$var); - - let assemblyFormat = "`<` type($res) `>` `(` $var `:` type($var) `)` attr-dict"; - - let results = (outs CastVariable:$res); -} - // Issue #12 (https://github.com/ispras/utopia-hls/issues/12). // Type system rework required. diff --git a/src/model/dfcir/include/dfcir/conversions/DFCIRPasses.h b/src/model/dfcir/include/dfcir/conversions/DFCIRPasses.h index 086ab44..d5f40bc 100644 --- a/src/model/dfcir/include/dfcir/conversions/DFCIRPasses.h +++ b/src/model/dfcir/include/dfcir/conversions/DFCIRPasses.h @@ -60,18 +60,21 @@ enum Ops { } // namespace mlir::dfcir -typedef std::unordered_map LatencyConfig; +struct LatencyConfig { + std::unordered_map internalOps; + std::unordered_map externalOps; +}; namespace mlir::dfcir { using std::unique_ptr; using mlir::Pass; -unique_ptr createDFCIRToFIRRTLPass(LatencyConfig *config); +unique_ptr createDFCIRToFIRRTLPass(); -unique_ptr createDFCIRASAPSchedulerPass(); +unique_ptr createDFCIRASAPSchedulerPass(LatencyConfig *config); -unique_ptr createDFCIRLinearSchedulerPass(); +unique_ptr createDFCIRLinearSchedulerPass(LatencyConfig *config); unique_ptr createFIRRTLStubGeneratorPass(llvm::raw_ostream *stream); diff --git a/src/model/dfcir/include/dfcir/conversions/DFCIRPasses.td b/src/model/dfcir/include/dfcir/conversions/DFCIRPasses.td index dda21fb..c45d150 100644 --- a/src/model/dfcir/include/dfcir/conversions/DFCIRPasses.td +++ b/src/model/dfcir/include/dfcir/conversions/DFCIRPasses.td @@ -14,6 +14,12 @@ include "mlir/Pass/PassBase.td" def DFCIRToFIRRTLPass: Pass<"dfcir-to-firrtl-pass", "mlir::ModuleOp"> { let summary = "Lower DFCIR entities to FIRRTL entities."; + let constructor = "mlir::dfcir::createDFCIRToFIRRTLPass()"; +} + +def DFCIRASAPSchedulerPass: Pass<"dfcir-asap-scheduler-pass", "mlir::ModuleOp"> { + let summary = "Schedule operations with a greedy as-soon-as-possible algorithm."; + let options = [ Option<"latencyConfig", "latencyConfig", @@ -22,18 +28,20 @@ def DFCIRToFIRRTLPass: Pass<"dfcir-to-firrtl-pass", "mlir::ModuleOp"> { "Latency configuration for operations."> ]; - let constructor = "mlir::dfcir::createDFCIRToFIRRTLPass()"; -} - -def DFCIRASAPSchedulerPass: Pass<"dfcir-asap-scheduler-pass", "mlir::ModuleOp"> { - let summary = "Schedule operations with a greedy as-soon-as-possible algorithm."; - let constructor = "mlir::dfcir::createDFCIRASAPSchedulerPass()"; } def DFCIRLinearSchedulerPass: Pass<"dfcir-linear-scheduler-pass", "mlir::ModuleOp"> { let summary = "Schedule operations with linear programming algorithm."; + let options = [ + Option<"latencyConfig", + "latencyConfig", + "LatencyConfig *", + "nullptr", + "Latency configuration for operations."> + ]; + let constructor = "mlir::dfcir::createDFCIRLinearSchedulerPass()"; } diff --git a/src/model/dfcir/include/dfcir/conversions/DFCIRPassesUtils.h b/src/model/dfcir/include/dfcir/conversions/DFCIRPassesUtils.h index 8305633..be6e684 100644 --- a/src/model/dfcir/include/dfcir/conversions/DFCIRPassesUtils.h +++ b/src/model/dfcir/include/dfcir/conversions/DFCIRPassesUtils.h @@ -9,98 +9,24 @@ #ifndef DFCIR_PASSES_UTILS_H #define DFCIR_PASSES_UTILS_H -#include "circt/Dialect/FIRRTL/FIRRTLDialect.h" -#include "circt/Dialect/FIRRTL/FIRRTLOps.h" #include "dfcir/conversions/DFCIRPasses.h" #include "dfcir/DFCIROperations.h" #include "mlir/IR/Iterators.h" #include "mlir/Transforms/DialectConversion.h" #include +#include #include -// Module names for operations. -#define ADD_MODULE "__ADD" -#define SUB_MODULE "__SUB" -#define MUL_MODULE "__MUL" -#define DIV_MODULE "__DIV" -#define NEG_MODULE "__NEG" - -#define AND_MODULE "__AND" -#define OR_MODULE "__OR" -#define XOR_MODULE "__XOR" -#define NOT_MODULE "__NOT" - -#define LESS_MODULE "__LESS" -#define LESSEQ_MODULE "__LESSEQ" -#define GREATER_MODULE "__GREATER" -#define GREATEREQ_MODULE "__GREATEREQ" -#define EQ_MODULE "__EQ" -#define NEQ_MODULE "__NEQ" - -// Specification names for operation's types. -#define FLOAT_SPEC "FLOAT" -#define INT_SPEC "INT" -#define UINT_SPEC "UINT" -#define SINT_SPEC "SINT" - -// Utility definitions. -#define BUF_MODULE "__FIFO" -#define STAGES_PARAM "stages" -#define CLOCK_ARG "clk" - -#define TYPE_SIZE_PARAM "size" -#define INSTANCE_LATENCY_ATTR "__latency" -#define CONNECT_OFFSET_ATTR "__offset" - namespace mlir::dfcir::utils { struct Node; struct Channel; struct Graph; } // namespace mlir::dfcir::utils -typedef std::unordered_map Latencies; -typedef std::unordered_map Buffers; +typedef std::unordered_map Buffers; typedef std::unordered_map ModuleArgMap; -namespace circt::firrtl::utils { - -template -inline CircuitOp findCircuit(const OpTy &op) { - return op->template getParentOfType(); -} - -inline FExtModuleOp createBufferModule(OpBuilder &builder, - llvm::StringRef name, Type type, - Location loc, unsigned stages); - -inline FExtModuleOp createBufferModuleWithTypeName(OpBuilder &builder, - Type type, Location loc, - unsigned stages); - -FExtModuleOp findOrCreateBufferModule(OpBuilder &builder, Type type, - Location loc, unsigned stages); - -bool isAStartWire(Operation *op); - -std::pair unrollConnectChain(Value value); - -Value getBlockArgument(Block *block, unsigned ind); - -Value getBlockArgumentFromOpBlock(Operation *op, unsigned ind); - -Value getClockVar(Block *block); - -Value getClockVarFromOpBlock(Operation *op); - -ConnectOp createConnect(OpBuilder &builder, Value destination, Value source, - int offset = 0); - -int getConnectOffset(ConnectOp connect); - -int setConnectOffset(ConnectOp connect, int offset); -} // namespace circt::firrtl::utils - namespace mlir::utils { template @@ -122,12 +48,9 @@ namespace mlir::dfcir::utils { struct Node { Operation *op; - unsigned latency; - bool isConst; - long argInd; + int32_t latency; - explicit Node(Operation *op, unsigned latency = 0, - bool isConst = false, long argInd = -1); + explicit Node(Operation *op, int32_t latency = -1); Node(); @@ -139,17 +62,15 @@ struct Node { }; struct Channel { - Node source; - Node target; - Value val; - unsigned valInd; - Operation *connectOp; - int offset; + Node *source; + Node *target; + int8_t valInd; + int32_t offset; - Channel(Node source, Node target, Value val, unsigned valInd, - Operation *connectOp, int offset = 0); + Channel(Node *source, Node *target, + int8_t valInd, int32_t offset = 0); - Channel(); + Channel() = default; Channel(const Channel &) = default; @@ -165,7 +86,7 @@ struct std::hash { using Node = mlir::dfcir::utils::Node; size_t operator()(const Node &node) const noexcept { - return std::hash()(node.op) + node.argInd; + return std::hash()(node.op); } }; @@ -175,37 +96,47 @@ struct std::hash { using Channel = mlir::dfcir::utils::Channel; size_t operator()(const Channel &channel) const noexcept { - return std::hash()(channel.target) + 13 + channel.valInd; + return std::hash()(channel.target) + 13 + channel.valInd; } }; namespace mlir::dfcir::utils { -struct Graph { - using FModuleOp = circt::firrtl::FModuleOp; - using CircuitOp = circt::firrtl::CircuitOp; +class Graph { using StringRef = llvm::StringRef; - std::unordered_set nodes; - std::unordered_set startNodes; - std::unordered_map> inputs; - std::unordered_map> outputs; +public: + std::unordered_set nodes; + std::unordered_set channels; - explicit Graph(); + std::unordered_set startNodes; + std::unordered_map> inputs; + std::unordered_map> outputs; - auto findNode(const std::pair &connectInfo); + explicit Graph() = default; - explicit Graph(FModuleOp module); + ~Graph(); - explicit Graph(CircuitOp circuit, StringRef name = StringRef()); + auto findNode(Operation *op); - explicit Graph(ModuleOp op, StringRef name = StringRef()); + auto findNode(const Value &val); + + explicit Graph(KernelOp kernel); + + explicit Graph(ModuleOp module); + + void applyConfig(const LatencyConfig &cfg); + +private: + template + void process(Op &op); }; -void insertBuffer(OpBuilder &builder, circt::firrtl::InstanceOp buf, - const Channel &channel); +void insertBuffer(OpBuilder &builder, Channel *channel); void insertBuffers(mlir::MLIRContext &ctx, const Buffers &buffers); +Ops resolveInternalOpType(mlir::Operation *op); + } // namespace mlir::dfcir::utils #endif // DFCIR_PASSES_UTILS_H diff --git a/src/model/dfcir/include/dfcir/conversions/ModuleDefines.inc b/src/model/dfcir/include/dfcir/conversions/ModuleDefines.inc new file mode 100644 index 0000000..bb621d1 --- /dev/null +++ b/src/model/dfcir/include/dfcir/conversions/ModuleDefines.inc @@ -0,0 +1,41 @@ +//===----------------------------------------------------------------------===// +// +// Part of the Utopia HLS Project, under the Apache License v2.0 +// SPDX-License-Identifier: Apache-2.0 +// Copyright 2024 ISP RAS (http://www.ispras.ru) +// +//===----------------------------------------------------------------------===// + +// Module names for operations. +#define ADD_MODULE "__ADD" +#define SUB_MODULE "__SUB" +#define MUL_MODULE "__MUL" +#define DIV_MODULE "__DIV" +#define NEG_MODULE "__NEG" + +#define AND_MODULE "__AND" +#define OR_MODULE "__OR" +#define XOR_MODULE "__XOR" +#define NOT_MODULE "__NOT" + +#define LESS_MODULE "__LESS" +#define LESSEQ_MODULE "__LESSEQ" +#define GREATER_MODULE "__GREATER" +#define GREATEREQ_MODULE "__GREATEREQ" +#define EQ_MODULE "__EQ" +#define NEQ_MODULE "__NEQ" + +// Specification names for operation's types. +#define FLOAT_SPEC "FLOAT" +#define INT_SPEC "INT" +#define UINT_SPEC "UINT" +#define SINT_SPEC "SINT" + +// Utility definitions. +#define BUF_MODULE "__FIFO" +#define STAGES_PARAM "stages" +#define CLOCK_ARG "clk" + +#define TYPE_SIZE_PARAM "size" +#define INSTANCE_LATENCY_ATTR "__latency" +#define CONNECT_OFFSET_ATTR "__offset" diff --git a/src/model/dfcir/lib/dfcir/DFCIROperations.cpp b/src/model/dfcir/lib/dfcir/DFCIROperations.cpp index 93938ce..1e9d6d8 100644 --- a/src/model/dfcir/lib/dfcir/DFCIROperations.cpp +++ b/src/model/dfcir/lib/dfcir/DFCIROperations.cpp @@ -422,6 +422,54 @@ void mlir::dfcir::OffsetOp::print(OpAsmPrinter &printer) { printer << " : " << getRes().getType(); } +ParseResult LatencyOp::parse(OpAsmParser &parser, OperationState &result) { + IntegerAttr latencyAttr; + OpAsmParser::UnresolvedOperand inputRawOperands[1]; + llvm::ArrayRef inputOperands(inputRawOperands); + llvm::SMLoc inputOperandsLoc; + Type inputRawTypes[1]; + llvm::ArrayRef inputTypes(inputRawTypes); + Type resRawTypes[1]; + llvm::ArrayRef resTypes(resRawTypes); + if (parser.parseLSquare() || + parser.parseCustomAttributeWithFallback(latencyAttr, Type{})) { + return failure(); + } + + if (latencyAttr) { + result.getOrAddProperties().latency = latencyAttr; + } + + if (parser.parseRSquare() || + parser.parseLParen()) { + return failure(); + } + + inputOperandsLoc = parser.getCurrentLocation(); + if (parser.parseOperand(inputRawOperands[0]) || + parser.parseColon() || + parser.parseCustomTypeWithFallback(inputRawTypes[0]) || + parser.parseRParen() || + parser.parseColon() || + parser.parseCustomTypeWithFallback(resRawTypes[0]) || + parser.parseOptionalAttrDict(result.attributes)) { + return failure(); + } + result.addTypes(resTypes); + if (parser.resolveOperands(inputOperands, inputTypes, inputOperandsLoc, result.operands)) { + return failure(); + } + return success(); +} + +void LatencyOp::print(OpAsmPrinter &printer) { + printer << "[" << getLatency() << "] ("; + printer << getInput() << " : " << getInput().getType() << ") : "; + printer << getRes().getType(); + llvm::SmallVector elidedAttrs; + printer.printOptionalAttrDict((*this)->getAttrs(), elidedAttrs); +} + } // namespace mlir::dfcir #define GET_OP_CLASSES diff --git a/src/model/dfcir/lib/dfcir/conversions/DFCIRASAPSchedulerPass.cpp b/src/model/dfcir/lib/dfcir/conversions/DFCIRASAPSchedulerPass.cpp index 10a0396..4813dcd 100644 --- a/src/model/dfcir/lib/dfcir/conversions/DFCIRASAPSchedulerPass.cpp +++ b/src/model/dfcir/lib/dfcir/conversions/DFCIRASAPSchedulerPass.cpp @@ -21,6 +21,8 @@ namespace mlir::dfcir { #include "dfcir/conversions/DFCIRPasses.h.inc" +typedef std::unordered_map Latencies; + class DFCIRASAPSchedulerPass : public impl::DFCIRASAPSchedulerPassBase { using Node = utils::Node; @@ -34,9 +36,9 @@ class DFCIRASAPSchedulerPass public: explicit ChannelComp(Latencies &map) : map(map) {} - bool operator()(const Channel &lhs, const Channel &rhs) const { - return map[lhs.source] + int(lhs.source.latency) + lhs.offset < - map[rhs.source] + int(rhs.source.latency) + rhs.offset; + bool operator()(Channel *lhs, const Channel *rhs) const { + return map[lhs->source] + lhs->source->latency + lhs->offset < + map[rhs->source] + rhs->source->latency + rhs->offset; } }; @@ -44,43 +46,43 @@ class DFCIRASAPSchedulerPass Buffers schedule(Graph &graph) { Latencies map; using ChannelQueue = - std::priority_queue, ChannelComp>; + std::priority_queue, ChannelComp>; ChannelQueue chanQueue((ChannelComp(map))); auto visitChannel = - [&](const Channel &channel) { - map[channel.target] = std::max(map[channel.target], - map[channel.source] + - int(channel.source.latency) + - channel.offset); + [&](Channel *channel) { + map[channel->target] = std::max(map[channel->target], + map[channel->source] + + channel->source->latency + + channel->offset); }; - auto visitNode = [&](const Node &node) { - for (const Channel &out: graph.outputs[node]) { + auto visitNode = [&](Node *node) { + for (Channel *out: graph.outputs[node]) { chanQueue.push(out); visitChannel(out); } }; - for (const Node &node: graph.startNodes) { + for (Node *node: graph.startNodes) { visitNode(node); } while (!chanQueue.empty()) { - Node outNode = chanQueue.top().target; + Node *outNode = chanQueue.top()->target; chanQueue.pop(); visitNode(outNode); } Buffers buffers; - for (const Node &node: graph.nodes) { - for (const Channel &channel: graph.inputs[node]) { - int delta = map[channel.target] - - (map[channel.source] + - int(channel.source.latency) + - channel.offset); - if (!channel.source.isConst && delta) { + for (Node *node: graph.nodes) { + for (Channel *channel: graph.inputs[node]) { + int32_t delta = map[channel->target] - + (map[channel->source] + + channel->source->latency + + channel->offset); + if (delta) { buffers[channel] = delta; } } @@ -89,10 +91,16 @@ class DFCIRASAPSchedulerPass } public: + explicit DFCIRASAPSchedulerPass(const DFCIRASAPSchedulerPassOptions &options) + : impl::DFCIRASAPSchedulerPassBase(options) {} + void runOnOperation() override { // Convert kernel into graph. Graph graph(llvm::dyn_cast(getOperation())); + // Apply latency config to the graph. + graph.applyConfig(*latencyConfig); + // Execute scheduler. auto buffers = schedule(graph); @@ -101,8 +109,10 @@ class DFCIRASAPSchedulerPass } }; -std::unique_ptr createDFCIRASAPSchedulerPass() { - return std::make_unique(); +std::unique_ptr createDFCIRASAPSchedulerPass(LatencyConfig *config) { + DFCIRASAPSchedulerPassOptions options; + options.latencyConfig = config; + return std::make_unique(options); } } // namespace mlir::dfcir diff --git a/src/model/dfcir/lib/dfcir/conversions/DFCIRLinearSchedulerPass.cpp b/src/model/dfcir/lib/dfcir/conversions/DFCIRLinearSchedulerPass.cpp index bfd14bf..78dca84 100644 --- a/src/model/dfcir/lib/dfcir/conversions/DFCIRLinearSchedulerPass.cpp +++ b/src/model/dfcir/lib/dfcir/conversions/DFCIRLinearSchedulerPass.cpp @@ -37,7 +37,7 @@ class DFCIRLinearSchedulerPass using Status = utils::lp::Status; private: - void synchronizeInput(const Node &node) { + void synchronizeInput(Node *node) { int *var = new int[1]{nodeMap[node]}; double *coeff = new double[1]{1.0}; @@ -45,19 +45,19 @@ class DFCIRLinearSchedulerPass problem.addConstraint(1, var, coeff, OpType::Equal, 0); } - void addLatencyConstraint(const Channel &chan) { - int *vars = new int[2]{nodeMap[chan.target], nodeMap[chan.source]}; + void addLatencyConstraint(Channel *chan) { + int *vars = new int[2]{nodeMap[chan->target], nodeMap[chan->source]}; double *coeffs = new double[2]{1.0, -1.0}; // t_next >= t_prev + prev_latency + next_prev_offset problem.addConstraint(2, vars, coeffs, OpType::GreaterOrEqual, - int(chan.source.latency) + chan.offset); + int(chan->source->latency) + chan->offset); } - int addDeltaConstraint(const Channel &chan) { + int addDeltaConstraint(Channel *chan) { int deltaID = problem.addVariable(); - int *vars = new int[3]{deltaID, nodeMap[chan.target], - nodeMap[chan.source]}; + int *vars = new int[3]{deltaID, nodeMap[chan->target], + nodeMap[chan->source]}; double *coeffs = new double[3]{1.0, -1.0, 1.0}; // delta_t = t_next - t_prev @@ -65,17 +65,17 @@ class DFCIRLinearSchedulerPass return deltaID; } - void addBufferConstraint(const Channel &chan) { + void addBufferConstraint(Channel *chan) { int bufID = problem.addVariable(); bufMap[chan] = bufID; int *vars = new int[3]{bufID, - nodeMap[chan.target], - nodeMap[chan.source]}; + nodeMap[chan->target], + nodeMap[chan->source]}; double *coeffs = new double[3]{1.0, -1.0, 1.0}; // buf_next_prev = t_next - (t_prev + prev_latency + next_prev_offset) problem.addConstraint(3, vars, coeffs, OpType::Equal, - -1.0 * (int(chan.source.latency) + chan.offset)); + -1.0 * (int(chan->source->latency) + chan->offset)); // buf_next_prev >= 0 problem.addConstraint(1, new int[1]{bufID}, new double[1]{1.0}, @@ -83,12 +83,12 @@ class DFCIRLinearSchedulerPass } LPProblem problem; - std::unordered_map nodeMap; - std::unordered_map bufMap; + std::unordered_map nodeMap; + std::unordered_map bufMap; Buffers schedule(Graph &graph) { size_t chanCount = 0; - for (const Node &node: graph.nodes) { + for (Node *node: graph.nodes) { chanCount += graph.inputs[node].size(); nodeMap[node] = problem.addVariable(); if (graph.startNodes.find(node) != graph.startNodes.end()) { @@ -99,8 +99,8 @@ class DFCIRLinearSchedulerPass int *deltaIDs = new int[chanCount]; double *deltaCoeffs = new double[chanCount]; int curr_id = 0; - for (const Node &node: graph.nodes) { - for (const Channel &chan: graph.inputs[node]) { + for (Node *node: graph.nodes) { + for (Channel *chan: graph.inputs[node]) { addLatencyConstraint(chan); deltaCoeffs[curr_id] = 1.0; deltaIDs[curr_id++] = addDeltaConstraint(chan); @@ -121,8 +121,8 @@ class DFCIRLinearSchedulerPass problem.getResults(&result); for (const auto &[chan, id]: bufMap) { // lp_solve positions start with 1. - int latency = result[id - 1]; - if (!chan.source.isConst && latency) { + int32_t latency = result[id - 1]; + if (latency) { buffers[chan] = latency; } } @@ -139,10 +139,16 @@ class DFCIRLinearSchedulerPass } public: + explicit DFCIRLinearSchedulerPass(const DFCIRLinearSchedulerPassOptions &options) + : impl::DFCIRLinearSchedulerPassBase(options) {} + void runOnOperation() override { // Convert kernel into graph. Graph graph(llvm::dyn_cast(getOperation())); + // Apply latency config to the graph. + graph.applyConfig(*latencyConfig); + // Execute scheduler. auto buffers = schedule(graph); @@ -151,8 +157,10 @@ class DFCIRLinearSchedulerPass } }; -std::unique_ptr createDFCIRLinearSchedulerPass() { - return std::make_unique(); +std::unique_ptr createDFCIRLinearSchedulerPass(LatencyConfig *config) { + DFCIRLinearSchedulerPassOptions options; + options.latencyConfig = config; + return std::make_unique(options); } } // namespace mlir::dfcir diff --git a/src/model/dfcir/lib/dfcir/conversions/DFCIRPassesUtils.cpp b/src/model/dfcir/lib/dfcir/conversions/DFCIRPassesUtils.cpp index d19c236..f98f924 100644 --- a/src/model/dfcir/lib/dfcir/conversions/DFCIRPassesUtils.cpp +++ b/src/model/dfcir/lib/dfcir/conversions/DFCIRPassesUtils.cpp @@ -10,349 +10,259 @@ #include "circt/Dialect/FIRRTL/FIRRTLInstanceGraph.h" -namespace circt::firrtl::utils { - -inline FExtModuleOp createBufferModule(OpBuilder &builder, - llvm::StringRef name, Type type, - Location loc, unsigned stages) { - SmallVector ports = { - circt::firrtl::PortInfo( - mlir::StringAttr::get(builder.getContext(), "res1"), - type, - circt::firrtl::Direction::Out), - circt::firrtl::PortInfo( - mlir::StringAttr::get(builder.getContext(), "arg1"), - type, - circt::firrtl::Direction::In), - circt::firrtl::PortInfo( - mlir::StringAttr::get(builder.getContext(), "clk"), - circt::firrtl::ClockType::get(builder.getContext()), - circt::firrtl::Direction::In) - }; - auto typeWidth = - circt::firrtl::getBitWidth(llvm::dyn_cast(type)); - assert(typeWidth.has_value()); - IntegerType attrType = mlir::IntegerType::get(builder.getContext(), 32, - mlir::IntegerType::Unsigned); - auto module = builder.create( - loc, - mlir::StringAttr::get(builder.getContext(), name), - circt::firrtl::ConventionAttr::get(builder.getContext(), - Convention::Internal), - ports, - StringRef(name), - mlir::ArrayAttr()); - module->setAttr(INSTANCE_LATENCY_ATTR, - mlir::IntegerAttr::get(attrType, stages)); - return module; -} - -inline FExtModuleOp createBufferModuleWithTypeName(OpBuilder &builder, - Type type, Location loc, - unsigned stages) { - using circt::firrtl::getBitWidth; - using circt::firrtl::FIRRTLBaseType; - - std::string name = BUF_MODULE; - llvm::raw_string_ostream nameStream(name); - auto width = getBitWidth(llvm::dyn_cast(type)); - assert(width.has_value()); - nameStream << "_IN_" << *width << "_OUT_" << *width << "_" << stages; - return createBufferModule(builder, name, type, loc, stages); -} - -FExtModuleOp findOrCreateBufferModule(OpBuilder &builder, Type type, - Location loc, unsigned stages) { - using circt::firrtl::getBitWidth; - using circt::firrtl::FIRRTLBaseType; - - CircuitOp circuit = findCircuit(builder.getInsertionPoint()); - Block *block = circuit.getBodyBlock(); - std::string name = BUF_MODULE; - llvm::raw_string_ostream nameStream(name); - auto width = getBitWidth(llvm::dyn_cast(type)); - assert(width.has_value()); - nameStream << "_IN_" << *width << "_OUT_" << *width << "_" << stages; - - auto begin = block->op_begin(); - auto end = block->op_end(); - for (auto op = begin; op != end; ++op) { - if ((*op).getModuleName() == name) { - return *op; - } - } - auto save = builder.saveInsertionPoint(); - builder.setInsertionPointToStart(block); - FExtModuleOp result = createBufferModuleWithTypeName(builder, type, - loc, stages); - builder.restoreInsertionPoint(save); - return result; -} -bool isAStartWire(Operation *op) { - auto casted = llvm::dyn_cast(op); - if (!casted) return false; - for (const auto &val: op->getUses()) { - auto found = llvm::dyn_cast(val.getOwner()); - if (found && found.getDest() == casted.getResult()) return false; - } - return true; -} +namespace mlir::dfcir::utils { -std::pair unrollConnectChain(Value value) { - Value cur_val = value; - Operation *connect_op = nullptr; +std::pair findNearestNodeValue(Value value) { + Value curVal = value; + int32_t offsetSum = 0; bool flag; do { flag = false; - for (const auto &operand: cur_val.getUses()) { - auto found = llvm::dyn_cast(operand.getOwner()); - if (found && found.getDest() == operand.get()) { - cur_val = found.getSrc(); - if (!connect_op) { - connect_op = found.getOperation(); - } + + for (const auto &operand: curVal.getUses()) { + auto possConnect = llvm::dyn_cast(operand.getOwner()); + if (!possConnect) { continue; } + if (possConnect.getDest() == operand.get()) { + curVal = possConnect.getSrc(); flag = true; + break; } } + + if (!flag) { + auto possOffset = llvm::dyn_cast(curVal.getDefiningOp()); + if (possOffset) { + offsetSum += static_cast(possOffset.getOffset().getInt()); + curVal = possOffset.getStream(); + flag = true; + } + } + } while (flag); - return std::make_pair(cur_val, connect_op); -} -Value getBlockArgument(Block *block, unsigned ind) { - return block->getArgument(ind); + return std::make_pair(curVal, offsetSum); } -Value getBlockArgumentFromOpBlock(Operation *op, unsigned ind) { - return getBlockArgument(op->getBlock(), ind); -} +Node::Node(Operation *op, int32_t latency) : op(op), latency(latency) {} -Value getClockVar(Block *block) { - Value arg = getBlockArgument(block, block->getNumArguments() - 1); - if (arg.getType().isa()) { - return arg; - } - return nullptr; +Node::Node() : Node(nullptr) {} + +bool Node::operator==(const Node &node) const { + return this->op == node.op; } -Value getClockVarFromOpBlock(Operation *op) { - return getClockVar(op->getBlock()); +Channel::Channel(Node *source, Node *target, + int8_t valInd, int32_t offset) : + source(source), target(target), + valInd(valInd), offset(offset) {} + +bool Channel::operator==(const Channel &channel) const { + return this->source == channel.source && + this->target == channel.target && + this->valInd == channel.valInd; } -ConnectOp createConnect(OpBuilder &builder, Value destination, - Value source, int offset) { - auto connect = builder.create(builder.getUnknownLoc(), - destination, source); - connect->setAttr(CONNECT_OFFSET_ATTR, builder.getI32IntegerAttr(offset)); - return connect; +Graph::~Graph() { + for (Node *node: nodes) { + delete node; + } + + for (Channel *channel: channels) { + delete channel; + } } -int getConnectOffset(ConnectOp connect) { - return (connect && connect->hasAttr(CONNECT_OFFSET_ATTR)) - ? connect->getAttr(CONNECT_OFFSET_ATTR).cast().getInt() - : 0; +auto Graph::findNode(Operation *op) { + return std::find_if(nodes.begin(), nodes.end(), + [&](Node *n) { + return n->op == op; + }); } -int setConnectOffset(ConnectOp connect, int offset) { - connect->setAttr( - CONNECT_OFFSET_ATTR, - mlir::IntegerAttr::get(mlir::IntegerType::get(connect.getContext(), 32, - mlir::IntegerType::Signed), - offset)); - return getConnectOffset(connect); +auto Graph::findNode(const Value &val) { + return std::find_if(nodes.begin(), nodes.end(), + [&](Node *n) { + return n->op == val.getDefiningOp(); + }); } -} // namespace circt::firrtl::utils +void Graph::applyConfig(const LatencyConfig &cfg) { + for (Node *node: nodes) { + auto casted = llvm::dyn_cast(node->op); + if (!casted) { continue; } -namespace mlir::dfcir::utils { + Ops opType = resolveInternalOpType(node->op); -Node::Node(Operation *op, unsigned latency, - bool isConst, long argInd) : op(op), latency(latency), - isConst(isConst), argInd(argInd) {} + auto found = cfg.internalOps.find(opType); -Node::Node() : Node(nullptr) {} + int32_t latency = (found != cfg.internalOps.end()) ? + (*found).second : + 1; + + casted.setLatency(latency); -bool Node::operator==(const Node &node) const { - return this->op == node.op && this->latency == node.latency && - this->isConst == node.isConst && this->argInd == node.argInd; + node->latency = latency; + } } -Channel::Channel(Node source, Node target, Value val, - unsigned valInd, Operation *connectOp, - int offset) : source(source), target(target), - val(val), valInd(valInd), - connectOp(connectOp), offset(offset) {} - -Channel::Channel() : source(), target(), val(), - valInd(0), connectOp(nullptr), offset(0) {} +template <> +void Graph::process(InputOutputOpInterface &op) { + Node *newNode = new Node(op, 0); + nodes.insert(newNode); + if (llvm::isa(op.getOperation())) { + startNodes.insert(newNode); + } +} -bool Channel::operator==(const Channel &channel) const { - return this->source == channel.source && this->target == channel.target && - this->val == channel.val && this->valInd == channel.valInd; +template <> +void Graph::process(ConstantOp &op) { + Node *newNode = new Node(op, 0); + nodes.insert(newNode); + startNodes.insert(newNode); } -Graph::Graph() { - nodes = std::unordered_set(); - startNodes = std::unordered_set(); - inputs = std::unordered_map>(); - outputs = std::unordered_map>(); +template <> +void Graph::process(MuxOp &op) { + Node *newNode = new Node(op, 0); + nodes.insert(newNode); + + for (size_t i = 0; i < op.getNumOperands(); ++i) { + auto operand = op.getOperand(i); + auto unrolledInfo = findNearestNodeValue(operand); + auto srcNode = findNode(unrolledInfo.first); + Channel *newChannel = new Channel(*srcNode, newNode, i, unrolledInfo.second); + channels.insert(newChannel); + outputs[*srcNode].insert(newChannel); + inputs[newNode].insert(newChannel); + } } -auto Graph::findNode(const std::pair &connectInfo) { - bool isArg = connectInfo.first.isa(); - const Value &val = connectInfo.first; - return std::find_if(nodes.begin(), nodes.end(), - [&](const Node &n) { - if (isArg) { - return n.argInd == val.cast().getArgNumber(); - } else { - return n.op == val.getDefiningOp(); - } - }); +template <> +void Graph::process(ConnectOp &op) { + if (!llvm::isa(op.getDest().getDefiningOp())) { return; } + auto unrolledInfo = findNearestNodeValue(op.getSrc()); + auto srcNode = findNode(unrolledInfo.first); + auto dstNode = findNode(op); + Channel *newChannel = new Channel(*srcNode, *dstNode, 0, unrolledInfo.second); + channels.insert(newChannel); + outputs[*srcNode].insert(newChannel); + inputs[*dstNode].insert(newChannel); } -Graph::Graph(FModuleOp module) : Graph() { - using circt::firrtl::ClockType; - using circt::firrtl::InstanceOp; - using circt::firrtl::ConnectOp; - using circt::firrtl::MultibitMuxOp; - using circt::firrtl::ConstantOp; - using circt::firrtl::ShlPrimOp; - using circt::firrtl::ShrPrimOp; - using circt::firrtl::utils::isAStartWire; - using circt::firrtl::utils::getConnectOffset; - using circt::firrtl::utils::unrollConnectChain; - using circt::firrtl::InstanceGraph; - - assert(module); - InstanceGraph instanceGraph(module->getParentOp()); - - for (BlockArgument arg: module.getArguments()) { - if (!(arg.getType().isa())) { - Node newNode(nullptr, 0, false, arg.getArgNumber()); - nodes.insert(newNode); - if (module.getPortDirection(arg.getArgNumber()) == - circt::firrtl::Direction::In) { - startNodes.insert(newNode); - } - } +template <> +void Graph::process(NaryOpInterface &op) { + Node *newNode = new Node(op, -1); + nodes.insert(newNode); + + Operation *opPtr = op.getOperation(); + + for (size_t i = 0; i < opPtr->getNumOperands(); ++i) { + auto operand = opPtr->getOperand(i); + auto unrolledInfo = findNearestNodeValue(operand); + auto srcNode = findNode(unrolledInfo.first); + Channel *newChannel = new Channel(*srcNode, newNode, i, unrolledInfo.second); + channels.insert(newChannel); + outputs[*srcNode].insert(newChannel); + inputs[newNode].insert(newChannel); } +} - for (Operation &op: module.getBodyBlock()->getOperations()) { - if (auto constOp = llvm::dyn_cast(&op)) { - Node newNode(constOp, 0, true); - nodes.insert(newNode); - startNodes.insert(newNode); - } else if (auto muxOp = llvm::dyn_cast(&op)) { - Node newNode(muxOp); - nodes.insert(newNode); - for (size_t index = 0, count = muxOp.getOperands().size(); - index < count; - ++index) { - auto operand = muxOp.getOperand(index); - if (!llvm::isa(operand.getType())) { - auto connectInfo = unrollConnectChain(operand); - - auto found = findNode(connectInfo); - - if (found == nodes.end()) continue; - Channel newChan(*found, newNode, operand, - index, connectInfo.second, 0); - outputs[*found].insert(newChan); - inputs[newNode].insert(newChan); - } - } - } else if (auto instanceOp = llvm::dyn_cast(&op)) { - auto instModule = instanceOp.getReferencedModule(instanceGraph); - unsigned latency = - instModule->getAttr(INSTANCE_LATENCY_ATTR) - .cast().getUInt(); - Node newNode(instanceOp, latency); - nodes.insert(newNode); - auto directions = instanceOp.getPortDirections(); - for (size_t index = 0, count = instanceOp.getResults().size(); - index < count; - ++index) { - auto operand = instanceOp.getResult(index); - if (!directions[index] && !(operand.getType().isa())) { - auto connectInfo = unrollConnectChain(operand); - - auto found = findNode(connectInfo); - - if (found == nodes.end()) continue; - int connectOffset = - getConnectOffset(llvm::cast(connectInfo.second)); - Channel newChan(*found, newNode, operand, index, - connectInfo.second, connectOffset); - outputs[*found].insert(newChan); - inputs[newNode].insert(newChan); - } - } - } else if (llvm::isa(&op)) { - Node newNode(&op); - nodes.insert(newNode); - auto operand = op.getOperand(0); - auto connectInfo = unrollConnectChain(operand); - auto found = findNode(connectInfo); - if (found == nodes.end()) continue; - Channel newChan(*found, newNode, operand, - 0, connectInfo.second, 0); - outputs[*found].insert(newChan); - inputs[newNode].insert(newChan); +template <> +void Graph::process(ShiftOpInterface &op) { + Node *newNode = new Node(op, 0); + nodes.insert(newNode); + + Operation *opPtr = op.getOperation(); + + auto operand = opPtr->getOperand(0); + auto unrolledInfo = findNearestNodeValue(operand); + auto srcNode = findNode(unrolledInfo.first); + Channel *newChannel = new Channel(*srcNode, newNode, 0, unrolledInfo.second); + outputs[*srcNode].insert(newChannel); + inputs[newNode].insert(newChannel); +} + +Graph::Graph(KernelOp kernel) : Graph() { + + for (Operation &op: kernel.getBody().front().getOperations()) { + if (auto casted = llvm::dyn_cast(&op)) { + process(casted); + } else if (auto casted = llvm::dyn_cast(&op)) { + process(casted); + } else if (auto casted = llvm::dyn_cast(&op)) { + process(casted); + } else if (auto casted = llvm::dyn_cast(&op)) { + process(casted); + } else if (auto casted = llvm::dyn_cast(&op)) { + process(casted); + } else if (auto casted = llvm::dyn_cast(&op)) { + process(casted); } } } -Graph::Graph(CircuitOp circuit, StringRef name) - : Graph(llvm::dyn_cast(circuit.lookupSymbol( - name.empty() - ? circuit.CircuitOp::getName() - : name))) {} - -Graph::Graph(ModuleOp op, StringRef name) - : Graph(mlir::utils::findFirstOccurence(op), name) {} - -void insertBuffer(OpBuilder &builder, circt::firrtl::InstanceOp buf, - const Channel &channel) { - using circt::firrtl::InstanceOp; - using circt::firrtl::ConnectOp; - using circt::firrtl::MultibitMuxOp; - using circt::firrtl::utils::createConnect; - using circt::firrtl::utils::getClockVarFromOpBlock; - assert(!channel.source.isConst); - - if (llvm::isa(channel.target.op)) { - ConnectOp castedConnect = llvm::dyn_cast(channel.connectOp); - // Take the original connectee operand and bind it to a newly created - // ConnectOp. - Value connecteeVal = castedConnect.getSrc(); - createConnect(builder, buf.getResult(1), connecteeVal); - createConnect(builder, buf.getResult(2), getClockVarFromOpBlock(buf)); - // Set the original connectee operand to the newly created ConnectOp's - // result. - castedConnect.setOperand(1, buf.getResult(0)); - } else if (auto muxOp = llvm::dyn_cast(channel.target.op)) { - // Just bind the newly created 'ConnectOp'. - createConnect(builder, buf.getResult(1), channel.val); - createConnect(builder, buf.getResult(2), getClockVarFromOpBlock(buf)); - muxOp.setOperand(channel.valInd, buf.getResult(0)); - } +Graph::Graph(ModuleOp module) + : Graph(mlir::utils::findFirstOccurence(module)) {} + + +void insertBuffer(OpBuilder &builder, Channel *channel) { + + builder.setInsertionPoint(channel->target->op); + auto value = channel->target->op->getOperand(channel->valInd); + + auto latencyOp = builder.create(builder.getUnknownLoc(), + value.getType(), value); + channel->target->op->setOperand(channel->valInd, latencyOp.getRes()); } void insertBuffers(mlir::MLIRContext &ctx, const Buffers &buffers) { - using circt::firrtl::InstanceOp; - using circt::firrtl::utils::findOrCreateBufferModule; OpBuilder builder(&ctx); for (auto &[channel, latency]: buffers) { - assert(!channel.source.isConst); - builder.setInsertionPoint(channel.target.op); - auto bufModule = findOrCreateBufferModule(builder, channel.val.getType(), - builder.getUnknownLoc(), latency); - auto instance = builder.create(builder.getUnknownLoc(), - bufModule, "placeholder"); - insertBuffer(builder, instance, channel); + insertBuffer(builder, channel); } } +Ops resolveInternalOpType(mlir::Operation *op) { + auto resultType = op->getResult(0).getType(); + auto dfType = llvm::dyn_cast(resultType).getDFType(); + bool isFloat = llvm::isa(dfType); + + if (llvm::isa(op)) { + return (isFloat) ? Ops::ADD_FLOAT : Ops::ADD_INT; + } else if (llvm::isa(op)) { + return (isFloat) ? Ops::SUB_FLOAT : Ops::SUB_INT; + } else if (llvm::isa(op)) { + return (isFloat) ? Ops::MUL_FLOAT : Ops::MUL_INT; + } else if (llvm::isa(op)) { + return (isFloat) ? Ops::DIV_FLOAT : Ops::DIV_INT; + } else if (llvm::isa(op)) { + return (isFloat) ? Ops::NEG_FLOAT : Ops::NEG_INT; + } else if (llvm::isa(op)) { + return (isFloat) ? Ops::AND_FLOAT : Ops::AND_INT; + } else if (llvm::isa(op)) { + return (isFloat) ? Ops::OR_FLOAT : Ops::OR_INT; + } else if (llvm::isa(op)) { + return (isFloat) ? Ops::XOR_FLOAT : Ops::XOR_INT; + } else if (llvm::isa(op)) { + return (isFloat) ? Ops::NOT_FLOAT : Ops::NOT_INT; + } else if (llvm::isa(op)) { + return (isFloat) ? Ops::LESS_FLOAT : Ops::LESS_INT; + } else if (llvm::isa(op)) { + return (isFloat) ? Ops::LESSEQ_FLOAT : Ops::LESSEQ_INT; + } else if (llvm::isa(op)) { + return (isFloat) ? Ops::GREATER_FLOAT : Ops::GREATER_INT; + } else if (llvm::isa(op)) { + return (isFloat) ? Ops::GREATEREQ_FLOAT : Ops::GREATEREQ_INT; + } else if (llvm::isa(op)) { + return (isFloat) ? Ops::EQ_FLOAT : Ops::EQ_INT; + } else if (llvm::isa(op)) { + return (isFloat) ? Ops::NEQ_FLOAT : Ops::NEQ_INT; + } + + assert(false && "Shouldn't reach this"); + return Ops::UNDEFINED; +} + } // namespace mlir::dfcir::utils \ No newline at end of file diff --git a/src/model/dfcir/lib/dfcir/conversions/DFCIRToFIRRTLPass.cpp b/src/model/dfcir/lib/dfcir/conversions/DFCIRToFIRRTLPass.cpp index e75a58c..897c629 100644 --- a/src/model/dfcir/lib/dfcir/conversions/DFCIRToFIRRTLPass.cpp +++ b/src/model/dfcir/lib/dfcir/conversions/DFCIRToFIRRTLPass.cpp @@ -16,6 +16,32 @@ #include "mlir/IR/Dialect.h" #include "mlir/Transforms/DialectConversion.h" +#include "dfcir/conversions/ModuleDefines.inc" + +namespace circt::firrtl::utils { + +Value getBlockArgument(Block *block, unsigned ind) { + return block->getArgument(ind); +} + +Value getBlockArgumentFromOpBlock(Operation *op, unsigned ind) { + return getBlockArgument(op->getBlock(), ind); +} + +Value getClockVar(Block *block) { + Value arg = getBlockArgument(block, block->getNumArguments() - 1); + if (arg.getType().isa()) { + return arg; + } + return nullptr; +} + +Value getClockVarFromOpBlock(Operation *op) { + return getClockVar(op->getBlock()); +} + +} // namespace circt::firrtl::utils + template <> struct std::hash> { size_t operator()( @@ -103,31 +129,25 @@ class FIRRTLOpConversionPattern : public OpConversionPattern { public: using OpConversionPattern::OpConversionPattern; using ConvertedOps = mlir::DenseSet; - using OffsetMap = - std::unordered_map, signed>; using OldTypeMap = std::unordered_map, mlir::Type>; +protected: mutable ConvertedOps *convertedOps; - const LatencyConfig *latencyConfig; - OffsetMap *offsetMap; // TODO: Change when replaceAllUsesWith-related // pull request for MLIR is approved. // Issue #17 (https://github.com/ispras/utopia-hls/issues/17). OldTypeMap *oldTypeMap; ModuleArgMap *moduleArgMap; +public: FIRRTLOpConversionPattern(MLIRContext *context, TypeConverter &typeConverter, ConvertedOps *convertedOps, - LatencyConfig *latencyConfig, - OffsetMap *offsetMap, OldTypeMap *oldTypeMap, ModuleArgMap *moduleArgMap) : OpConversionPattern(typeConverter, context), convertedOps(convertedOps), - latencyConfig(latencyConfig), - offsetMap(offsetMap), oldTypeMap(oldTypeMap), moduleArgMap(moduleArgMap) { // Required to allow root updates, which imply recursive @@ -149,7 +169,7 @@ class KernelOpConversionPattern : public FIRRTLOpConversionPattern { LogicalResult matchAndRewrite(KernelOp kernelOp, OpAdaptor adaptor, Rewriter &rewriter) const override { - Block *kernelBlock = &(kernelOp.getBodyRegion().getBlocks().front()); + Block *kernelBlock = &(kernelOp.getBody().front()); auto save = rewriter.saveInsertionPoint(); // Create a new circuit to substitute the kernel with. @@ -171,7 +191,7 @@ class KernelOpConversionPattern : public FIRRTLOpConversionPattern { modulePorts.emplace_back( mlir::StringAttr::get(getContext(), name), converted, - (llvm::isa(op)) + (llvm::isa(op)) ? circt::firrtl::Direction::In : circt::firrtl::Direction::Out); } @@ -251,16 +271,16 @@ class OutputOpConversionPattern : public FIRRTLOpConversionPattern { LogicalResult matchAndRewrite(OutputOp outputOp, OpAdaptor adaptor, Rewriter &rewriter) const override { - using circt::firrtl::utils::createConnect; using circt::firrtl::utils::getBlockArgumentFromOpBlock; // TODO: Add control stream functionality. // Issue #12 (https://github.com/ispras/utopia-hls/issues/12). if (outputOp.getStream()) { - createConnect(rewriter, - getBlockArgumentFromOpBlock(outputOp, - (*moduleArgMap)[outputOp]), - adaptor.getStream()); + rewriter.create( + rewriter.getUnknownLoc(), + getBlockArgumentFromOpBlock(outputOp, (*moduleArgMap)[outputOp]), + adaptor.getStream() + ); } rewriter.eraseOp(outputOp); return mlir::success(); @@ -277,16 +297,17 @@ class ScalarOutputOpConversionPattern LogicalResult matchAndRewrite(ScalarOutputOp scalarOutputOp, OpAdaptor adaptor, Rewriter &rewriter) const override { - using circt::firrtl::utils::createConnect; using circt::firrtl::utils::getBlockArgumentFromOpBlock; // TODO: Add control stream functionality. // Issue #12 (https://github.com/ispras/utopia-hls/issues/12). if (scalarOutputOp.getStream()) { - createConnect(rewriter, - getBlockArgumentFromOpBlock(scalarOutputOp, - (*moduleArgMap)[scalarOutputOp]), - adaptor.getStream()); + rewriter.create( + rewriter.getUnknownLoc(), + getBlockArgumentFromOpBlock(scalarOutputOp, + (*moduleArgMap)[scalarOutputOp]), + adaptor.getStream() + ); } rewriter.eraseOp(scalarOutputOp); return mlir::success(); @@ -331,10 +352,9 @@ class ConstantOpConversionPattern } }; -SmallVector getBinaryOpPorts(mlir::Type outType, - mlir::Type firstType, - mlir::Type secondType, - mlir::MLIRContext *ctx) { +SmallVector getUnaryOpPorts(mlir::Type outType, + mlir::Type firstType, + mlir::MLIRContext *ctx) { return SmallVector { circt::firrtl::PortInfo( mlir::StringAttr::get(ctx, "res1"), @@ -344,10 +364,6 @@ SmallVector getBinaryOpPorts(mlir::Type outType, mlir::StringAttr::get(ctx, "arg1"), firstType, circt::firrtl::Direction::In), - circt::firrtl::PortInfo( - mlir::StringAttr::get(ctx, "arg2"), - secondType, - circt::firrtl::Direction::In), circt::firrtl::PortInfo( mlir::StringAttr::get(ctx, "clk"), circt::firrtl::ClockType::get(ctx), @@ -355,9 +371,10 @@ SmallVector getBinaryOpPorts(mlir::Type outType, }; } -SmallVector getUnaryOpPorts(mlir::Type outType, - mlir::Type firstType, - mlir::MLIRContext *ctx) { +SmallVector getBinaryOpPorts(mlir::Type outType, + mlir::Type firstType, + mlir::Type secondType, + mlir::MLIRContext *ctx) { return SmallVector { circt::firrtl::PortInfo( mlir::StringAttr::get(ctx, "res1"), @@ -367,6 +384,10 @@ SmallVector getUnaryOpPorts(mlir::Type outType, mlir::StringAttr::get(ctx, "arg1"), firstType, circt::firrtl::Direction::In), + circt::firrtl::PortInfo( + mlir::StringAttr::get(ctx, "arg2"), + secondType, + circt::firrtl::Direction::In), circt::firrtl::PortInfo( mlir::StringAttr::get(ctx, "clk"), circt::firrtl::ClockType::get(ctx), @@ -374,61 +395,108 @@ SmallVector getUnaryOpPorts(mlir::Type outType, }; } -#define CAT(FIRST, SECOND) FIRST ## SECOND -#define CAT_E(FIRST, SECOND) CAT(FIRST, SECOND) - -#define GET_SCHED_OP_NAME(OP_NAME) \ -std::string name = CAT_E(OP_NAME,_MODULE); \ -llvm::raw_string_ostream nameStream(name); \ - \ -for (unsigned id = 0; id < op->getNumOperands(); ++id) { \ - nameStream << "_IN_"; \ - Type oldType = (*oldTypeMap)[std::make_pair(op, id)]; \ - Type innerType = llvm::cast(oldType).getDFType(); \ - llvm::cast(innerType).printSVSignature(nameStream); \ -} \ - \ -for (unsigned id = 0; id < op->getNumResults(); ++id) { \ - nameStream << "_OUT_"; \ - Type oldType = (*oldTypeMap)[std::make_pair(op, id)]; \ - Type innerType = llvm::cast(oldType).getDFType(); \ - llvm::cast(innerType).printSVSignature(nameStream); \ - bool isFloat = innerType.isa(); \ - if (isFloat) { \ - nameStream << "_" << latencyConfig->find(CAT_E(OP_NAME,_FLOAT))->second; \ - } else { \ - nameStream << "_" << latencyConfig->find(CAT_E(OP_NAME,_INT))->second; \ - } \ -} \ -return name; - -// Issue #12 (https://github.com/ispras/utopia-hls/issues/12). -#define GET_OP_SV_PARAMS(CTX, ATTR_TYPE, LATENCY, WIDTH) { } - template -class SchedulableOpConversionPattern { +class SchedulableOpConversionPattern + : public FIRRTLOpConversionPattern { using FExtModuleOp = circt::firrtl::FExtModuleOp; using InstanceOp = circt::firrtl::InstanceOp; using CircuitOp = circt::firrtl::CircuitOp; using Rewriter = ConversionPatternRewriter; virtual std::string - constructModuleName(const OperationType &op, AdaptorType &adaptor) const = 0; + getBaseModuleName() const = 0; + + virtual std::string + constructModuleName(OperationType &op, AdaptorType &adaptor) const { + std::string name = getBaseModuleName(); + llvm::raw_string_ostream nameStream(name); + + for (unsigned id = 0; id < op->getNumOperands(); ++id) { + nameStream << "_IN_"; + Type oldType = (*this->oldTypeMap)[std::make_pair(op, id)]; + Type innerType = llvm::cast(oldType).getDFType(); + llvm::cast(innerType).printSVSignature(nameStream); + } + + for (unsigned id = 0; id < op->getNumResults(); ++id) { + nameStream << "_OUT_"; + Type oldType = (*this->oldTypeMap)[std::make_pair(op, id)]; + Type innerType = llvm::cast(oldType).getDFType(); + llvm::cast(innerType).printSVSignature(nameStream); + nameStream << "_" << llvm::cast(op.getOperation()).getLatency(); + } + return name; + } virtual FExtModuleOp - createModule(const std::string &name, const OperationType &op, - AdaptorType &adaptor, Rewriter &rewriter) const = 0; + createModule(const std::string &name, OperationType &op, + AdaptorType &adaptor, Rewriter &rewriter) const { + Type type = op->getResult(0).getType(); + Type convertedType = this->getTypeConverter()->convertType(type); + + SmallVector ports; + auto adaptorOperands = adaptor.getOperands(); + if (op->getNumOperands() == 1) { + ports = getUnaryOpPorts(convertedType, + adaptorOperands[0].getType(), + rewriter.getContext()); + } else { + ports = getBinaryOpPorts(convertedType, + adaptorOperands[0].getType(), + adaptorOperands[1].getType(), + rewriter.getContext()); + } + + IntegerType attrType = mlir::IntegerType::get(rewriter.getContext(), 32, + mlir::IntegerType::Unsigned); + + int32_t latency = llvm::cast(op.getOperation()).getLatency(); + auto module = rewriter.create( + rewriter.getUnknownLoc(), + mlir::StringAttr::get(rewriter.getContext(), name), + circt::firrtl::ConventionAttr::get(rewriter.getContext(), + circt::firrtl::Convention::Internal), + ports, + StringRef(name)); + module->setAttr(INSTANCE_LATENCY_ATTR, + mlir::IntegerAttr::get(attrType, latency)); + return module; + } virtual void remapUses(OperationType &oldOp, AdaptorType &adaptor, - InstanceOp &newOp, Rewriter &rewriter) const = 0; + InstanceOp &newOp, Rewriter &rewriter) const { + using circt::firrtl::utils::getClockVarFromOpBlock; + + unsigned id = 1; + auto adaptorOperands = adaptor.getOperands(); + for (; id <= (newOp.getNumResults() - 2); ++id) { + rewriter.create( + rewriter.getUnknownLoc(), + newOp.getResult(id), + adaptorOperands[id - 1] + ); + } + rewriter.create( + rewriter.getUnknownLoc(), + newOp.getResult(id), + getClockVarFromOpBlock(newOp) + ); + + for (auto &operand: llvm::make_early_inc_range(oldOp.getRes().getUses())) { + (*this->oldTypeMap)[std::make_pair(operand.getOwner(), + operand.getOperandNumber())] = + operand.get().getType(); + operand.set(newOp.getResult(0)); + } + }; protected: - FExtModuleOp findOrCreateModule(const OperationType &op, + FExtModuleOp findOrCreateModule(OperationType &op, AdaptorType &adaptor, Rewriter &rewriter) const { std::string moduleName = constructModuleName(op, adaptor); - CircuitOp circuit = circt::firrtl::utils::findCircuit(op); + CircuitOp circuit = op->template getParentOfType(); auto foundModule = circuit.template lookupSymbol(moduleName); if (foundModule) return foundModule; @@ -440,90 +508,43 @@ class SchedulableOpConversionPattern { return newModule; } +public: + // Inherit existing constructor. + using FIRRTLOpConversionPattern::FIRRTLOpConversionPattern; + + LogicalResult matchAndRewrite(OperationType oldOp, AdaptorType adaptor, + Rewriter &rewriter) const override { + FExtModuleOp module = findOrCreateModule(oldOp, adaptor, rewriter); + + auto newOp = + rewriter.create(oldOp.getLoc(), module, "placeholder"); + remapUses(oldOp, adaptor, newOp, rewriter); + rewriter.eraseOp(oldOp); + return mlir::success(); + } + virtual ~SchedulableOpConversionPattern() = default; }; +#define CAT(FIRST, SECOND) FIRST ## SECOND +#define CAT_E(FIRST, SECOND) CAT(FIRST, SECOND) #define OP_CLASS(CLASS_PREF) CAT_E(CLASS_PREF, Op) -#define OP_CLASS_ADAPTOR(CLASS_REF) OP_CLASS(CLASS_REF)::Adaptor - -#define OP_CLASS_CONV_PATTERN(CLASS_PREF) CAT_E(OP_CLASS(CLASS_PREF),ConversionPattern) -#define SCHED_OP_CONV_PATTERN_SPEC(CLASS_PREF) OP_CLASS(CLASS_PREF) , OP_CLASS_ADAPTOR(CLASS_PREF) - -#define DECL_SCHED_BINARY_ARITH_OP_CONV_PATTERN(CLASS_PREF, OP_NAME) \ -class OP_CLASS_CONV_PATTERN(CLASS_PREF) \ - : public FIRRTLOpConversionPattern< OP_CLASS(CLASS_PREF) >, \ - SchedulableOpConversionPattern< SCHED_OP_CONV_PATTERN_SPEC(CLASS_PREF) > { \ -public: \ - using FIRRTLOpConversionPattern::FIRRTLOpConversionPattern; \ - using OpAdaptor = typename OP_CLASS_ADAPTOR(CLASS_PREF); \ - using FExtModuleOp = circt::firrtl::FExtModuleOp; \ - using InstanceOp = circt::firrtl::InstanceOp; \ - using IntType = circt::firrtl::IntType; \ - using Rewriter = ConversionPatternRewriter; \ - \ - std::string constructModuleName(const OP_CLASS(CLASS_PREF) &op, \ - OpAdaptor &adaptor) const override { \ - GET_SCHED_OP_NAME(OP_NAME) \ - } \ - \ - FExtModuleOp createModule(const std::string &name, \ - const OP_CLASS(CLASS_PREF) &op, \ - OpAdaptor &adaptor, \ - Rewriter &rewriter) const override { \ - Type type = op->getResult(0).getType(); \ - Type innerType = llvm::cast(type).getDFType(); \ - Type convertedType = getTypeConverter()->convertType(type); \ - auto ports = getBinaryOpPorts(convertedType, adaptor.getFirst().getType(), \ - adaptor.getSecond().getType(), \ - rewriter.getContext()); \ - IntegerType attrType = mlir::IntegerType::get(rewriter.getContext(), 32, \ - mlir::IntegerType::Unsigned); \ - \ - bool isFloat = innerType.isa(); \ - unsigned latency = latencyConfig->find( \ - (isFloat) ? CAT_E(OP_NAME,_FLOAT) : CAT_E(OP_NAME,_INT))->second; \ - auto module = rewriter.create( \ - rewriter.getUnknownLoc(), \ - mlir::StringAttr::get(rewriter.getContext(), name), \ - circt::firrtl::ConventionAttr::get(rewriter.getContext(), \ - circt::firrtl::Convention::Internal), \ - ports, \ - StringRef(name)); \ - module->setAttr(INSTANCE_LATENCY_ATTR, \ - mlir::IntegerAttr::get(attrType, latency)); \ - return module; \ - } \ - \ - void remapUses( OP_CLASS(CLASS_PREF) &oldOp, OpAdaptor &adaptor, \ - InstanceOp &newOp, Rewriter &rewriter) const override { \ - using circt::firrtl::utils::createConnect; \ - using circt::firrtl::utils::getClockVarFromOpBlock; \ - createConnect(rewriter, newOp.getResult(1), adaptor.getFirst(), \ - (*offsetMap)[std::make_pair(oldOp, 0)]); \ - createConnect(rewriter, newOp.getResult(2), adaptor.getSecond(), \ - (*offsetMap)[std::make_pair(oldOp, 1)]); \ - createConnect(rewriter, newOp.getResult(3), getClockVarFromOpBlock(newOp)); \ - \ - for (auto &operand: llvm::make_early_inc_range(oldOp.getRes().getUses())) { \ - (*oldTypeMap)[std::make_pair(operand.getOwner(), \ - operand.getOperandNumber())] = \ - operand.get().getType(); \ - operand.set(newOp.getResult(0)); \ - } \ - } \ - \ - LogicalResult matchAndRewrite( OP_CLASS(CLASS_PREF) oldOp, OpAdaptor adaptor, \ - Rewriter &rewriter) const override { \ - FExtModuleOp module = findOrCreateModule(oldOp, adaptor, rewriter); \ - \ - auto newOp = rewriter.create(oldOp.getLoc(), \ - module, \ - "placeholder"); \ - remapUses(oldOp, adaptor, newOp, rewriter); \ - rewriter.eraseOp(oldOp); \ - return mlir::success(); \ - } \ -}; \ +#define OP_CLASS_ADAPTOR(CLASS_PREF) OP_CLASS(CLASS_PREF)::Adaptor + +#define OP_CLASS_CONV_PATTERN(CLASS_PREF) CAT_E(OP_CLASS(CLASS_PREF), ConversionPattern) +#define SCHED_OP_CONV_PATTERN_SPEC(CLASS_PREF) OP_CLASS(CLASS_PREF), OP_CLASS_ADAPTOR(CLASS_PREF) + +#define DECL_SCHED_BINARY_ARITH_OP_CONV_PATTERN(CLASS_PREF, OP_NAME) \ +class OP_CLASS_CONV_PATTERN(CLASS_PREF) \ + : public SchedulableOpConversionPattern< SCHED_OP_CONV_PATTERN_SPEC(CLASS_PREF) > { \ + \ +public: \ + using SchedulableOpConversionPattern< SCHED_OP_CONV_PATTERN_SPEC(CLASS_PREF) >::SchedulableOpConversionPattern; \ + \ + std::string getBaseModuleName() const override { \ + return CAT_E(OP_NAME,_MODULE); \ + } \ +}; // AddOpConversionPattern. DECL_SCHED_BINARY_ARITH_OP_CONV_PATTERN(Add, ADD) @@ -546,82 +567,16 @@ DECL_SCHED_BINARY_ARITH_OP_CONV_PATTERN(Or, OR) // XorOpConversionPattern. DECL_SCHED_BINARY_ARITH_OP_CONV_PATTERN(Xor, XOR) -#define DECL_SCHED_UNARY_ARITH_OP_CONV_PATTERN(CLASS_PREF, OP_NAME) \ -class OP_CLASS_CONV_PATTERN(CLASS_PREF) \ - : public FIRRTLOpConversionPattern< OP_CLASS(CLASS_PREF) >, \ - SchedulableOpConversionPattern< SCHED_OP_CONV_PATTERN_SPEC(CLASS_PREF) > { \ -public: \ - using FIRRTLOpConversionPattern::FIRRTLOpConversionPattern; \ - using OpAdaptor = typename OP_CLASS_ADAPTOR(CLASS_PREF); \ - using FExtModuleOp = circt::firrtl::FExtModuleOp; \ - using InstanceOp = circt::firrtl::InstanceOp; \ - using IntType = circt::firrtl::IntType; \ - using Rewriter = ConversionPatternRewriter; \ - \ - std::string constructModuleName(const OP_CLASS(CLASS_PREF) &op, \ - OpAdaptor &adaptor) const override { \ - GET_SCHED_OP_NAME(OP_NAME) \ - } \ - \ - FExtModuleOp createModule(const std::string &name, \ - const OP_CLASS(CLASS_PREF) &op, OpAdaptor &adaptor, \ - Rewriter &rewriter) const override { \ - Type type = op->getResult(0).getType(); \ - Type innerType = llvm::cast(type).getDFType(); \ - Type firstType = (*oldTypeMap)[std::make_pair(op, 0)]; \ - Type firstInnerType = llvm::cast(firstType).getDFType(); \ - Type convertedType = getTypeConverter()->convertType(type); \ - auto ports = getUnaryOpPorts(convertedType, adaptor.getFirst().getType(), \ - rewriter.getContext()); \ - IntegerType attrType = mlir::IntegerType::get(rewriter.getContext(), 32, \ - mlir::IntegerType::Unsigned); \ - auto outTypeWidth = llvm::cast(innerType).getBitWidth(); \ - auto firstTypeWidth = llvm::cast(firstInnerType).getBitWidth(); \ - assert(outTypeWidth == firstTypeWidth); \ - \ - bool isFloat = innerType.isa(); \ - unsigned latency = \ - latencyConfig->find((isFloat) \ - ? CAT_E(OP_NAME,_FLOAT) \ - : CAT_E(OP_NAME,_INT))->second; \ - auto module = rewriter.create( \ - rewriter.getUnknownLoc(), \ - mlir::StringAttr::get(rewriter.getContext(), name), \ - circt::firrtl::ConventionAttr::get(rewriter.getContext(), \ - circt::firrtl::Convention::Internal), \ - ports, \ - StringRef(name)); \ - module->setAttr(INSTANCE_LATENCY_ATTR, \ - mlir::IntegerAttr::get(attrType, latency)); \ - return module; \ - } \ - \ - void remapUses( OP_CLASS(CLASS_PREF) &oldOp, OpAdaptor &adaptor, \ - InstanceOp &newOp, Rewriter &rewriter) const override { \ - using circt::firrtl::utils::createConnect; \ - using circt::firrtl::utils::getClockVarFromOpBlock; \ - createConnect(rewriter, newOp.getResult(1), adaptor.getFirst(), \ - (*offsetMap)[std::make_pair(oldOp, 0)]); \ - createConnect(rewriter, newOp.getResult(2), getClockVarFromOpBlock(newOp)); \ - \ - for (auto &operand: llvm::make_early_inc_range(oldOp.getRes().getUses())) { \ - (*oldTypeMap)[std::make_pair(operand.getOwner(), \ - operand.getOperandNumber())] = \ - operand.get().getType(); \ - operand.set(newOp.getResult(0)); \ - } \ - } \ - \ - LogicalResult matchAndRewrite( OP_CLASS(CLASS_PREF) oldOp, OpAdaptor adaptor, \ - Rewriter &rewriter) const override { \ - FExtModuleOp module = findOrCreateModule(oldOp, adaptor, rewriter); \ - \ - auto newOp = \ - rewriter.create(oldOp.getLoc(), module, "placeholder"); \ - remapUses(oldOp, adaptor, newOp, rewriter); \ - rewriter.eraseOp(oldOp); \ - return mlir::success(); \ - } \ +#define DECL_SCHED_UNARY_ARITH_OP_CONV_PATTERN(CLASS_PREF, OP_NAME) \ +class OP_CLASS_CONV_PATTERN(CLASS_PREF) \ + : public SchedulableOpConversionPattern< SCHED_OP_CONV_PATTERN_SPEC(CLASS_PREF) > { \ + \ +public: \ + using SchedulableOpConversionPattern< SCHED_OP_CONV_PATTERN_SPEC(CLASS_PREF) >::SchedulableOpConversionPattern; \ + \ + std::string getBaseModuleName() const override { \ + return CAT_E(OP_NAME,_MODULE); \ + } \ }; // NotOpConversionPattern. @@ -648,6 +603,32 @@ DECL_SCHED_BINARY_ARITH_OP_CONV_PATTERN(Eq, EQ) // NotEqOpConversionPattern. DECL_SCHED_BINARY_ARITH_OP_CONV_PATTERN(NotEq, NEQ) +class LatencyOpConversionPattern + : public SchedulableOpConversionPattern { + +public: + std::string + getBaseModuleName() const override { + return BUF_MODULE; + } + + std::string + constructModuleName(LatencyOp &op, LatencyOp::Adaptor &adaptor) const override { + using circt::firrtl::getBitWidth; + using circt::firrtl::FIRRTLBaseType; + + std::string name = getBaseModuleName(); + llvm::raw_string_ostream nameStream(name); + + auto convertedType = getTypeConverter()->convertType(op->getResult(0).getType()); + auto width = getBitWidth(llvm::dyn_cast(convertedType)); + int32_t latency = llvm::cast(op.getOperation()).getLatency(); + nameStream << "_IN_" << *width << "_OUT_" << *width << "_" << latency; + + return name; + } +}; + class ShiftLeftOpConversionPattern : public FIRRTLOpConversionPattern { public: @@ -715,42 +696,17 @@ class ConnectOpConversionPattern LogicalResult matchAndRewrite(ConnectOp connectOp, OpAdaptor adaptor, Rewriter &rewriter) const override { - using circt::firrtl::utils::createConnect; - auto newOp = createConnect(rewriter, - adaptor.getDest(), - adaptor.getSrc()); + auto newOp = rewriter.create( + rewriter.getUnknownLoc(), + adaptor.getDest(), + adaptor.getSrc() + ); rewriter.replaceOp(connectOp, newOp); return mlir::success(); } }; -class OffsetOpConversionPattern - : public FIRRTLOpConversionPattern { -public: - using FIRRTLOpConversionPattern::FIRRTLOpConversionPattern; - using OpAdaptor = typename OffsetOp::Adaptor; - using Rewriter = ConversionPatternRewriter; - - LogicalResult matchAndRewrite(OffsetOp offsetOp, OpAdaptor adaptor, - Rewriter &rewriter) const override { - int offset = adaptor.getOffset().getInt(); - - for (auto &operand: llvm::make_early_inc_range( - offsetOp.getRes().getUses())) { - (*oldTypeMap)[std::make_pair(operand.getOwner(), - operand.getOperandNumber())] = - operand.get().getType(); - operand.set(offsetOp.getOperand()); - (*offsetMap)[std::make_pair(operand.getOwner(), - operand.getOperandNumber())] = offset; - } - - rewriter.eraseOp(offsetOp); - return mlir::success(); - } -}; - class MuxOpConversionPattern : public FIRRTLOpConversionPattern { public: using FIRRTLOpConversionPattern::FIRRTLOpConversionPattern; @@ -778,13 +734,10 @@ class DFCIRToFIRRTLPass : public impl::DFCIRToFIRRTLPassBase { public: using ConvertedOps = mlir::DenseSet; - using OffsetMap = - std::unordered_map, signed>; using OldTypeMap = std::unordered_map, mlir::Type>; - explicit DFCIRToFIRRTLPass(const DFCIRToFIRRTLPassOptions &options) - : impl::DFCIRToFIRRTLPassBase(options) {} + explicit DFCIRToFIRRTLPass() : impl::DFCIRToFIRRTLPassBase() {} void runOnOperation() override { // Define the conversion target. @@ -797,7 +750,6 @@ class DFCIRToFIRRTLPass // Issue #12 (https://github.com/ispras/utopia-hls/issues/12). FIRRTLTypeConverter typeConverter; ConvertedOps convertedOps; - OffsetMap offsetMap; OldTypeMap oldTypeMap; ModuleArgMap moduleArgMap; @@ -809,8 +761,6 @@ class DFCIRToFIRRTLPass &getContext(), typeConverter, &convertedOps, - latencyConfig, - &offsetMap, &oldTypeMap, &moduleArgMap ); @@ -826,13 +776,13 @@ class DFCIRToFIRRTLPass patterns.clear(); target.addIllegalDialect(); target.addIllegalOp(); + target.addIllegalOp(); patterns.add< InputOpConversionPattern, ScalarInputOpConversionPattern, OutputOpConversionPattern, ScalarOutputOpConversionPattern, ConstantOpConversionPattern, - OffsetOpConversionPattern, MuxOpConversionPattern, AddOpConversionPattern, SubOpConversionPattern, @@ -855,8 +805,6 @@ class DFCIRToFIRRTLPass &getContext(), typeConverter, &convertedOps, - latencyConfig, - &offsetMap, &oldTypeMap, &moduleArgMap ); @@ -870,10 +818,8 @@ class DFCIRToFIRRTLPass } }; -std::unique_ptr createDFCIRToFIRRTLPass(LatencyConfig *config) { - DFCIRToFIRRTLPassOptions options; - options.latencyConfig = config; - return std::make_unique(options); +std::unique_ptr createDFCIRToFIRRTLPass() { + return std::make_unique(); } } // namespace mlir::dfcir \ No newline at end of file diff --git a/src/model/dfcir/lib/dfcir/conversions/FIRRTLStubsGeneratorPass.cpp b/src/model/dfcir/lib/dfcir/conversions/FIRRTLStubsGeneratorPass.cpp index 9f71790..a483d6e 100644 --- a/src/model/dfcir/lib/dfcir/conversions/FIRRTLStubsGeneratorPass.cpp +++ b/src/model/dfcir/lib/dfcir/conversions/FIRRTLStubsGeneratorPass.cpp @@ -24,9 +24,10 @@ namespace mlir::dfcir { #define GEN_PASS_DECL_FIRRTLSTUBGENERATORPASS #define GEN_PASS_DEF_FIRRTLSTUBGENERATORPASS - #include "dfcir/conversions/DFCIRPasses.h.inc" +#include "dfcir/conversions/ModuleDefines.inc" + class FIRRTLStubGeneratorPass : public impl::FIRRTLStubGeneratorPassBase { using TemplateDictionary = ctemplate::TemplateDictionary; diff --git a/src/model/dfcxx/include/dfcxx/typedefs.h b/src/model/dfcxx/include/dfcxx/typedefs.h index 2ac86a1..f20ce3a 100644 --- a/src/model/dfcxx/include/dfcxx/typedefs.h +++ b/src/model/dfcxx/include/dfcxx/typedefs.h @@ -74,7 +74,11 @@ enum class OutputFormatID : uint8_t { } // namespace dfcxx -typedef std::unordered_map DFLatencyConfig; +struct DFLatencyConfig { + std::unordered_map internalOps; + std::unordered_map externalOps; +}; + typedef std::unordered_map DFOutputPaths; #endif // DFCXX_TYPEDEFS_H diff --git a/src/model/dfcxx/lib/dfcxx/converter.cpp b/src/model/dfcxx/lib/dfcxx/converter.cpp index 73fbfc4..bbe4ed5 100644 --- a/src/model/dfcxx/lib/dfcxx/converter.cpp +++ b/src/model/dfcxx/lib/dfcxx/converter.cpp @@ -43,10 +43,11 @@ std::unique_ptr createDFCIRDumperPass(llvm::raw_fd_ostream *stream) DFCIRConverter::DFCIRConverter(const DFLatencyConfig &config) { this->config = LatencyConfig(); - for (auto [op, latency]: config) { - this->config[static_cast(op)] = latency; + for (auto [op, latency]: config.internalOps) { + this->config.internalOps[static_cast(op)] = latency; } - this->config[mlir::dfcir::UNDEFINED] = 0; + this->config.internalOps[mlir::dfcir::UNDEFINED] = 0; + this->config.externalOps = config.externalOps; } bool DFCIRConverter::convertAndPrint(mlir::ModuleOp module, @@ -62,16 +63,17 @@ bool DFCIRConverter::convertAndPrint(mlir::ModuleOp module, module.print(*stream); } - pm.addPass(mlir::dfcir::createDFCIRToFIRRTLPass(&config)); switch (sched) { case Linear: - pm.addPass(mlir::dfcir::createDFCIRLinearSchedulerPass()); + pm.addPass(mlir::dfcir::createDFCIRLinearSchedulerPass(&config)); break; case ASAP: - pm.addPass(mlir::dfcir::createDFCIRASAPSchedulerPass()); + pm.addPass(mlir::dfcir::createDFCIRASAPSchedulerPass(&config)); break; } + pm.addPass(mlir::dfcir::createDFCIRToFIRRTLPass()); + // Dump FIRRTL if the corresponding option is specified. if (auto *stream = outputStreams[OUT_FORMAT_ID_INT(FIRRTL)]) { pm.addPass(createDFCIRDumperPass(stream)); diff --git a/src/options.h b/src/options.h index 879c972..53195c7 100644 --- a/src/options.h +++ b/src/options.h @@ -41,6 +41,9 @@ #define OUT_FIRRTL_JSON "out_firrtl" #define OUT_DOT_JSON "out_dot" +#define DFCIR_OPS_ID_JSON "dfcir" +#define EXTERNAL_OPS_ID_JSON "external" + #define SIM_ID_JSON "sim" #define SIM_IN_JSON "in" #define SIM_OUT_JSON "out" @@ -223,7 +226,7 @@ struct HlsOptions final : public AppOptions { get(json, OUT_SV_LIB_JSON, outNames[OUT_FORMAT_ID_INT(SVLibrary)]); get(json, OUT_DFCIR_JSON, outNames[OUT_FORMAT_ID_INT(DFCIR)]); get(json, OUT_FIRRTL_JSON, outNames[OUT_FORMAT_ID_INT(FIRRTL)]); - get(json, OUT_DOT_JSON, outNames[OUT_FORMAT_ID_INT(DOT)]); + get(json, OUT_DOT_JSON, outNames[OUT_FORMAT_ID_INT(DOT)]); } dfcxx::Ops convertFieldToEnum(const std::string field) { @@ -260,13 +263,26 @@ struct HlsOptions final : public AppOptions { return dfcxx::ADD_INT; } + void parseInternalOpsConfig(Json json) { + if (!json.contains(DFCIR_OPS_ID_JSON)) { return; } + for (auto &[key, val] : json[DFCIR_OPS_ID_JSON].items()) { + latencyCfg.internalOps[convertFieldToEnum(key)] = val; + } + } + + void parseExternalOpsConfig(Json json) { + if (!json.contains(EXTERNAL_OPS_ID_JSON)) { return; } + for (auto &[key, val] : json[EXTERNAL_OPS_ID_JSON].items()) { + latencyCfg.externalOps[key] = val; + } + } + void parseLatencyConfig() { std::ifstream in(latencyCfgFile); if (!in.good()) { return; } - auto json = Json::parse(in); - for (auto &[key, val] : json.items()) { - latencyCfg[convertFieldToEnum(key)] = val; - } + Json json = Json::parse(in); + parseInternalOpsConfig(json); + parseExternalOpsConfig(json); } std::string latencyCfgFile; From 62227c94921ffca8ad6eb702137119fa54d12b01 Mon Sep 17 00:00:00 2001 From: Litvinov Mikhail Date: Mon, 13 Jan 2025 03:25:18 +0300 Subject: [PATCH 02/11] DFCIRPassesUtils.cpp: process fixed. --- src/model/dfcir/lib/dfcir/conversions/DFCIRPassesUtils.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/model/dfcir/lib/dfcir/conversions/DFCIRPassesUtils.cpp b/src/model/dfcir/lib/dfcir/conversions/DFCIRPassesUtils.cpp index f98f924..de32ba9 100644 --- a/src/model/dfcir/lib/dfcir/conversions/DFCIRPassesUtils.cpp +++ b/src/model/dfcir/lib/dfcir/conversions/DFCIRPassesUtils.cpp @@ -144,7 +144,7 @@ void Graph::process(ConnectOp &op) { if (!llvm::isa(op.getDest().getDefiningOp())) { return; } auto unrolledInfo = findNearestNodeValue(op.getSrc()); auto srcNode = findNode(unrolledInfo.first); - auto dstNode = findNode(op); + auto dstNode = findNode(op.getDest()); Channel *newChannel = new Channel(*srcNode, *dstNode, 0, unrolledInfo.second); channels.insert(newChannel); outputs[*srcNode].insert(newChannel); From 4fe1f7564e39e518c61cbc521378ed845a795409 Mon Sep 17 00:00:00 2001 From: Litvinov Mikhail Date: Mon, 13 Jan 2025 03:35:58 +0300 Subject: [PATCH 03/11] DFCIRPassesUtils, DFCIROperations: latency ops creation fixed. --- src/model/dfcir/include/dfcir/DFCIROperations.td | 15 ++++++++++++++- .../include/dfcir/conversions/DFCIRPassesUtils.h | 2 +- .../lib/dfcir/conversions/DFCIRPassesUtils.cpp | 8 +++++--- 3 files changed, 20 insertions(+), 5 deletions(-) diff --git a/src/model/dfcir/include/dfcir/DFCIROperations.td b/src/model/dfcir/include/dfcir/DFCIROperations.td index 6e24387..3368f23 100644 --- a/src/model/dfcir/include/dfcir/DFCIROperations.td +++ b/src/model/dfcir/include/dfcir/DFCIROperations.td @@ -134,6 +134,19 @@ def LatencyOp : DFCIR_Op<"latency", []> { let results = (outs Variable:$res); + let builders = [ + OpBuilder<(ins + "Type":$res, + "Value":$input, + "int32_t":$latency + ), [{ + auto attr = + mlir::IntegerAttr::get(IntegerType::get($_builder.getContext(), 32), + latency); + build($_builder, $_state, res, input, attr); + }]> + ]; + let hasCustomAssemblyFormat = 1; } @@ -153,7 +166,7 @@ class DFCIR_UnaryOp:$latency ), [{ - auto attr = + auto attr = mlir::IntegerAttr::get(IntegerType::get($_builder.getContext(), 32), latency); build($_builder, $_state, res, first, attr); diff --git a/src/model/dfcir/include/dfcir/conversions/DFCIRPassesUtils.h b/src/model/dfcir/include/dfcir/conversions/DFCIRPassesUtils.h index be6e684..27d155f 100644 --- a/src/model/dfcir/include/dfcir/conversions/DFCIRPassesUtils.h +++ b/src/model/dfcir/include/dfcir/conversions/DFCIRPassesUtils.h @@ -131,7 +131,7 @@ class Graph { void process(Op &op); }; -void insertBuffer(OpBuilder &builder, Channel *channel); +void insertBuffer(OpBuilder &builder, Channel *channel, int32_t latency); void insertBuffers(mlir::MLIRContext &ctx, const Buffers &buffers); diff --git a/src/model/dfcir/lib/dfcir/conversions/DFCIRPassesUtils.cpp b/src/model/dfcir/lib/dfcir/conversions/DFCIRPassesUtils.cpp index de32ba9..020d540 100644 --- a/src/model/dfcir/lib/dfcir/conversions/DFCIRPassesUtils.cpp +++ b/src/model/dfcir/lib/dfcir/conversions/DFCIRPassesUtils.cpp @@ -207,20 +207,22 @@ Graph::Graph(ModuleOp module) : Graph(mlir::utils::findFirstOccurence(module)) {} -void insertBuffer(OpBuilder &builder, Channel *channel) { +void insertBuffer(OpBuilder &builder, Channel *channel, int32_t latency) { builder.setInsertionPoint(channel->target->op); auto value = channel->target->op->getOperand(channel->valInd); auto latencyOp = builder.create(builder.getUnknownLoc(), - value.getType(), value); + value.getType(), + value, + latency); channel->target->op->setOperand(channel->valInd, latencyOp.getRes()); } void insertBuffers(mlir::MLIRContext &ctx, const Buffers &buffers) { OpBuilder builder(&ctx); for (auto &[channel, latency]: buffers) { - insertBuffer(builder, channel); + insertBuffer(builder, channel, latency); } } From d01bc41cc6d2673c70c55d3516d30208a751fdba Mon Sep 17 00:00:00 2001 From: Litvinov Mikhail Date: Mon, 13 Jan 2025 03:58:16 +0300 Subject: [PATCH 04/11] DFCIROperations, DFCIRToFIRRTLPass: LatencyOp conversion fixed. --- .../dfcir/include/dfcir/DFCIROperations.td | 2 +- .../dfcir/conversions/DFCIRToFIRRTLPass.cpp | 57 ++++++++++--------- 2 files changed, 31 insertions(+), 28 deletions(-) diff --git a/src/model/dfcir/include/dfcir/DFCIROperations.td b/src/model/dfcir/include/dfcir/DFCIROperations.td index 3368f23..28625fb 100644 --- a/src/model/dfcir/include/dfcir/DFCIROperations.td +++ b/src/model/dfcir/include/dfcir/DFCIROperations.td @@ -124,7 +124,7 @@ def CastOp : DFCIR_Op<"cast", []> { let results = (outs CastVariable:$res); } -def LatencyOp : DFCIR_Op<"latency", []> { +def LatencyOp : DFCIR_Op<"latency", [DeclareOpInterfaceMethods]> { let summary = "Sets a clock latency for the input."; let arguments = (ins diff --git a/src/model/dfcir/lib/dfcir/conversions/DFCIRToFIRRTLPass.cpp b/src/model/dfcir/lib/dfcir/conversions/DFCIRToFIRRTLPass.cpp index 897c629..3840b07 100644 --- a/src/model/dfcir/lib/dfcir/conversions/DFCIRToFIRRTLPass.cpp +++ b/src/model/dfcir/lib/dfcir/conversions/DFCIRToFIRRTLPass.cpp @@ -603,32 +603,6 @@ DECL_SCHED_BINARY_ARITH_OP_CONV_PATTERN(Eq, EQ) // NotEqOpConversionPattern. DECL_SCHED_BINARY_ARITH_OP_CONV_PATTERN(NotEq, NEQ) -class LatencyOpConversionPattern - : public SchedulableOpConversionPattern { - -public: - std::string - getBaseModuleName() const override { - return BUF_MODULE; - } - - std::string - constructModuleName(LatencyOp &op, LatencyOp::Adaptor &adaptor) const override { - using circt::firrtl::getBitWidth; - using circt::firrtl::FIRRTLBaseType; - - std::string name = getBaseModuleName(); - llvm::raw_string_ostream nameStream(name); - - auto convertedType = getTypeConverter()->convertType(op->getResult(0).getType()); - auto width = getBitWidth(llvm::dyn_cast(convertedType)); - int32_t latency = llvm::cast(op.getOperation()).getLatency(); - nameStream << "_IN_" << *width << "_OUT_" << *width << "_" << latency; - - return name; - } -}; - class ShiftLeftOpConversionPattern : public FIRRTLOpConversionPattern { public: @@ -730,6 +704,34 @@ class MuxOpConversionPattern : public FIRRTLOpConversionPattern { } }; +class LatencyOpConversionPattern + : public SchedulableOpConversionPattern { + +public: + using SchedulableOpConversionPattern::SchedulableOpConversionPattern; + + std::string + getBaseModuleName() const override { + return BUF_MODULE; + } + + std::string + constructModuleName(LatencyOp &op, LatencyOp::Adaptor &adaptor) const override { + using circt::firrtl::getBitWidth; + using circt::firrtl::FIRRTLBaseType; + + std::string name = getBaseModuleName(); + llvm::raw_string_ostream nameStream(name); + + auto convertedType = getTypeConverter()->convertType(op->getResult(0).getType()); + auto width = getBitWidth(llvm::dyn_cast(convertedType)); + int32_t latency = llvm::cast(op.getOperation()).getLatency(); + nameStream << "_IN_" << *width << "_OUT_" << *width << "_" << latency; + + return name; + } +}; + class DFCIRToFIRRTLPass : public impl::DFCIRToFIRRTLPassBase { public: @@ -801,7 +803,8 @@ class DFCIRToFIRRTLPass NotEqOpConversionPattern, ShiftLeftOpConversionPattern, ShiftRightOpConversionPattern, - ConnectOpConversionPattern>( + ConnectOpConversionPattern, + LatencyOpConversionPattern>( &getContext(), typeConverter, &convertedOps, From 8abcd43dc487224259e2365dbcaf053b3f524b42 Mon Sep 17 00:00:00 2001 From: Litvinov Mikhail Date: Mon, 13 Jan 2025 04:06:10 +0300 Subject: [PATCH 05/11] examples: encapsulated configs in "dfcir"-section. --- examples/addconst/add_int_2.json | 4 +++- examples/idct/add_int_1_sub_int_1_mul_int_3.json | 8 +++++--- examples/matrixmul2/add_int_2_mul_int3.json | 6 ++++-- examples/movingsum/add_int_2.json | 6 ++++-- examples/movingsum/add_int_8.json | 6 ++++-- examples/muxmul/add_int_2_mul_int3.json | 6 ++++-- examples/polynomial2/add_int_2_mul_int3.json | 6 ++++-- examples/polynomial2/add_int_8_mul_int15.json | 6 ++++-- examples/polynomial2_inst/add_int_2_mul_int3.json | 6 ++++-- examples/scalar3/add_int_2_mul_int3.json | 6 ++++-- 10 files changed, 40 insertions(+), 20 deletions(-) diff --git a/examples/addconst/add_int_2.json b/examples/addconst/add_int_2.json index e1d2329..a8188ff 100644 --- a/examples/addconst/add_int_2.json +++ b/examples/addconst/add_int_2.json @@ -1,3 +1,5 @@ { - "ADD_INT": 2 + "dfcir": { + "ADD_INT": 2 + } } diff --git a/examples/idct/add_int_1_sub_int_1_mul_int_3.json b/examples/idct/add_int_1_sub_int_1_mul_int_3.json index 19d272c..baafaae 100644 --- a/examples/idct/add_int_1_sub_int_1_mul_int_3.json +++ b/examples/idct/add_int_1_sub_int_1_mul_int_3.json @@ -1,5 +1,7 @@ { - "ADD_INT": 1, - "SUB_INT": 1, - "MUL_INT": 3 + "dfcir": { + "ADD_INT": 1, + "SUB_INT": 1, + "MUL_INT": 3 + } } diff --git a/examples/matrixmul2/add_int_2_mul_int3.json b/examples/matrixmul2/add_int_2_mul_int3.json index da7ea74..4a706d9 100644 --- a/examples/matrixmul2/add_int_2_mul_int3.json +++ b/examples/matrixmul2/add_int_2_mul_int3.json @@ -1,4 +1,6 @@ { - "ADD_INT": 2, - "MUL_INT": 3 + "dfcir": { + "ADD_INT": 2, + "MUL_INT": 3 + } } diff --git a/examples/movingsum/add_int_2.json b/examples/movingsum/add_int_2.json index e1d2329..a80f8c1 100644 --- a/examples/movingsum/add_int_2.json +++ b/examples/movingsum/add_int_2.json @@ -1,3 +1,5 @@ { - "ADD_INT": 2 -} + "dfcir": { + "ADD_INT": 2 + } +} \ No newline at end of file diff --git a/examples/movingsum/add_int_8.json b/examples/movingsum/add_int_8.json index 8c0c11a..a3ad101 100644 --- a/examples/movingsum/add_int_8.json +++ b/examples/movingsum/add_int_8.json @@ -1,3 +1,5 @@ { - "ADD_INT": 8 -} + "dfcir": { + "ADD_INT": 8 + } +} \ No newline at end of file diff --git a/examples/muxmul/add_int_2_mul_int3.json b/examples/muxmul/add_int_2_mul_int3.json index da7ea74..4a706d9 100644 --- a/examples/muxmul/add_int_2_mul_int3.json +++ b/examples/muxmul/add_int_2_mul_int3.json @@ -1,4 +1,6 @@ { - "ADD_INT": 2, - "MUL_INT": 3 + "dfcir": { + "ADD_INT": 2, + "MUL_INT": 3 + } } diff --git a/examples/polynomial2/add_int_2_mul_int3.json b/examples/polynomial2/add_int_2_mul_int3.json index da7ea74..4a706d9 100644 --- a/examples/polynomial2/add_int_2_mul_int3.json +++ b/examples/polynomial2/add_int_2_mul_int3.json @@ -1,4 +1,6 @@ { - "ADD_INT": 2, - "MUL_INT": 3 + "dfcir": { + "ADD_INT": 2, + "MUL_INT": 3 + } } diff --git a/examples/polynomial2/add_int_8_mul_int15.json b/examples/polynomial2/add_int_8_mul_int15.json index 9f1d750..8eed8df 100644 --- a/examples/polynomial2/add_int_8_mul_int15.json +++ b/examples/polynomial2/add_int_8_mul_int15.json @@ -1,4 +1,6 @@ { - "ADD_INT": 8, - "MUL_INT": 15 + "dfcir": { + "ADD_INT": 8, + "MUL_INT": 15 + } } diff --git a/examples/polynomial2_inst/add_int_2_mul_int3.json b/examples/polynomial2_inst/add_int_2_mul_int3.json index da7ea74..4a706d9 100644 --- a/examples/polynomial2_inst/add_int_2_mul_int3.json +++ b/examples/polynomial2_inst/add_int_2_mul_int3.json @@ -1,4 +1,6 @@ { - "ADD_INT": 2, - "MUL_INT": 3 + "dfcir": { + "ADD_INT": 2, + "MUL_INT": 3 + } } diff --git a/examples/scalar3/add_int_2_mul_int3.json b/examples/scalar3/add_int_2_mul_int3.json index da7ea74..4a706d9 100644 --- a/examples/scalar3/add_int_2_mul_int3.json +++ b/examples/scalar3/add_int_2_mul_int3.json @@ -1,4 +1,6 @@ { - "ADD_INT": 2, - "MUL_INT": 3 + "dfcir": { + "ADD_INT": 2, + "MUL_INT": 3 + } } From 1830df1c7216fde1c7eab8dc631f52b91ab475a0 Mon Sep 17 00:00:00 2001 From: Litvinov Mikhail Date: Mon, 13 Jan 2025 04:26:42 +0300 Subject: [PATCH 06/11] HLS mode: --out-scheduled-dfcir option. --- README.md | 3 ++- config.json | 17 +++++++------- src/model/dfcxx/include/dfcxx/typedefs.h | 3 ++- src/model/dfcxx/lib/dfcxx/converter.cpp | 9 +++++-- src/options.h | 30 ++++++++++++++---------- 5 files changed, 38 insertions(+), 24 deletions(-) diff --git a/README.md b/README.md index dfb5484..3713a42 100644 --- a/README.md +++ b/README.md @@ -219,7 +219,8 @@ Unless neither of the three arguments is used, first argument is the mode which * `--config `: *required* filesystem-path option; used to specify the file for a JSON latency configuration file. Its format is presented in `docs/latency_config.md`. * `--out-sv `: *optional* filesystem-path option; used to specify the output SystemVerilog file. * `--out-sv-lib `: *optional* filesystem-path option; used to specify the output SystemVerilog file for generated operations library. -* `--out-dfcir `: *optional* filesystem-path option; used to specify the output DFCIR file. +* `--out-dfcir `: *optional* filesystem-path option; used to specify the output unscheduled DFCIR file. +* `--out-scheduled-dfcir `: *optional* filesystem-path option; used to specify the output scheduled DFCIR file. * `--out-firrtl `: *optional* filesystem-path option; used to specify the output FIRRTL file. * `--out-dot `: *optional* filesystem-path option; used to specify the output DOT file. * `-a` or `-l`: *required* flag; used to specify the chosen scheduling strategy - either as-soon-as-possible or linear programming. **Exactly one of these flags has to be specified**. diff --git a/config.json b/config.json index 2ac439d..43d98e9 100644 --- a/config.json +++ b/config.json @@ -1,13 +1,14 @@ { "hls": { - "config" : "", - "asap_scheduler" : false, - "lp_scheduler" : false, - "out_sv" : "", - "out_sv_lib" : "", - "out_dfcir" : "", - "out_firrtl" : "", - "out_dot" : "" + "config" : "", + "asap_scheduler" : false, + "lp_scheduler" : false, + "out_sv" : "", + "out_sv_lib" : "", + "out_dfcir" : "", + "out_scheduled_dfcir": "", + "out_firrtl" : "", + "out_dot" : "" }, "sim": { "in" : "sim.txt", diff --git a/src/model/dfcxx/include/dfcxx/typedefs.h b/src/model/dfcxx/include/dfcxx/typedefs.h index f20ce3a..77641a2 100644 --- a/src/model/dfcxx/include/dfcxx/typedefs.h +++ b/src/model/dfcxx/include/dfcxx/typedefs.h @@ -63,7 +63,8 @@ enum Scheduler { enum class OutputFormatID : uint8_t { SystemVerilog = 0, SVLibrary, - DFCIR, + UnscheduledDFCIR, + ScheduledDFCIR, FIRRTL, DOT, // Utility value. Constains the number of elements in the enum. diff --git a/src/model/dfcxx/lib/dfcxx/converter.cpp b/src/model/dfcxx/lib/dfcxx/converter.cpp index bbe4ed5..90ed6fa 100644 --- a/src/model/dfcxx/lib/dfcxx/converter.cpp +++ b/src/model/dfcxx/lib/dfcxx/converter.cpp @@ -58,8 +58,8 @@ bool DFCIRConverter::convertAndPrint(mlir::ModuleOp module, context->getOrLoadDialect(); mlir::PassManager pm(context); - // Dump DFCIR if the corresponding option is specified. - if (auto *stream = outputStreams[OUT_FORMAT_ID_INT(DFCIR)]) { + // Dump unscheduled DFCIR if the corresponding option is specified. + if (auto *stream = outputStreams[OUT_FORMAT_ID_INT(UnscheduledDFCIR)]) { module.print(*stream); } @@ -72,6 +72,11 @@ bool DFCIRConverter::convertAndPrint(mlir::ModuleOp module, break; } + // Dump scheduled DFCIR if the corresponding option is specified. + if (auto *stream = outputStreams[OUT_FORMAT_ID_INT(ScheduledDFCIR)]) { + pm.addPass(createDFCIRDumperPass(stream)); + } + pm.addPass(mlir::dfcir::createDFCIRToFIRRTLPass()); // Dump FIRRTL if the corresponding option is specified. diff --git a/src/options.h b/src/options.h index 53195c7..efe9ea0 100644 --- a/src/options.h +++ b/src/options.h @@ -37,7 +37,8 @@ #define LP_SCHEDULER_JSON "lp_scheduler" #define OUT_SV_JSON "out_sv" #define OUT_SV_LIB_JSON "out_sv_lib" -#define OUT_DFCIR_JSON "out_dfcir" +#define OUT_UNSCHEDULED_DFCIR_JSON "out_dfcir" +#define OUT_SCHEDULED_DFCIR_JSON "out_scheduled_dfcir" #define OUT_FIRRTL_JSON "out_firrtl" #define OUT_DOT_JSON "out_dot" @@ -60,7 +61,8 @@ #define OUTPUT_GROUP "output" #define OUT_SV_ARG CLI_ARG("out-sv") #define OUT_SV_LIB_ARG CLI_ARG("out-sv-lib") -#define OUT_DFCIR_ARG CLI_ARG("out-dfcir") +#define OUT_UNSCHEDULED_DFCIR_ARG CLI_ARG("out-dfcir") +#define OUT_SCHEDULED_DFCIR_ARG CLI_ARG("out-scheduled-dfcir") #define OUT_FIRRTL_ARG CLI_ARG("out-firrtl") #define OUT_DOT_ARG CLI_ARG("out-dot") @@ -206,9 +208,12 @@ struct HlsOptions final : public AppOptions { outputGroup->add_option(OUT_SV_LIB_ARG, outNames[OUT_FORMAT_ID_INT(SVLibrary)], "Path to output SystemVerilog modules for generated operations"); - outputGroup->add_option(OUT_DFCIR_ARG, - outNames[OUT_FORMAT_ID_INT(DFCIR)], + outputGroup->add_option(OUT_UNSCHEDULED_DFCIR_ARG, + outNames[OUT_FORMAT_ID_INT(UnscheduledDFCIR)], "Path to output unscheduled DFCIR"); + outputGroup->add_option(OUT_SCHEDULED_DFCIR_ARG, + outNames[OUT_FORMAT_ID_INT(ScheduledDFCIR)], + "Path to output scheduled DFCIR"); outputGroup->add_option(OUT_FIRRTL_ARG, outNames[OUT_FORMAT_ID_INT(FIRRTL)], "Path to output scheduled FIRRTL"); @@ -219,14 +224,15 @@ struct HlsOptions final : public AppOptions { } void fromJson(Json json) override { - get(json, CONFIG_JSON, latencyCfgFile); - get(json, ASAP_SCHEDULER_JSON, asapScheduler); - get(json, LP_SCHEDULER_JSON, lpScheduler); - get(json, OUT_SV_JSON, outNames[OUT_FORMAT_ID_INT(SystemVerilog)]); - get(json, OUT_SV_LIB_JSON, outNames[OUT_FORMAT_ID_INT(SVLibrary)]); - get(json, OUT_DFCIR_JSON, outNames[OUT_FORMAT_ID_INT(DFCIR)]); - get(json, OUT_FIRRTL_JSON, outNames[OUT_FORMAT_ID_INT(FIRRTL)]); - get(json, OUT_DOT_JSON, outNames[OUT_FORMAT_ID_INT(DOT)]); + get(json, CONFIG_JSON, latencyCfgFile); + get(json, ASAP_SCHEDULER_JSON, asapScheduler); + get(json, LP_SCHEDULER_JSON, lpScheduler); + get(json, OUT_SV_JSON, outNames[OUT_FORMAT_ID_INT(SystemVerilog)]); + get(json, OUT_SV_LIB_JSON, outNames[OUT_FORMAT_ID_INT(SVLibrary)]); + get(json, OUT_UNSCHEDULED_DFCIR_JSON, outNames[OUT_FORMAT_ID_INT(UnscheduledDFCIR)]); + get(json, OUT_SCHEDULED_DFCIR_JSON, outNames[OUT_FORMAT_ID_INT(ScheduledDFCIR)]); + get(json, OUT_FIRRTL_JSON, outNames[OUT_FORMAT_ID_INT(FIRRTL)]); + get(json, OUT_DOT_JSON, outNames[OUT_FORMAT_ID_INT(DOT)]); } dfcxx::Ops convertFieldToEnum(const std::string field) { From bf429356fcedea010649a612186dce3d30aa614a Mon Sep 17 00:00:00 2001 From: Muxianesty Date: Mon, 13 Jan 2025 14:12:32 +0300 Subject: [PATCH 07/11] Scheduling, DFCIRPassesUtils: added OffsetOp erasing after scheduling. --- .../include/dfcir/conversions/DFCIRPassesUtils.h | 2 ++ .../lib/dfcir/conversions/DFCIRASAPSchedulerPass.cpp | 3 +++ .../dfcir/conversions/DFCIRLinearSchedulerPass.cpp | 3 +++ .../dfcir/lib/dfcir/conversions/DFCIRPassesUtils.cpp | 11 +++++++++++ 4 files changed, 19 insertions(+) diff --git a/src/model/dfcir/include/dfcir/conversions/DFCIRPassesUtils.h b/src/model/dfcir/include/dfcir/conversions/DFCIRPassesUtils.h index 27d155f..7ca1bb4 100644 --- a/src/model/dfcir/include/dfcir/conversions/DFCIRPassesUtils.h +++ b/src/model/dfcir/include/dfcir/conversions/DFCIRPassesUtils.h @@ -135,6 +135,8 @@ void insertBuffer(OpBuilder &builder, Channel *channel, int32_t latency); void insertBuffers(mlir::MLIRContext &ctx, const Buffers &buffers); +void eraseOffsets(mlir::Operation *op); + Ops resolveInternalOpType(mlir::Operation *op); } // namespace mlir::dfcir::utils diff --git a/src/model/dfcir/lib/dfcir/conversions/DFCIRASAPSchedulerPass.cpp b/src/model/dfcir/lib/dfcir/conversions/DFCIRASAPSchedulerPass.cpp index 4813dcd..d7692df 100644 --- a/src/model/dfcir/lib/dfcir/conversions/DFCIRASAPSchedulerPass.cpp +++ b/src/model/dfcir/lib/dfcir/conversions/DFCIRASAPSchedulerPass.cpp @@ -106,6 +106,9 @@ class DFCIRASAPSchedulerPass // Insert buffers. mlir::dfcir::utils::insertBuffers(this->getContext(), buffers); + + // Erase old "dfcir.offset" operations. + mlir::dfcir::utils::eraseOffsets(getOperation()); } }; diff --git a/src/model/dfcir/lib/dfcir/conversions/DFCIRLinearSchedulerPass.cpp b/src/model/dfcir/lib/dfcir/conversions/DFCIRLinearSchedulerPass.cpp index 78dca84..2d615a7 100644 --- a/src/model/dfcir/lib/dfcir/conversions/DFCIRLinearSchedulerPass.cpp +++ b/src/model/dfcir/lib/dfcir/conversions/DFCIRLinearSchedulerPass.cpp @@ -154,6 +154,9 @@ class DFCIRLinearSchedulerPass // Insert buffers. mlir::dfcir::utils::insertBuffers(this->getContext(), buffers); + + // Erase old "dfcir.offset" operations. + mlir::dfcir::utils::eraseOffsets(getOperation()); } }; diff --git a/src/model/dfcir/lib/dfcir/conversions/DFCIRPassesUtils.cpp b/src/model/dfcir/lib/dfcir/conversions/DFCIRPassesUtils.cpp index 020d540..ed7cf0a 100644 --- a/src/model/dfcir/lib/dfcir/conversions/DFCIRPassesUtils.cpp +++ b/src/model/dfcir/lib/dfcir/conversions/DFCIRPassesUtils.cpp @@ -226,6 +226,17 @@ void insertBuffers(mlir::MLIRContext &ctx, const Buffers &buffers) { } } +void eraseOffsets(mlir::Operation *op) { + op->walk([](OffsetOp offset) { + auto input = offset->getOperand(0); + auto result = offset->getResult(0); + for (auto &operand: llvm::make_early_inc_range(result.getUses())) { + operand.set(input); + } + offset->erase(); + }); +} + Ops resolveInternalOpType(mlir::Operation *op) { auto resultType = op->getResult(0).getType(); auto dfType = llvm::dyn_cast(resultType).getDFType(); From 6c6fa3683364d056c1baec51343627dee7cdda2c Mon Sep 17 00:00:00 2001 From: Muxianesty Date: Mon, 13 Jan 2025 14:34:16 +0300 Subject: [PATCH 08/11] DFCIROperations, Scheduling: ConstantInputInterface was added; scheduling now recognizes constant input operations. --- src/model/dfcir/include/dfcir/DFCIROpInterfaces.td | 4 ++++ src/model/dfcir/include/dfcir/DFCIROperations.td | 5 +++-- src/model/dfcir/include/dfcir/conversions/DFCIRPassesUtils.h | 2 ++ .../dfcir/lib/dfcir/conversions/DFCIRASAPSchedulerPass.cpp | 4 +++- .../dfcir/lib/dfcir/conversions/DFCIRLinearSchedulerPass.cpp | 4 +++- src/model/dfcir/lib/dfcir/conversions/DFCIRPassesUtils.cpp | 4 ++++ 6 files changed, 19 insertions(+), 4 deletions(-) diff --git a/src/model/dfcir/include/dfcir/DFCIROpInterfaces.td b/src/model/dfcir/include/dfcir/DFCIROpInterfaces.td index 06f6e54..1f0073b 100644 --- a/src/model/dfcir/include/dfcir/DFCIROpInterfaces.td +++ b/src/model/dfcir/include/dfcir/DFCIROpInterfaces.td @@ -54,6 +54,10 @@ def ShiftOpInterface : OpInterface<"ShiftOpInterface"> { let cppNamespace = "mlir::dfcir"; } +def ConstantInputInterface : OpInterface<"ConstantInputInterface"> { + let cppNamespace = "mlir::dfcir"; +} + def Scheduled : OpInterface<"Scheduled"> { let cppNamespace = "mlir::dfcir"; diff --git a/src/model/dfcir/include/dfcir/DFCIROperations.td b/src/model/dfcir/include/dfcir/DFCIROperations.td index 28625fb..48a51b8 100644 --- a/src/model/dfcir/include/dfcir/DFCIROperations.td +++ b/src/model/dfcir/include/dfcir/DFCIROperations.td @@ -35,7 +35,8 @@ def KernelOp : DFCIR_Op<"kernel", } def ScalarInputOp : DFCIR_Op<"scalarInput", - [DeclareOpInterfaceMethods, DeclareOpInterfaceMethods]> { + [DeclareOpInterfaceMethods, DeclareOpInterfaceMethods, + DeclareOpInterfaceMethods]> { let arguments = (ins StrAttr:$name ); @@ -98,7 +99,7 @@ def OutputOp : DFCIR_Op<"output", }]; } -def ConstantOp : DFCIR_Op<"constant", []> { +def ConstantOp : DFCIR_Op<"constant", [DeclareOpInterfaceMethods]> { let arguments = (ins AnyAttrOf<[Builtin_IntegerAttr, Builtin_FloatAttr]>:$value); diff --git a/src/model/dfcir/include/dfcir/conversions/DFCIRPassesUtils.h b/src/model/dfcir/include/dfcir/conversions/DFCIRPassesUtils.h index 7ca1bb4..2212e69 100644 --- a/src/model/dfcir/include/dfcir/conversions/DFCIRPassesUtils.h +++ b/src/model/dfcir/include/dfcir/conversions/DFCIRPassesUtils.h @@ -137,6 +137,8 @@ void insertBuffers(mlir::MLIRContext &ctx, const Buffers &buffers); void eraseOffsets(mlir::Operation *op); +bool hasConstantInput(mlir::Operation *op); + Ops resolveInternalOpType(mlir::Operation *op); } // namespace mlir::dfcir::utils diff --git a/src/model/dfcir/lib/dfcir/conversions/DFCIRASAPSchedulerPass.cpp b/src/model/dfcir/lib/dfcir/conversions/DFCIRASAPSchedulerPass.cpp index d7692df..7149e34 100644 --- a/src/model/dfcir/lib/dfcir/conversions/DFCIRASAPSchedulerPass.cpp +++ b/src/model/dfcir/lib/dfcir/conversions/DFCIRASAPSchedulerPass.cpp @@ -82,7 +82,9 @@ class DFCIRASAPSchedulerPass (map[channel->source] + channel->source->latency + channel->offset); - if (delta) { + + using mlir::dfcir::utils::hasConstantInput; + if (delta && !hasConstantInput(channel->source->op)) { buffers[channel] = delta; } } diff --git a/src/model/dfcir/lib/dfcir/conversions/DFCIRLinearSchedulerPass.cpp b/src/model/dfcir/lib/dfcir/conversions/DFCIRLinearSchedulerPass.cpp index 2d615a7..17462a4 100644 --- a/src/model/dfcir/lib/dfcir/conversions/DFCIRLinearSchedulerPass.cpp +++ b/src/model/dfcir/lib/dfcir/conversions/DFCIRLinearSchedulerPass.cpp @@ -122,7 +122,9 @@ class DFCIRLinearSchedulerPass for (const auto &[chan, id]: bufMap) { // lp_solve positions start with 1. int32_t latency = result[id - 1]; - if (latency) { + + using mlir::dfcir::utils::hasConstantInput; + if (latency && !hasConstantInput(chan->source->op)) { buffers[chan] = latency; } } diff --git a/src/model/dfcir/lib/dfcir/conversions/DFCIRPassesUtils.cpp b/src/model/dfcir/lib/dfcir/conversions/DFCIRPassesUtils.cpp index ed7cf0a..5ac5fbc 100644 --- a/src/model/dfcir/lib/dfcir/conversions/DFCIRPassesUtils.cpp +++ b/src/model/dfcir/lib/dfcir/conversions/DFCIRPassesUtils.cpp @@ -237,6 +237,10 @@ void eraseOffsets(mlir::Operation *op) { }); } +bool hasConstantInput(mlir::Operation *op) { + return llvm::isa(op); +} + Ops resolveInternalOpType(mlir::Operation *op) { auto resultType = op->getResult(0).getType(); auto dfType = llvm::dyn_cast(resultType).getDFType(); From 6c5c190ad89da291fcb46bdadcf573f211568f07 Mon Sep 17 00:00:00 2001 From: Muxianesty Date: Mon, 13 Jan 2025 15:13:58 +0300 Subject: [PATCH 09/11] DFLatencyConfig, LatencyConfig, Tests: init-list constructors for *LatencyConfig-objects were added; tests were updated according to new features. --- .github/workflows/synth-sv.yml | 10 +- examples/addconst/addconst.h | 7 +- ...mul_int3.json => add_int_2_mul_int_3.json} | 0 ...mul_int3.json => add_int_2_mul_int_3.json} | 0 ...mul_int3.json => add_int_2_mul_int_3.json} | 0 ...l_int15.json => add_int_8_mul_int_15.json} | 0 ...mul_int3.json => add_int_2_mul_int_3.json} | 0 ...mul_int3.json => add_int_2_mul_int_3.json} | 0 .../include/dfcir/conversions/DFCIRPasses.h | 13 +- src/model/dfcxx/include/dfcxx/typedefs.h | 12 + test/data/addconst.mlir | 9 +- test/data/idct.mlir | 2438 ++++++++--------- test/data/matrixmul2.mlir | 34 +- test/data/movingsum.mlir | 4 +- test/data/muxmul.mlir | 4 +- test/data/polynomial2.mlir | 6 +- test/data/scalar3.mlir | 10 +- test/model/dfcxx/addconst.cpp | 18 +- test/model/dfcxx/idct.cpp | 26 +- test/model/dfcxx/matrixmul2.cpp | 22 +- test/model/dfcxx/movingsum.cpp | 36 +- test/model/dfcxx/muxmul.cpp | 22 +- test/model/dfcxx/output_formats.cpp | 9 +- test/model/dfcxx/polynomial2.cpp | 44 +- test/model/dfcxx/scalar3.cpp | 22 +- 25 files changed, 1413 insertions(+), 1333 deletions(-) rename examples/matrixmul2/{add_int_2_mul_int3.json => add_int_2_mul_int_3.json} (100%) rename examples/muxmul/{add_int_2_mul_int3.json => add_int_2_mul_int_3.json} (100%) rename examples/polynomial2/{add_int_2_mul_int3.json => add_int_2_mul_int_3.json} (100%) rename examples/polynomial2/{add_int_8_mul_int15.json => add_int_8_mul_int_15.json} (100%) rename examples/polynomial2_inst/{add_int_2_mul_int3.json => add_int_2_mul_int_3.json} (100%) rename examples/scalar3/{add_int_2_mul_int3.json => add_int_2_mul_int_3.json} (100%) diff --git a/.github/workflows/synth-sv.yml b/.github/workflows/synth-sv.yml index 5525477..55df4da 100644 --- a/.github/workflows/synth-sv.yml +++ b/.github/workflows/synth-sv.yml @@ -32,7 +32,7 @@ jobs: config: add_int_2 ## matrixmul configs. - kernel: matrixmul2 - config: add_int_2_mul_int3 + config: add_int_2_mul_int_3 ## movingsum configs. - kernel: movingsum config: add_int_2 @@ -40,15 +40,15 @@ jobs: config: add_int_8 ## muxmul configs. - kernel: muxmul - config: add_int_2_mul_int3 + config: add_int_2_mul_int_3 ## polynomial2 configs. - kernel: polynomial2 - config: add_int_2_mul_int3 + config: add_int_2_mul_int_3 - kernel: polynomial2 - config: add_int_8_mul_int15 + config: add_int_8_mul_int_15 ## scalar3 configs. - kernel: scalar3 - config: add_int_2_mul_int3 + config: add_int_2_mul_int_3 runs-on: ubuntu-latest env: diff --git a/examples/addconst/addconst.h b/examples/addconst/addconst.h index c269274..059e5df 100644 --- a/examples/addconst/addconst.h +++ b/examples/addconst/addconst.h @@ -23,9 +23,10 @@ class AddConst : public dfcxx::Kernel { const DFType type = dfUInt(32); DFVariable x = io.input("x", type); DFVariable const5 = constant.var(type, uint64_t(5)); - DFVariable sum1 = x + const5; - DFVariable sum2 = sum1 + x; + DFVariable sum1 = x + x; + DFVariable sum2 = sum1 + const5; + DFVariable sum3 = sum2 + x; DFVariable out = io.output("out", type); - out.connect(sum2); + out.connect(sum3); } }; diff --git a/examples/matrixmul2/add_int_2_mul_int3.json b/examples/matrixmul2/add_int_2_mul_int_3.json similarity index 100% rename from examples/matrixmul2/add_int_2_mul_int3.json rename to examples/matrixmul2/add_int_2_mul_int_3.json diff --git a/examples/muxmul/add_int_2_mul_int3.json b/examples/muxmul/add_int_2_mul_int_3.json similarity index 100% rename from examples/muxmul/add_int_2_mul_int3.json rename to examples/muxmul/add_int_2_mul_int_3.json diff --git a/examples/polynomial2/add_int_2_mul_int3.json b/examples/polynomial2/add_int_2_mul_int_3.json similarity index 100% rename from examples/polynomial2/add_int_2_mul_int3.json rename to examples/polynomial2/add_int_2_mul_int_3.json diff --git a/examples/polynomial2/add_int_8_mul_int15.json b/examples/polynomial2/add_int_8_mul_int_15.json similarity index 100% rename from examples/polynomial2/add_int_8_mul_int15.json rename to examples/polynomial2/add_int_8_mul_int_15.json diff --git a/examples/polynomial2_inst/add_int_2_mul_int3.json b/examples/polynomial2_inst/add_int_2_mul_int_3.json similarity index 100% rename from examples/polynomial2_inst/add_int_2_mul_int3.json rename to examples/polynomial2_inst/add_int_2_mul_int_3.json diff --git a/examples/scalar3/add_int_2_mul_int3.json b/examples/scalar3/add_int_2_mul_int_3.json similarity index 100% rename from examples/scalar3/add_int_2_mul_int3.json rename to examples/scalar3/add_int_2_mul_int_3.json diff --git a/src/model/dfcir/include/dfcir/conversions/DFCIRPasses.h b/src/model/dfcir/include/dfcir/conversions/DFCIRPasses.h index d5f40bc..3b6543a 100644 --- a/src/model/dfcir/include/dfcir/conversions/DFCIRPasses.h +++ b/src/model/dfcir/include/dfcir/conversions/DFCIRPasses.h @@ -14,7 +14,8 @@ #include "mlir/Pass/Pass.h" #include "llvm/Support/raw_ostream.h" -#include "memory" +#include +#include namespace mlir::dfcir { @@ -61,8 +62,18 @@ enum Ops { } // namespace mlir::dfcir struct LatencyConfig { +public: std::unordered_map internalOps; std::unordered_map externalOps; + + LatencyConfig() = default; + + LatencyConfig(const LatencyConfig &) = default; + + LatencyConfig( + std::initializer_list> internals, + std::initializer_list> externals + ) : internalOps(internals), externalOps(externals) {} }; namespace mlir::dfcir { diff --git a/src/model/dfcxx/include/dfcxx/typedefs.h b/src/model/dfcxx/include/dfcxx/typedefs.h index 77641a2..ca4c158 100644 --- a/src/model/dfcxx/include/dfcxx/typedefs.h +++ b/src/model/dfcxx/include/dfcxx/typedefs.h @@ -10,6 +10,7 @@ #define DFCXX_TYPEDEFS_H #include +#include #include #include @@ -76,8 +77,19 @@ enum class OutputFormatID : uint8_t { } // namespace dfcxx struct DFLatencyConfig { +public: std::unordered_map internalOps; std::unordered_map externalOps; + + DFLatencyConfig() = default; + + DFLatencyConfig(const DFLatencyConfig &) = default; + + DFLatencyConfig( + std::initializer_list> internals, + std::initializer_list> externals + ) : internalOps(internals), externalOps(externals) {} + }; typedef std::unordered_map DFOutputPaths; diff --git a/test/data/addconst.mlir b/test/data/addconst.mlir index a31dc45..ba00337 100644 --- a/test/data/addconst.mlir +++ b/test/data/addconst.mlir @@ -2,9 +2,10 @@ module { dfcir.kernel "AddConst" { %0 = dfcir.constant> 5 : ui32 %1 = dfcir.input> ("x") - %2 = dfcir.add(%1 : !dfcir.stream>, %0 : !dfcir.const>) : !dfcir.stream> - %3 = dfcir.add(%2 : !dfcir.stream>, %1 : !dfcir.stream>) : !dfcir.stream> - %4 = dfcir.output> ("out") {operandSegmentSizes = array} - dfcir.connect(%4 : !dfcir.stream>, %3 : !dfcir.stream>) + %2 = dfcir.add[?] (%1 : !dfcir.stream>, %1 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %3 = dfcir.add[?] (%2 : !dfcir.stream>, %0 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %4 = dfcir.add[?] (%3 : !dfcir.stream>, %1 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %5 = dfcir.output> ("out") {operandSegmentSizes = array} + dfcir.connect(%5 : !dfcir.stream>, %4 : !dfcir.stream>) } } diff --git a/test/data/idct.mlir b/test/data/idct.mlir index 5187405..bddbacc 100644 --- a/test/data/idct.mlir +++ b/test/data/idct.mlir @@ -1,1254 +1,1254 @@ module { dfcir.kernel "IDCT" { - %0 = dfcir.input> ("x63") - %1 = dfcir.input> ("x62") - %2 = dfcir.input> ("x61") - %3 = dfcir.input> ("x60") - %4 = dfcir.shl(%3 : !dfcir.stream>, 11 : i32) : !dfcir.stream> - %5 = dfcir.input> ("x58") - %6 = dfcir.add(%5 : !dfcir.stream>, %1 : !dfcir.stream>) : !dfcir.stream> - %7 = dfcir.input> ("x57") - %8 = dfcir.add(%7 : !dfcir.stream>, %0 : !dfcir.stream>) : !dfcir.stream> - %9 = dfcir.input> ("x56") - %10 = dfcir.shl(%9 : !dfcir.stream>, 11 : i32) : !dfcir.stream> - %11 = dfcir.input> ("x55") - %12 = dfcir.input> ("x54") - %13 = dfcir.input> ("x18") - %14 = dfcir.constant> 1108 : si32 - %15 = dfcir.mul(%6 : !dfcir.stream>, %14 : !dfcir.const>) : !dfcir.stream> - %16 = dfcir.input> ("x39") - %17 = dfcir.input> ("x38") - %18 = dfcir.input> ("x53") - %19 = dfcir.input> ("x16") - %20 = dfcir.shl(%19 : !dfcir.stream>, 11 : i32) : !dfcir.stream> - %21 = dfcir.input> ("x26") - %22 = dfcir.input> ("x25") - %23 = dfcir.input> ("x24") - %24 = dfcir.shl(%23 : !dfcir.stream>, 11 : i32) : !dfcir.stream> - %25 = dfcir.input> ("x23") - %26 = dfcir.input> ("x12") - %27 = dfcir.shl(%26 : !dfcir.stream>, 11 : i32) : !dfcir.stream> - %28 = dfcir.input> ("x22") - %29 = dfcir.add(%13 : !dfcir.stream>, %28 : !dfcir.stream>) : !dfcir.stream> - %30 = dfcir.mul(%29 : !dfcir.stream>, %14 : !dfcir.const>) : !dfcir.stream> - %31 = dfcir.input> ("x52") - %32 = dfcir.shl(%31 : !dfcir.stream>, 11 : i32) : !dfcir.stream> - %33 = dfcir.input> ("x15") - %34 = dfcir.input> ("x9") - %35 = dfcir.add(%34 : !dfcir.stream>, %33 : !dfcir.stream>) : !dfcir.stream> - %36 = dfcir.input> ("x49") - %37 = dfcir.add(%36 : !dfcir.stream>, %11 : !dfcir.stream>) : !dfcir.stream> - %38 = dfcir.input> ("x32") - %39 = dfcir.shl(%38 : !dfcir.stream>, 11 : i32) : !dfcir.stream> - %40 = dfcir.input> ("x34") - %41 = dfcir.add(%40 : !dfcir.stream>, %17 : !dfcir.stream>) : !dfcir.stream> - %42 = dfcir.mul(%41 : !dfcir.stream>, %14 : !dfcir.const>) : !dfcir.stream> - %43 = dfcir.input> ("x6") - %44 = dfcir.input> ("x51") - %45 = dfcir.add(%18 : !dfcir.stream>, %44 : !dfcir.stream>) : !dfcir.stream> - %46 = dfcir.input> ("x14") - %47 = dfcir.input> ("x4") - %48 = dfcir.shl(%47 : !dfcir.stream>, 11 : i32) : !dfcir.stream> - %49 = dfcir.input> ("x59") - %50 = dfcir.add(%2 : !dfcir.stream>, %49 : !dfcir.stream>) : !dfcir.stream> - %51 = dfcir.input> ("x1") - %52 = dfcir.input> ("x5") - %53 = dfcir.constant> 1609 : si32 - %54 = dfcir.input> ("x7") - %55 = dfcir.add(%51 : !dfcir.stream>, %54 : !dfcir.stream>) : !dfcir.stream> - %56 = dfcir.input> ("x11") - %57 = dfcir.input> ("x17") - %58 = dfcir.add(%57 : !dfcir.stream>, %25 : !dfcir.stream>) : !dfcir.stream> - %59 = dfcir.constant> 2676 : si32 - %60 = dfcir.sub(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %61 = dfcir.add(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %62 = dfcir.sub(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %63 = dfcir.add(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %64 = dfcir.sub(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %65 = dfcir.add(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %66 = dfcir.sub(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %67 = dfcir.add(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %68 = dfcir.sub(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %69 = dfcir.add(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %70 = dfcir.sub(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %71 = dfcir.add(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %72 = dfcir.sub(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %73 = dfcir.add(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %74 = dfcir.sub(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %75 = dfcir.add(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %76 = dfcir.sub(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %77 = dfcir.mul(%76 : !dfcir.const>, %5 : !dfcir.stream>) : !dfcir.stream> - %78 = dfcir.add(%15 : !dfcir.stream>, %77 : !dfcir.stream>) : !dfcir.stream> - %79 = dfcir.add(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %80 = dfcir.mul(%79 : !dfcir.const>, %1 : !dfcir.stream>) : !dfcir.stream> - %81 = dfcir.sub(%15 : !dfcir.stream>, %80 : !dfcir.stream>) : !dfcir.stream> - %82 = dfcir.sub(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %83 = dfcir.add(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %84 = dfcir.mul(%83 : !dfcir.const>, %12 : !dfcir.stream>) : !dfcir.stream> - %85 = dfcir.sub(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %86 = dfcir.add(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %87 = dfcir.sub(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %88 = dfcir.mul(%87 : !dfcir.const>, %40 : !dfcir.stream>) : !dfcir.stream> - %89 = dfcir.add(%42 : !dfcir.stream>, %88 : !dfcir.stream>) : !dfcir.stream> - %90 = dfcir.add(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %91 = dfcir.mul(%90 : !dfcir.const>, %17 : !dfcir.stream>) : !dfcir.stream> - %92 = dfcir.sub(%42 : !dfcir.stream>, %91 : !dfcir.stream>) : !dfcir.stream> - %93 = dfcir.sub(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %94 = dfcir.mul(%93 : !dfcir.const>, %21 : !dfcir.stream>) : !dfcir.stream> - %95 = dfcir.add(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %96 = dfcir.sub(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %97 = dfcir.mul(%96 : !dfcir.const>, %13 : !dfcir.stream>) : !dfcir.stream> - %98 = dfcir.add(%30 : !dfcir.stream>, %97 : !dfcir.stream>) : !dfcir.stream> - %99 = dfcir.add(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %100 = dfcir.mul(%99 : !dfcir.const>, %28 : !dfcir.stream>) : !dfcir.stream> - %101 = dfcir.sub(%30 : !dfcir.stream>, %100 : !dfcir.stream>) : !dfcir.stream> - %102 = dfcir.sub(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %103 = dfcir.add(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %104 = dfcir.mul(%103 : !dfcir.const>, %46 : !dfcir.stream>) : !dfcir.stream> - %105 = dfcir.sub(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %106 = dfcir.add(%59 : !dfcir.const>, %14 : !dfcir.const>) : !dfcir.const> - %107 = dfcir.mul(%106 : !dfcir.const>, %43 : !dfcir.stream>) : !dfcir.stream> - %108 = dfcir.input> ("x21") - %109 = dfcir.constant> 8192 : si32 - %110 = dfcir.input> ("x37") - %111 = dfcir.constant> 181 : si32 - %112 = dfcir.input> ("x31") - %113 = dfcir.add(%22 : !dfcir.stream>, %112 : !dfcir.stream>) : !dfcir.stream> - %114 = dfcir.input> ("x48") - %115 = dfcir.shl(%114 : !dfcir.stream>, 11 : i32) : !dfcir.stream> - %116 = dfcir.constant> 565 : si32 - %117 = dfcir.mul(%8 : !dfcir.stream>, %116 : !dfcir.const>) : !dfcir.stream> - %118 = dfcir.mul(%37 : !dfcir.stream>, %116 : !dfcir.const>) : !dfcir.stream> - %119 = dfcir.mul(%113 : !dfcir.stream>, %116 : !dfcir.const>) : !dfcir.stream> - %120 = dfcir.mul(%58 : !dfcir.stream>, %116 : !dfcir.const>) : !dfcir.stream> - %121 = dfcir.mul(%35 : !dfcir.stream>, %116 : !dfcir.const>) : !dfcir.stream> - %122 = dfcir.mul(%55 : !dfcir.stream>, %116 : !dfcir.const>) : !dfcir.stream> - %123 = dfcir.input> ("x8") - %124 = dfcir.shl(%123 : !dfcir.stream>, 11 : i32) : !dfcir.stream> - %125 = dfcir.input> ("x10") - %126 = dfcir.mul(%102 : !dfcir.const>, %125 : !dfcir.stream>) : !dfcir.stream> - %127 = dfcir.add(%125 : !dfcir.stream>, %46 : !dfcir.stream>) : !dfcir.stream> - %128 = dfcir.mul(%127 : !dfcir.stream>, %14 : !dfcir.const>) : !dfcir.stream> - %129 = dfcir.add(%128 : !dfcir.stream>, %126 : !dfcir.stream>) : !dfcir.stream> - %130 = dfcir.sub(%128 : !dfcir.stream>, %104 : !dfcir.stream>) : !dfcir.stream> - %131 = dfcir.input> ("x20") - %132 = dfcir.shl(%131 : !dfcir.stream>, 11 : i32) : !dfcir.stream> - %133 = dfcir.input> ("x2") - %134 = dfcir.mul(%105 : !dfcir.const>, %133 : !dfcir.stream>) : !dfcir.stream> - %135 = dfcir.add(%133 : !dfcir.stream>, %43 : !dfcir.stream>) : !dfcir.stream> - %136 = dfcir.mul(%135 : !dfcir.stream>, %14 : !dfcir.const>) : !dfcir.stream> - %137 = dfcir.add(%136 : !dfcir.stream>, %134 : !dfcir.stream>) : !dfcir.stream> - %138 = dfcir.sub(%136 : !dfcir.stream>, %107 : !dfcir.stream>) : !dfcir.stream> - %139 = dfcir.input> ("x27") - %140 = dfcir.input> ("x3") - %141 = dfcir.add(%52 : !dfcir.stream>, %140 : !dfcir.stream>) : !dfcir.stream> - %142 = dfcir.input> ("x50") - %143 = dfcir.mul(%82 : !dfcir.const>, %142 : !dfcir.stream>) : !dfcir.stream> - %144 = dfcir.add(%142 : !dfcir.stream>, %12 : !dfcir.stream>) : !dfcir.stream> - %145 = dfcir.mul(%144 : !dfcir.stream>, %14 : !dfcir.const>) : !dfcir.stream> - %146 = dfcir.add(%145 : !dfcir.stream>, %143 : !dfcir.stream>) : !dfcir.stream> - %147 = dfcir.sub(%145 : !dfcir.stream>, %84 : !dfcir.stream>) : !dfcir.stream> - %148 = dfcir.input> ("x13") - %149 = dfcir.add(%148 : !dfcir.stream>, %56 : !dfcir.stream>) : !dfcir.stream> - %150 = dfcir.constant> 2841 : si32 - %151 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %152 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %153 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %154 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %155 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %156 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %157 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %158 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %159 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %160 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %161 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %162 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %163 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %164 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %165 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %166 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %167 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %168 = dfcir.mul(%167 : !dfcir.const>, %0 : !dfcir.stream>) : !dfcir.stream> - %169 = dfcir.sub(%117 : !dfcir.stream>, %168 : !dfcir.stream>) : !dfcir.stream> - %170 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %171 = dfcir.mul(%170 : !dfcir.const>, %7 : !dfcir.stream>) : !dfcir.stream> - %172 = dfcir.add(%117 : !dfcir.stream>, %171 : !dfcir.stream>) : !dfcir.stream> - %173 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %174 = dfcir.mul(%173 : !dfcir.const>, %11 : !dfcir.stream>) : !dfcir.stream> - %175 = dfcir.sub(%118 : !dfcir.stream>, %174 : !dfcir.stream>) : !dfcir.stream> - %176 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %177 = dfcir.mul(%176 : !dfcir.const>, %36 : !dfcir.stream>) : !dfcir.stream> - %178 = dfcir.add(%118 : !dfcir.stream>, %177 : !dfcir.stream>) : !dfcir.stream> - %179 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %180 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %181 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %182 = dfcir.mul(%181 : !dfcir.const>, %16 : !dfcir.stream>) : !dfcir.stream> - %183 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %184 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %185 = dfcir.mul(%184 : !dfcir.const>, %112 : !dfcir.stream>) : !dfcir.stream> - %186 = dfcir.sub(%119 : !dfcir.stream>, %185 : !dfcir.stream>) : !dfcir.stream> - %187 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %188 = dfcir.mul(%187 : !dfcir.const>, %22 : !dfcir.stream>) : !dfcir.stream> - %189 = dfcir.add(%119 : !dfcir.stream>, %188 : !dfcir.stream>) : !dfcir.stream> - %190 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %191 = dfcir.mul(%190 : !dfcir.const>, %25 : !dfcir.stream>) : !dfcir.stream> - %192 = dfcir.sub(%120 : !dfcir.stream>, %191 : !dfcir.stream>) : !dfcir.stream> - %193 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %194 = dfcir.mul(%193 : !dfcir.const>, %57 : !dfcir.stream>) : !dfcir.stream> - %195 = dfcir.add(%120 : !dfcir.stream>, %194 : !dfcir.stream>) : !dfcir.stream> - %196 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %197 = dfcir.mul(%196 : !dfcir.const>, %33 : !dfcir.stream>) : !dfcir.stream> - %198 = dfcir.sub(%121 : !dfcir.stream>, %197 : !dfcir.stream>) : !dfcir.stream> - %199 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %200 = dfcir.mul(%199 : !dfcir.const>, %34 : !dfcir.stream>) : !dfcir.stream> - %201 = dfcir.add(%121 : !dfcir.stream>, %200 : !dfcir.stream>) : !dfcir.stream> - %202 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %203 = dfcir.mul(%202 : !dfcir.const>, %54 : !dfcir.stream>) : !dfcir.stream> - %204 = dfcir.sub(%122 : !dfcir.stream>, %203 : !dfcir.stream>) : !dfcir.stream> - %205 = dfcir.sub(%150 : !dfcir.const>, %116 : !dfcir.const>) : !dfcir.const> - %206 = dfcir.mul(%205 : !dfcir.const>, %51 : !dfcir.stream>) : !dfcir.stream> - %207 = dfcir.add(%122 : !dfcir.stream>, %206 : !dfcir.stream>) : !dfcir.stream> - %208 = dfcir.constant> 128 : si32 - %209 = dfcir.add(%10 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %210 = dfcir.sub(%209 : !dfcir.stream>, %4 : !dfcir.stream>) : !dfcir.stream> - %211 = dfcir.sub(%210 : !dfcir.stream>, %81 : !dfcir.stream>) : !dfcir.stream> - %212 = dfcir.add(%210 : !dfcir.stream>, %81 : !dfcir.stream>) : !dfcir.stream> - %213 = dfcir.add(%209 : !dfcir.stream>, %4 : !dfcir.stream>) : !dfcir.stream> - %214 = dfcir.sub(%213 : !dfcir.stream>, %78 : !dfcir.stream>) : !dfcir.stream> - %215 = dfcir.add(%213 : !dfcir.stream>, %78 : !dfcir.stream>) : !dfcir.stream> - %216 = dfcir.add(%115 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %217 = dfcir.sub(%216 : !dfcir.stream>, %32 : !dfcir.stream>) : !dfcir.stream> - %218 = dfcir.sub(%217 : !dfcir.stream>, %147 : !dfcir.stream>) : !dfcir.stream> - %219 = dfcir.add(%217 : !dfcir.stream>, %147 : !dfcir.stream>) : !dfcir.stream> - %220 = dfcir.add(%216 : !dfcir.stream>, %32 : !dfcir.stream>) : !dfcir.stream> - %221 = dfcir.sub(%220 : !dfcir.stream>, %146 : !dfcir.stream>) : !dfcir.stream> - %222 = dfcir.add(%220 : !dfcir.stream>, %146 : !dfcir.stream>) : !dfcir.stream> - %223 = dfcir.add(%39 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %224 = dfcir.add(%24 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %225 = dfcir.add(%20 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %226 = dfcir.sub(%225 : !dfcir.stream>, %132 : !dfcir.stream>) : !dfcir.stream> - %227 = dfcir.sub(%226 : !dfcir.stream>, %101 : !dfcir.stream>) : !dfcir.stream> - %228 = dfcir.add(%226 : !dfcir.stream>, %101 : !dfcir.stream>) : !dfcir.stream> - %229 = dfcir.add(%225 : !dfcir.stream>, %132 : !dfcir.stream>) : !dfcir.stream> - %230 = dfcir.sub(%229 : !dfcir.stream>, %98 : !dfcir.stream>) : !dfcir.stream> - %231 = dfcir.add(%229 : !dfcir.stream>, %98 : !dfcir.stream>) : !dfcir.stream> - %232 = dfcir.add(%124 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %233 = dfcir.sub(%232 : !dfcir.stream>, %27 : !dfcir.stream>) : !dfcir.stream> - %234 = dfcir.sub(%233 : !dfcir.stream>, %130 : !dfcir.stream>) : !dfcir.stream> - %235 = dfcir.add(%233 : !dfcir.stream>, %130 : !dfcir.stream>) : !dfcir.stream> - %236 = dfcir.add(%232 : !dfcir.stream>, %27 : !dfcir.stream>) : !dfcir.stream> - %237 = dfcir.sub(%236 : !dfcir.stream>, %129 : !dfcir.stream>) : !dfcir.stream> - %238 = dfcir.add(%236 : !dfcir.stream>, %129 : !dfcir.stream>) : !dfcir.stream> - %239 = dfcir.constant> 4 : si32 - %240 = dfcir.input> ("x28") - %241 = dfcir.shl(%240 : !dfcir.stream>, 11 : i32) : !dfcir.stream> - %242 = dfcir.sub(%224 : !dfcir.stream>, %241 : !dfcir.stream>) : !dfcir.stream> - %243 = dfcir.add(%224 : !dfcir.stream>, %241 : !dfcir.stream>) : !dfcir.stream> - %244 = dfcir.input> ("x0") - %245 = dfcir.shl(%244 : !dfcir.stream>, 11 : i32) : !dfcir.stream> - %246 = dfcir.add(%245 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %247 = dfcir.sub(%246 : !dfcir.stream>, %48 : !dfcir.stream>) : !dfcir.stream> - %248 = dfcir.sub(%247 : !dfcir.stream>, %138 : !dfcir.stream>) : !dfcir.stream> - %249 = dfcir.add(%247 : !dfcir.stream>, %138 : !dfcir.stream>) : !dfcir.stream> - %250 = dfcir.add(%246 : !dfcir.stream>, %48 : !dfcir.stream>) : !dfcir.stream> - %251 = dfcir.sub(%250 : !dfcir.stream>, %137 : !dfcir.stream>) : !dfcir.stream> - %252 = dfcir.add(%250 : !dfcir.stream>, %137 : !dfcir.stream>) : !dfcir.stream> - %253 = dfcir.input> ("x33") - %254 = dfcir.mul(%183 : !dfcir.const>, %253 : !dfcir.stream>) : !dfcir.stream> - %255 = dfcir.add(%253 : !dfcir.stream>, %16 : !dfcir.stream>) : !dfcir.stream> - %256 = dfcir.mul(%255 : !dfcir.stream>, %116 : !dfcir.const>) : !dfcir.stream> - %257 = dfcir.sub(%256 : !dfcir.stream>, %182 : !dfcir.stream>) : !dfcir.stream> - %258 = dfcir.add(%256 : !dfcir.stream>, %254 : !dfcir.stream>) : !dfcir.stream> - %259 = dfcir.input> ("x19") - %260 = dfcir.add(%108 : !dfcir.stream>, %259 : !dfcir.stream>) : !dfcir.stream> - %261 = dfcir.input> ("x40") - %262 = dfcir.shl(%261 : !dfcir.stream>, 11 : i32) : !dfcir.stream> - %263 = dfcir.add(%262 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %264 = dfcir.input> ("x29") - %265 = dfcir.add(%264 : !dfcir.stream>, %139 : !dfcir.stream>) : !dfcir.stream> - %266 = dfcir.constant> 2408 : si32 - %267 = dfcir.add(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %268 = dfcir.sub(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %269 = dfcir.add(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %270 = dfcir.sub(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %271 = dfcir.add(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %272 = dfcir.sub(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %273 = dfcir.add(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %274 = dfcir.sub(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %275 = dfcir.add(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %276 = dfcir.sub(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %277 = dfcir.add(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %278 = dfcir.sub(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %279 = dfcir.add(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %280 = dfcir.sub(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %281 = dfcir.add(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %282 = dfcir.sub(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %283 = dfcir.add(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %284 = dfcir.mul(%283 : !dfcir.const>, %49 : !dfcir.stream>) : !dfcir.stream> - %285 = dfcir.sub(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %286 = dfcir.mul(%285 : !dfcir.const>, %2 : !dfcir.stream>) : !dfcir.stream> - %287 = dfcir.mul(%266 : !dfcir.const>, %50 : !dfcir.stream>) : !dfcir.stream> - %288 = dfcir.sub(%287 : !dfcir.stream>, %284 : !dfcir.stream>) : !dfcir.stream> - %289 = dfcir.sub(%169 : !dfcir.stream>, %288 : !dfcir.stream>) : !dfcir.stream> - %290 = dfcir.add(%169 : !dfcir.stream>, %288 : !dfcir.stream>) : !dfcir.stream> - %291 = dfcir.sub(%214 : !dfcir.stream>, %290 : !dfcir.stream>) : !dfcir.stream> - %292 = dfcir.shr(%291 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %293 = dfcir.mul(%157 : !dfcir.const>, %292 : !dfcir.stream>) : !dfcir.stream> - %294 = dfcir.add(%214 : !dfcir.stream>, %290 : !dfcir.stream>) : !dfcir.stream> + %0 = dfcir.constant> 4017 : si32 + %1 = dfcir.constant> 799 : si32 + %2 = dfcir.constant> 3406 : si32 + %3 = dfcir.constant> 2276 : si32 + %4 = dfcir.constant> 3784 : si32 + %5 = dfcir.constant> 4017 : si32 + %6 = dfcir.constant> 2276 : si32 + %7 = dfcir.constant> 1568 : si32 + %8 = dfcir.constant> 3784 : si32 + %9 = dfcir.constant> 2276 : si32 + %10 = dfcir.constant> 3784 : si32 + %11 = dfcir.constant> 799 : si32 + %12 = dfcir.constant> 3406 : si32 + %13 = dfcir.constant> 4017 : si32 + %14 = dfcir.constant> 799 : si32 + %15 = dfcir.constant> 3406 : si32 + %16 = dfcir.constant> 3784 : si32 + %17 = dfcir.constant> 4017 : si32 + %18 = dfcir.constant> 799 : si32 + %19 = dfcir.constant> 2276 : si32 + %20 = dfcir.constant> 3784 : si32 + %21 = dfcir.constant> 1568 : si32 + %22 = dfcir.constant> 4017 : si32 + %23 = dfcir.constant> 3784 : si32 + %24 = dfcir.constant> 799 : si32 + %25 = dfcir.constant> 2276 : si32 + %26 = dfcir.constant> 1568 : si32 + %27 = dfcir.input> ("x46") + %28 = dfcir.constant> 1568 : si32 + %29 = dfcir.constant> 799 : si32 + %30 = dfcir.constant> 3784 : si32 + %31 = dfcir.input> ("x45") + %32 = dfcir.input> ("x40") + %33 = dfcir.shl(%32 : !dfcir.stream>, 11 : i32) : !dfcir.stream> + %34 = dfcir.constant> 1568 : si32 + %35 = dfcir.input> ("x38") + %36 = dfcir.input> ("x30") + %37 = dfcir.input> ("x27") + %38 = dfcir.constant> 3406 : si32 + %39 = dfcir.constant> 3784 : si32 + %40 = dfcir.input> ("x24") + %41 = dfcir.shl(%40 : !dfcir.stream>, 11 : i32) : !dfcir.stream> + %42 = dfcir.constant> 2276 : si32 + %43 = dfcir.input> ("x20") + %44 = dfcir.shl(%43 : !dfcir.stream>, 11 : i32) : !dfcir.stream> + %45 = dfcir.constant> 1568 : si32 + %46 = dfcir.constant> 1568 : si32 + %47 = dfcir.input> ("x26") + %48 = dfcir.mul[?] (%47 : !dfcir.stream>, %45 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %49 = dfcir.add[?] (%47 : !dfcir.stream>, %36 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %50 = dfcir.input> ("x19") + %51 = dfcir.input> ("x51") + %52 = dfcir.constant> 3406 : si32 + %53 = dfcir.constant> 4017 : si32 + %54 = dfcir.input> ("x22") + %55 = dfcir.mul[?] (%54 : !dfcir.stream>, %39 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %56 = dfcir.input> ("x23") + %57 = dfcir.input> ("x2") + %58 = dfcir.input> ("x43") + %59 = dfcir.add[?] (%31 : !dfcir.stream>, %58 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %60 = dfcir.input> ("x7") + %61 = dfcir.constant> 4017 : si32 + %62 = dfcir.constant> 181 : si32 + %63 = dfcir.constant> 1108 : si32 + %64 = dfcir.mul[?] (%49 : !dfcir.stream>, %63 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %65 = dfcir.add[?] (%64 : !dfcir.stream>, %48 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %66 = dfcir.input> ("x48") + %67 = dfcir.shl(%66 : !dfcir.stream>, 11 : i32) : !dfcir.stream> + %68 = dfcir.constant> 2276 : si32 + %69 = dfcir.constant> 3406 : si32 + %70 = dfcir.input> ("x41") + %71 = dfcir.constant> 1609 : si32 + %72 = dfcir.constant> 799 : si32 + %73 = dfcir.constant> 2408 : si32 + %74 = dfcir.mul[?] (%59 : !dfcir.stream>, %73 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %75 = dfcir.input> ("x61") + %76 = dfcir.constant> 4017 : si32 + %77 = dfcir.constant> 3784 : si32 + %78 = dfcir.mul[?] (%36 : !dfcir.stream>, %77 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %79 = dfcir.sub[?] (%64 : !dfcir.stream>, %78 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %80 = dfcir.input> ("x39") + %81 = dfcir.mul[?] (%80 : !dfcir.stream>, %38 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %82 = dfcir.constant> 2276 : si32 + %83 = dfcir.input> ("x33") + %84 = dfcir.mul[?] (%83 : !dfcir.stream>, %68 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %85 = dfcir.add[?] (%83 : !dfcir.stream>, %80 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %86 = dfcir.input> ("x25") + %87 = dfcir.constant> 799 : si32 + %88 = dfcir.input> ("x42") + %89 = dfcir.add[?] (%88 : !dfcir.stream>, %27 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %90 = dfcir.mul[?] (%89 : !dfcir.stream>, %63 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %91 = dfcir.input> ("x6") + %92 = dfcir.add[?] (%57 : !dfcir.stream>, %91 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %93 = dfcir.mul[?] (%92 : !dfcir.stream>, %63 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %94 = dfcir.constant> 3784 : si32 + %95 = dfcir.input> ("x36") + %96 = dfcir.shl(%95 : !dfcir.stream>, 11 : i32) : !dfcir.stream> + %97 = dfcir.input> ("x12") + %98 = dfcir.shl(%97 : !dfcir.stream>, 11 : i32) : !dfcir.stream> + %99 = dfcir.input> ("x3") + %100 = dfcir.mul[?] (%99 : !dfcir.stream>, %53 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %101 = dfcir.constant> 1568 : si32 + %102 = dfcir.constant> 565 : si32 + %103 = dfcir.mul[?] (%85 : !dfcir.stream>, %102 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %104 = dfcir.sub[?] (%103 : !dfcir.stream>, %81 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %105 = dfcir.add[?] (%103 : !dfcir.stream>, %84 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %106 = dfcir.input> ("x17") + %107 = dfcir.add[?] (%106 : !dfcir.stream>, %56 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %108 = dfcir.mul[?] (%107 : !dfcir.stream>, %102 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %109 = dfcir.constant> 2276 : si32 + %110 = dfcir.mul[?] (%106 : !dfcir.stream>, %109 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %111 = dfcir.add[?] (%108 : !dfcir.stream>, %110 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %112 = dfcir.constant> 799 : si32 + %113 = dfcir.input> ("x47") + %114 = dfcir.add[?] (%70 : !dfcir.stream>, %113 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %115 = dfcir.mul[?] (%114 : !dfcir.stream>, %102 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %116 = dfcir.constant> 3784 : si32 + %117 = dfcir.input> ("x4") + %118 = dfcir.shl(%117 : !dfcir.stream>, 11 : i32) : !dfcir.stream> + %119 = dfcir.constant> 3784 : si32 + %120 = dfcir.mul[?] (%27 : !dfcir.stream>, %119 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %121 = dfcir.sub[?] (%90 : !dfcir.stream>, %120 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %122 = dfcir.input> ("x31") + %123 = dfcir.mul[?] (%122 : !dfcir.stream>, %52 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %124 = dfcir.add[?] (%86 : !dfcir.stream>, %122 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %125 = dfcir.mul[?] (%124 : !dfcir.stream>, %102 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %126 = dfcir.sub[?] (%125 : !dfcir.stream>, %123 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %127 = dfcir.input> ("x1") + %128 = dfcir.mul[?] (%127 : !dfcir.stream>, %42 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %129 = dfcir.add[?] (%127 : !dfcir.stream>, %60 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %130 = dfcir.mul[?] (%129 : !dfcir.stream>, %102 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %131 = dfcir.add[?] (%130 : !dfcir.stream>, %128 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %132 = dfcir.input> ("x44") + %133 = dfcir.shl(%132 : !dfcir.stream>, 11 : i32) : !dfcir.stream> + %134 = dfcir.constant> 4017 : si32 + %135 = dfcir.mul[?] (%58 : !dfcir.stream>, %134 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %136 = dfcir.sub[?] (%74 : !dfcir.stream>, %135 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %137 = dfcir.constant> 4 : si32 + %138 = dfcir.constant> 8192 : si32 + %139 = dfcir.input> ("x8") + %140 = dfcir.shl(%139 : !dfcir.stream>, 11 : i32) : !dfcir.stream> + %141 = dfcir.input> ("x34") + %142 = dfcir.add[?] (%141 : !dfcir.stream>, %35 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %143 = dfcir.mul[?] (%142 : !dfcir.stream>, %63 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %144 = dfcir.constant> 2276 : si32 + %145 = dfcir.input> ("x18") + %146 = dfcir.add[?] (%145 : !dfcir.stream>, %54 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %147 = dfcir.mul[?] (%146 : !dfcir.stream>, %63 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %148 = dfcir.sub[?] (%147 : !dfcir.stream>, %55 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %149 = dfcir.input> ("x10") + %150 = dfcir.mul[?] (%149 : !dfcir.stream>, %28 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %151 = dfcir.input> ("x0") + %152 = dfcir.shl(%151 : !dfcir.stream>, 11 : i32) : !dfcir.stream> + %153 = dfcir.input> ("x35") + %154 = dfcir.constant> 799 : si32 + %155 = dfcir.input> ("x11") + %156 = dfcir.mul[?] (%155 : !dfcir.stream>, %76 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %157 = dfcir.input> ("x29") + %158 = dfcir.add[?] (%157 : !dfcir.stream>, %37 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %159 = dfcir.mul[?] (%158 : !dfcir.stream>, %73 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %160 = dfcir.input> ("x5") + %161 = dfcir.mul[?] (%160 : !dfcir.stream>, %87 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %162 = dfcir.add[?] (%160 : !dfcir.stream>, %99 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %163 = dfcir.mul[?] (%162 : !dfcir.stream>, %73 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %164 = dfcir.sub[?] (%163 : !dfcir.stream>, %100 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %165 = dfcir.sub[?] (%163 : !dfcir.stream>, %161 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %166 = dfcir.sub[?] (%131 : !dfcir.stream>, %165 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %167 = dfcir.add[?] (%131 : !dfcir.stream>, %165 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %168 = dfcir.input> ("x15") + %169 = dfcir.constant> 128 : si32 + %170 = dfcir.add[?] (%67 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %171 = dfcir.add[?] (%33 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %172 = dfcir.sub[?] (%171 : !dfcir.stream>, %133 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %173 = dfcir.sub[?] (%172 : !dfcir.stream>, %121 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %174 = dfcir.add[?] (%172 : !dfcir.stream>, %121 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %175 = dfcir.add[?] (%171 : !dfcir.stream>, %133 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %176 = dfcir.add[?] (%41 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %177 = dfcir.add[?] (%140 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %178 = dfcir.sub[?] (%177 : !dfcir.stream>, %98 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %179 = dfcir.add[?] (%177 : !dfcir.stream>, %98 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %180 = dfcir.add[?] (%152 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %181 = dfcir.sub[?] (%180 : !dfcir.stream>, %118 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %182 = dfcir.add[?] (%180 : !dfcir.stream>, %118 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %183 = dfcir.constant> 2276 : si32 + %184 = dfcir.constant> 2841 : si32 + %185 = dfcir.constant> 2276 : si32 + %186 = dfcir.input> ("x16") + %187 = dfcir.shl(%186 : !dfcir.stream>, 11 : i32) : !dfcir.stream> + %188 = dfcir.add[?] (%187 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %189 = dfcir.sub[?] (%188 : !dfcir.stream>, %44 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %190 = dfcir.sub[?] (%189 : !dfcir.stream>, %148 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %191 = dfcir.add[?] (%189 : !dfcir.stream>, %148 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %192 = dfcir.add[?] (%188 : !dfcir.stream>, %44 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %193 = dfcir.input> ("x49") + %194 = dfcir.mul[?] (%193 : !dfcir.stream>, %82 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %195 = dfcir.input> ("x50") + %196 = dfcir.constant> 4017 : si32 + %197 = dfcir.input> ("x52") + %198 = dfcir.shl(%197 : !dfcir.stream>, 11 : i32) : !dfcir.stream> + %199 = dfcir.sub[?] (%170 : !dfcir.stream>, %198 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %200 = dfcir.add[?] (%170 : !dfcir.stream>, %198 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %201 = dfcir.input> ("x53") + %202 = dfcir.add[?] (%201 : !dfcir.stream>, %51 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %203 = dfcir.mul[?] (%202 : !dfcir.stream>, %73 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %204 = dfcir.constant> 799 : si32 + %205 = dfcir.mul[?] (%31 : !dfcir.stream>, %204 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %206 = dfcir.sub[?] (%74 : !dfcir.stream>, %205 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %207 = dfcir.input> ("x54") + %208 = dfcir.mul[?] (%207 : !dfcir.stream>, %30 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %209 = dfcir.add[?] (%195 : !dfcir.stream>, %207 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %210 = dfcir.mul[?] (%209 : !dfcir.stream>, %63 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %211 = dfcir.sub[?] (%210 : !dfcir.stream>, %208 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %212 = dfcir.sub[?] (%199 : !dfcir.stream>, %211 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %213 = dfcir.add[?] (%199 : !dfcir.stream>, %211 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %214 = dfcir.input> ("x55") + %215 = dfcir.add[?] (%193 : !dfcir.stream>, %214 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %216 = dfcir.mul[?] (%215 : !dfcir.stream>, %102 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %217 = dfcir.add[?] (%216 : !dfcir.stream>, %194 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %218 = dfcir.input> ("x56") + %219 = dfcir.shl(%218 : !dfcir.stream>, 11 : i32) : !dfcir.stream> + %220 = dfcir.add[?] (%219 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %221 = dfcir.constant> 1568 : si32 + %222 = dfcir.input> ("x57") + %223 = dfcir.mul[?] (%222 : !dfcir.stream>, %183 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %224 = dfcir.constant> 3406 : si32 + %225 = dfcir.mul[?] (%113 : !dfcir.stream>, %224 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %226 = dfcir.sub[?] (%115 : !dfcir.stream>, %225 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %227 = dfcir.sub[?] (%226 : !dfcir.stream>, %136 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %228 = dfcir.add[?] (%226 : !dfcir.stream>, %136 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %229 = dfcir.input> ("x58") + %230 = dfcir.constant> 2276 : si32 + %231 = dfcir.constant> 2676 : si32 + %232 = dfcir.input> ("x59") + %233 = dfcir.add[?] (%75 : !dfcir.stream>, %232 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %234 = dfcir.mul[?] (%233 : !dfcir.stream>, %73 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %235 = dfcir.constant> 799 : si32 + %236 = dfcir.mul[?] (%157 : !dfcir.stream>, %235 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %237 = dfcir.sub[?] (%159 : !dfcir.stream>, %236 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %238 = dfcir.input> ("x62") + %239 = dfcir.add[?] (%229 : !dfcir.stream>, %238 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %240 = dfcir.mul[?] (%239 : !dfcir.stream>, %63 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %241 = dfcir.input> ("x37") + %242 = dfcir.add[?] (%241 : !dfcir.stream>, %153 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %243 = dfcir.mul[?] (%242 : !dfcir.stream>, %73 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %244 = dfcir.constant> 4017 : si32 + %245 = dfcir.mul[?] (%153 : !dfcir.stream>, %244 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %246 = dfcir.sub[?] (%243 : !dfcir.stream>, %245 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %247 = dfcir.sub[?] (%104 : !dfcir.stream>, %246 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %248 = dfcir.add[?] (%104 : !dfcir.stream>, %246 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %249 = dfcir.input> ("x14") + %250 = dfcir.mul[?] (%249 : !dfcir.stream>, %94 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %251 = dfcir.add[?] (%149 : !dfcir.stream>, %249 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %252 = dfcir.mul[?] (%251 : !dfcir.stream>, %63 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %253 = dfcir.add[?] (%252 : !dfcir.stream>, %150 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %254 = dfcir.sub[?] (%179 : !dfcir.stream>, %253 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %255 = dfcir.add[?] (%179 : !dfcir.stream>, %253 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %256 = dfcir.sub[?] (%252 : !dfcir.stream>, %250 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %257 = dfcir.sub[?] (%178 : !dfcir.stream>, %256 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %258 = dfcir.add[?] (%178 : !dfcir.stream>, %256 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %259 = dfcir.input> ("x63") + %260 = dfcir.add[?] (%222 : !dfcir.stream>, %259 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %261 = dfcir.mul[?] (%260 : !dfcir.stream>, %102 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %262 = dfcir.add[?] (%261 : !dfcir.stream>, %223 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %263 = dfcir.input> ("x9") + %264 = dfcir.mul[?] (%263 : !dfcir.stream>, %230 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %265 = dfcir.add[?] (%263 : !dfcir.stream>, %168 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %266 = dfcir.mul[?] (%265 : !dfcir.stream>, %102 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %267 = dfcir.add[?] (%266 : !dfcir.stream>, %264 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %268 = dfcir.constant> 3406 : si32 + %269 = dfcir.mul[?] (%60 : !dfcir.stream>, %268 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %270 = dfcir.sub[?] (%130 : !dfcir.stream>, %269 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %271 = dfcir.sub[?] (%270 : !dfcir.stream>, %164 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %272 = dfcir.sub[?] (%166 : !dfcir.stream>, %271 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %273 = dfcir.mul[?] (%272 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %274 = dfcir.add[?] (%273 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %275 = dfcir.shr(%274 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %276 = dfcir.add[?] (%166 : !dfcir.stream>, %271 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %277 = dfcir.mul[?] (%276 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %278 = dfcir.add[?] (%277 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %279 = dfcir.shr(%278 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %280 = dfcir.add[?] (%270 : !dfcir.stream>, %164 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %281 = dfcir.constant> 3784 : si32 + %282 = dfcir.mul[?] (%91 : !dfcir.stream>, %281 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %283 = dfcir.sub[?] (%93 : !dfcir.stream>, %282 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %284 = dfcir.sub[?] (%181 : !dfcir.stream>, %283 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %285 = dfcir.sub[?] (%284 : !dfcir.stream>, %275 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %286 = dfcir.shr(%285 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %287 = dfcir.shl(%286 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %288 = dfcir.add[?] (%287 : !dfcir.stream>, %138 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %289 = dfcir.add[?] (%284 : !dfcir.stream>, %275 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %290 = dfcir.shr(%289 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %291 = dfcir.shl(%290 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %292 = dfcir.add[?] (%291 : !dfcir.stream>, %138 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %293 = dfcir.add[?] (%181 : !dfcir.stream>, %283 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %294 = dfcir.sub[?] (%293 : !dfcir.stream>, %279 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %295 = dfcir.shr(%294 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %296 = dfcir.mul(%159 : !dfcir.const>, %295 : !dfcir.stream>) : !dfcir.stream> - %297 = dfcir.sub(%287 : !dfcir.stream>, %286 : !dfcir.stream>) : !dfcir.stream> - %298 = dfcir.sub(%172 : !dfcir.stream>, %297 : !dfcir.stream>) : !dfcir.stream> - %299 = dfcir.sub(%298 : !dfcir.stream>, %289 : !dfcir.stream>) : !dfcir.stream> - %300 = dfcir.mul(%299 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %301 = dfcir.add(%300 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %302 = dfcir.shr(%301 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %303 = dfcir.sub(%211 : !dfcir.stream>, %302 : !dfcir.stream>) : !dfcir.stream> - %304 = dfcir.shr(%303 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %305 = dfcir.mul(%155 : !dfcir.const>, %304 : !dfcir.stream>) : !dfcir.stream> - %306 = dfcir.add(%211 : !dfcir.stream>, %302 : !dfcir.stream>) : !dfcir.stream> - %307 = dfcir.shr(%306 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %308 = dfcir.mul(%161 : !dfcir.const>, %307 : !dfcir.stream>) : !dfcir.stream> - %309 = dfcir.add(%298 : !dfcir.stream>, %289 : !dfcir.stream>) : !dfcir.stream> - %310 = dfcir.mul(%309 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %311 = dfcir.add(%310 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %312 = dfcir.shr(%311 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %313 = dfcir.sub(%212 : !dfcir.stream>, %312 : !dfcir.stream>) : !dfcir.stream> - %314 = dfcir.shr(%313 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %315 = dfcir.mul(%153 : !dfcir.const>, %314 : !dfcir.stream>) : !dfcir.stream> - %316 = dfcir.add(%212 : !dfcir.stream>, %312 : !dfcir.stream>) : !dfcir.stream> + %296 = dfcir.shl(%295 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %297 = dfcir.add[?] (%296 : !dfcir.stream>, %138 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %298 = dfcir.add[?] (%293 : !dfcir.stream>, %279 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %299 = dfcir.shr(%298 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %300 = dfcir.shl(%299 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %301 = dfcir.add[?] (%300 : !dfcir.stream>, %138 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %302 = dfcir.constant> 3406 : si32 + %303 = dfcir.constant> 1568 : si32 + %304 = dfcir.mul[?] (%57 : !dfcir.stream>, %303 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %305 = dfcir.add[?] (%93 : !dfcir.stream>, %304 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %306 = dfcir.sub[?] (%182 : !dfcir.stream>, %305 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %307 = dfcir.sub[?] (%306 : !dfcir.stream>, %280 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %308 = dfcir.shr(%307 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %309 = dfcir.shl(%308 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %310 = dfcir.add[?] (%309 : !dfcir.stream>, %138 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %311 = dfcir.add[?] (%306 : !dfcir.stream>, %280 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %312 = dfcir.shr(%311 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %313 = dfcir.shl(%312 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %314 = dfcir.add[?] (%313 : !dfcir.stream>, %138 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %315 = dfcir.add[?] (%182 : !dfcir.stream>, %305 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %316 = dfcir.sub[?] (%315 : !dfcir.stream>, %167 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %317 = dfcir.shr(%316 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %318 = dfcir.mul(%163 : !dfcir.const>, %317 : !dfcir.stream>) : !dfcir.stream> - %319 = dfcir.add(%172 : !dfcir.stream>, %297 : !dfcir.stream>) : !dfcir.stream> - %320 = dfcir.sub(%215 : !dfcir.stream>, %319 : !dfcir.stream>) : !dfcir.stream> + %318 = dfcir.shl(%317 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %319 = dfcir.add[?] (%318 : !dfcir.stream>, %138 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %320 = dfcir.add[?] (%315 : !dfcir.stream>, %167 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %321 = dfcir.shr(%320 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %322 = dfcir.mul(%151 : !dfcir.const>, %321 : !dfcir.stream>) : !dfcir.stream> - %323 = dfcir.add(%215 : !dfcir.stream>, %319 : !dfcir.stream>) : !dfcir.stream> - %324 = dfcir.shr(%323 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %325 = dfcir.mul(%165 : !dfcir.const>, %324 : !dfcir.stream>) : !dfcir.stream> - %326 = dfcir.add(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %327 = dfcir.mul(%326 : !dfcir.const>, %44 : !dfcir.stream>) : !dfcir.stream> - %328 = dfcir.sub(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %329 = dfcir.mul(%328 : !dfcir.const>, %18 : !dfcir.stream>) : !dfcir.stream> - %330 = dfcir.mul(%266 : !dfcir.const>, %45 : !dfcir.stream>) : !dfcir.stream> - %331 = dfcir.sub(%330 : !dfcir.stream>, %327 : !dfcir.stream>) : !dfcir.stream> - %332 = dfcir.sub(%175 : !dfcir.stream>, %331 : !dfcir.stream>) : !dfcir.stream> - %333 = dfcir.add(%175 : !dfcir.stream>, %331 : !dfcir.stream>) : !dfcir.stream> - %334 = dfcir.sub(%221 : !dfcir.stream>, %333 : !dfcir.stream>) : !dfcir.stream> - %335 = dfcir.shr(%334 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %336 = dfcir.mul(%67 : !dfcir.const>, %335 : !dfcir.stream>) : !dfcir.stream> - %337 = dfcir.add(%221 : !dfcir.stream>, %333 : !dfcir.stream>) : !dfcir.stream> - %338 = dfcir.shr(%337 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %339 = dfcir.mul(%69 : !dfcir.const>, %338 : !dfcir.stream>) : !dfcir.stream> - %340 = dfcir.sub(%330 : !dfcir.stream>, %329 : !dfcir.stream>) : !dfcir.stream> - %341 = dfcir.sub(%178 : !dfcir.stream>, %340 : !dfcir.stream>) : !dfcir.stream> - %342 = dfcir.sub(%341 : !dfcir.stream>, %332 : !dfcir.stream>) : !dfcir.stream> - %343 = dfcir.mul(%342 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %344 = dfcir.add(%343 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %345 = dfcir.shr(%344 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %346 = dfcir.sub(%218 : !dfcir.stream>, %345 : !dfcir.stream>) : !dfcir.stream> - %347 = dfcir.shr(%346 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %348 = dfcir.mul(%65 : !dfcir.const>, %347 : !dfcir.stream>) : !dfcir.stream> - %349 = dfcir.add(%218 : !dfcir.stream>, %345 : !dfcir.stream>) : !dfcir.stream> - %350 = dfcir.shr(%349 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %351 = dfcir.mul(%71 : !dfcir.const>, %350 : !dfcir.stream>) : !dfcir.stream> - %352 = dfcir.add(%341 : !dfcir.stream>, %332 : !dfcir.stream>) : !dfcir.stream> - %353 = dfcir.mul(%352 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %354 = dfcir.add(%353 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %355 = dfcir.shr(%354 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %356 = dfcir.sub(%219 : !dfcir.stream>, %355 : !dfcir.stream>) : !dfcir.stream> - %357 = dfcir.shr(%356 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %358 = dfcir.mul(%63 : !dfcir.const>, %357 : !dfcir.stream>) : !dfcir.stream> - %359 = dfcir.add(%219 : !dfcir.stream>, %355 : !dfcir.stream>) : !dfcir.stream> - %360 = dfcir.shr(%359 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %361 = dfcir.mul(%73 : !dfcir.const>, %360 : !dfcir.stream>) : !dfcir.stream> - %362 = dfcir.add(%178 : !dfcir.stream>, %340 : !dfcir.stream>) : !dfcir.stream> - %363 = dfcir.sub(%222 : !dfcir.stream>, %362 : !dfcir.stream>) : !dfcir.stream> + %322 = dfcir.shl(%321 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %323 = dfcir.add[?] (%322 : !dfcir.stream>, %138 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %324 = dfcir.constant> 4017 : si32 + %325 = dfcir.mul[?] (%37 : !dfcir.stream>, %324 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %326 = dfcir.sub[?] (%159 : !dfcir.stream>, %325 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %327 = dfcir.sub[?] (%126 : !dfcir.stream>, %326 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %328 = dfcir.add[?] (%126 : !dfcir.stream>, %326 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %329 = dfcir.constant> 3406 : si32 + %330 = dfcir.mul[?] (%168 : !dfcir.stream>, %329 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %331 = dfcir.sub[?] (%266 : !dfcir.stream>, %330 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %332 = dfcir.input> ("x13") + %333 = dfcir.mul[?] (%332 : !dfcir.stream>, %154 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %334 = dfcir.add[?] (%332 : !dfcir.stream>, %155 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %335 = dfcir.mul[?] (%334 : !dfcir.stream>, %73 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %336 = dfcir.sub[?] (%335 : !dfcir.stream>, %156 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %337 = dfcir.sub[?] (%331 : !dfcir.stream>, %336 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %338 = dfcir.add[?] (%331 : !dfcir.stream>, %336 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %339 = dfcir.sub[?] (%254 : !dfcir.stream>, %338 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %340 = dfcir.shr(%339 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %341 = dfcir.mul[?] (%340 : !dfcir.stream>, %144 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %342 = dfcir.add[?] (%254 : !dfcir.stream>, %338 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %343 = dfcir.shr(%342 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %344 = dfcir.sub[?] (%335 : !dfcir.stream>, %333 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %345 = dfcir.sub[?] (%267 : !dfcir.stream>, %344 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %346 = dfcir.sub[?] (%345 : !dfcir.stream>, %337 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %347 = dfcir.mul[?] (%346 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %348 = dfcir.add[?] (%347 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %349 = dfcir.shr(%348 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %350 = dfcir.sub[?] (%257 : !dfcir.stream>, %349 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %351 = dfcir.shr(%350 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %352 = dfcir.mul[?] (%351 : !dfcir.stream>, %9 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %353 = dfcir.add[?] (%257 : !dfcir.stream>, %349 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %354 = dfcir.shr(%353 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %355 = dfcir.mul[?] (%354 : !dfcir.stream>, %19 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %356 = dfcir.add[?] (%345 : !dfcir.stream>, %337 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %357 = dfcir.mul[?] (%356 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %358 = dfcir.add[?] (%357 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %359 = dfcir.shr(%358 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %360 = dfcir.sub[?] (%258 : !dfcir.stream>, %359 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %361 = dfcir.shr(%360 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %362 = dfcir.mul[?] (%361 : !dfcir.stream>, %6 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %363 = dfcir.add[?] (%258 : !dfcir.stream>, %359 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %364 = dfcir.shr(%363 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %365 = dfcir.mul(%61 : !dfcir.const>, %364 : !dfcir.stream>) : !dfcir.stream> - %366 = dfcir.add(%222 : !dfcir.stream>, %362 : !dfcir.stream>) : !dfcir.stream> - %367 = dfcir.shr(%366 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %368 = dfcir.mul(%75 : !dfcir.const>, %367 : !dfcir.stream>) : !dfcir.stream> - %369 = dfcir.add(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %370 = dfcir.sub(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %371 = dfcir.add(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %372 = dfcir.sub(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %373 = dfcir.mul(%372 : !dfcir.const>, %110 : !dfcir.stream>) : !dfcir.stream> - %374 = dfcir.add(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %375 = dfcir.mul(%374 : !dfcir.const>, %139 : !dfcir.stream>) : !dfcir.stream> - %376 = dfcir.sub(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %377 = dfcir.mul(%376 : !dfcir.const>, %264 : !dfcir.stream>) : !dfcir.stream> - %378 = dfcir.mul(%266 : !dfcir.const>, %265 : !dfcir.stream>) : !dfcir.stream> - %379 = dfcir.sub(%378 : !dfcir.stream>, %375 : !dfcir.stream>) : !dfcir.stream> - %380 = dfcir.sub(%186 : !dfcir.stream>, %379 : !dfcir.stream>) : !dfcir.stream> - %381 = dfcir.add(%186 : !dfcir.stream>, %379 : !dfcir.stream>) : !dfcir.stream> - %382 = dfcir.sub(%378 : !dfcir.stream>, %377 : !dfcir.stream>) : !dfcir.stream> - %383 = dfcir.sub(%189 : !dfcir.stream>, %382 : !dfcir.stream>) : !dfcir.stream> - %384 = dfcir.sub(%383 : !dfcir.stream>, %380 : !dfcir.stream>) : !dfcir.stream> - %385 = dfcir.mul(%384 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %386 = dfcir.add(%385 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %387 = dfcir.shr(%386 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %388 = dfcir.add(%383 : !dfcir.stream>, %380 : !dfcir.stream>) : !dfcir.stream> - %389 = dfcir.mul(%388 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %390 = dfcir.add(%389 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %391 = dfcir.shr(%390 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %392 = dfcir.add(%189 : !dfcir.stream>, %382 : !dfcir.stream>) : !dfcir.stream> - %393 = dfcir.add(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %394 = dfcir.mul(%393 : !dfcir.const>, %259 : !dfcir.stream>) : !dfcir.stream> - %395 = dfcir.sub(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %396 = dfcir.mul(%395 : !dfcir.const>, %108 : !dfcir.stream>) : !dfcir.stream> - %397 = dfcir.mul(%266 : !dfcir.const>, %260 : !dfcir.stream>) : !dfcir.stream> - %398 = dfcir.sub(%397 : !dfcir.stream>, %394 : !dfcir.stream>) : !dfcir.stream> - %399 = dfcir.sub(%192 : !dfcir.stream>, %398 : !dfcir.stream>) : !dfcir.stream> - %400 = dfcir.add(%192 : !dfcir.stream>, %398 : !dfcir.stream>) : !dfcir.stream> - %401 = dfcir.sub(%230 : !dfcir.stream>, %400 : !dfcir.stream>) : !dfcir.stream> - %402 = dfcir.shr(%401 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %403 = dfcir.mul(%66 : !dfcir.const>, %402 : !dfcir.stream>) : !dfcir.stream> - %404 = dfcir.add(%402 : !dfcir.stream>, %335 : !dfcir.stream>) : !dfcir.stream> - %405 = dfcir.mul(%404 : !dfcir.stream>, %14 : !dfcir.const>) : !dfcir.stream> - %406 = dfcir.add(%405 : !dfcir.stream>, %239 : !dfcir.const>) : !dfcir.stream> - %407 = dfcir.add(%406 : !dfcir.stream>, %403 : !dfcir.stream>) : !dfcir.stream> - %408 = dfcir.shr(%407 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %409 = dfcir.sub(%406 : !dfcir.stream>, %336 : !dfcir.stream>) : !dfcir.stream> - %410 = dfcir.shr(%409 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %411 = dfcir.add(%230 : !dfcir.stream>, %400 : !dfcir.stream>) : !dfcir.stream> + %365 = dfcir.mul[?] (%364 : !dfcir.stream>, %25 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %366 = dfcir.add[?] (%267 : !dfcir.stream>, %344 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %367 = dfcir.sub[?] (%255 : !dfcir.stream>, %366 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %368 = dfcir.shr(%367 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %369 = dfcir.mul[?] (%368 : !dfcir.stream>, %3 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %370 = dfcir.add[?] (%255 : !dfcir.stream>, %366 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %371 = dfcir.shr(%370 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %372 = dfcir.mul[?] (%371 : !dfcir.stream>, %185 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %373 = dfcir.constant> 3406 : si32 + %374 = dfcir.mul[?] (%56 : !dfcir.stream>, %373 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %375 = dfcir.sub[?] (%108 : !dfcir.stream>, %374 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %376 = dfcir.constant> 4017 : si32 + %377 = dfcir.mul[?] (%50 : !dfcir.stream>, %376 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %378 = dfcir.constant> 1568 : si32 + %379 = dfcir.mul[?] (%145 : !dfcir.stream>, %378 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %380 = dfcir.add[?] (%147 : !dfcir.stream>, %379 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %381 = dfcir.sub[?] (%192 : !dfcir.stream>, %380 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %382 = dfcir.add[?] (%192 : !dfcir.stream>, %380 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %383 = dfcir.constant> 2276 : si32 + %384 = dfcir.mul[?] (%86 : !dfcir.stream>, %383 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %385 = dfcir.add[?] (%125 : !dfcir.stream>, %384 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %386 = dfcir.sub[?] (%385 : !dfcir.stream>, %237 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %387 = dfcir.sub[?] (%386 : !dfcir.stream>, %327 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %388 = dfcir.mul[?] (%387 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %389 = dfcir.add[?] (%388 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %390 = dfcir.shr(%389 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %391 = dfcir.add[?] (%386 : !dfcir.stream>, %327 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %392 = dfcir.mul[?] (%391 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %393 = dfcir.add[?] (%392 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %394 = dfcir.shr(%393 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %395 = dfcir.add[?] (%385 : !dfcir.stream>, %237 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %396 = dfcir.constant> 1568 : si32 + %397 = dfcir.mul[?] (%229 : !dfcir.stream>, %396 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %398 = dfcir.add[?] (%240 : !dfcir.stream>, %397 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %399 = dfcir.constant> 3784 : si32 + %400 = dfcir.mul[?] (%35 : !dfcir.stream>, %399 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %401 = dfcir.sub[?] (%143 : !dfcir.stream>, %400 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %402 = dfcir.constant> 2276 : si32 + %403 = dfcir.mul[?] (%343 : !dfcir.stream>, %402 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %404 = dfcir.input> ("x21") + %405 = dfcir.mul[?] (%404 : !dfcir.stream>, %72 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %406 = dfcir.add[?] (%404 : !dfcir.stream>, %50 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %407 = dfcir.mul[?] (%406 : !dfcir.stream>, %73 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %408 = dfcir.sub[?] (%407 : !dfcir.stream>, %377 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %409 = dfcir.sub[?] (%375 : !dfcir.stream>, %408 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %410 = dfcir.add[?] (%375 : !dfcir.stream>, %408 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %411 = dfcir.sub[?] (%381 : !dfcir.stream>, %410 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %412 = dfcir.shr(%411 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %413 = dfcir.mul(%68 : !dfcir.const>, %412 : !dfcir.stream>) : !dfcir.stream> - %414 = dfcir.add(%412 : !dfcir.stream>, %338 : !dfcir.stream>) : !dfcir.stream> - %415 = dfcir.mul(%414 : !dfcir.stream>, %14 : !dfcir.const>) : !dfcir.stream> - %416 = dfcir.add(%415 : !dfcir.stream>, %239 : !dfcir.const>) : !dfcir.stream> - %417 = dfcir.add(%416 : !dfcir.stream>, %413 : !dfcir.stream>) : !dfcir.stream> - %418 = dfcir.shr(%417 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %419 = dfcir.sub(%416 : !dfcir.stream>, %339 : !dfcir.stream>) : !dfcir.stream> - %420 = dfcir.shr(%419 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %421 = dfcir.sub(%397 : !dfcir.stream>, %396 : !dfcir.stream>) : !dfcir.stream> - %422 = dfcir.sub(%195 : !dfcir.stream>, %421 : !dfcir.stream>) : !dfcir.stream> - %423 = dfcir.sub(%422 : !dfcir.stream>, %399 : !dfcir.stream>) : !dfcir.stream> - %424 = dfcir.mul(%423 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %425 = dfcir.add(%424 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %426 = dfcir.shr(%425 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %427 = dfcir.sub(%227 : !dfcir.stream>, %426 : !dfcir.stream>) : !dfcir.stream> - %428 = dfcir.shr(%427 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %429 = dfcir.mul(%64 : !dfcir.const>, %428 : !dfcir.stream>) : !dfcir.stream> - %430 = dfcir.add(%428 : !dfcir.stream>, %347 : !dfcir.stream>) : !dfcir.stream> - %431 = dfcir.mul(%430 : !dfcir.stream>, %14 : !dfcir.const>) : !dfcir.stream> - %432 = dfcir.add(%431 : !dfcir.stream>, %239 : !dfcir.const>) : !dfcir.stream> - %433 = dfcir.add(%432 : !dfcir.stream>, %429 : !dfcir.stream>) : !dfcir.stream> - %434 = dfcir.shr(%433 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %435 = dfcir.sub(%432 : !dfcir.stream>, %348 : !dfcir.stream>) : !dfcir.stream> - %436 = dfcir.shr(%435 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %437 = dfcir.add(%227 : !dfcir.stream>, %426 : !dfcir.stream>) : !dfcir.stream> - %438 = dfcir.shr(%437 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %439 = dfcir.mul(%70 : !dfcir.const>, %438 : !dfcir.stream>) : !dfcir.stream> - %440 = dfcir.add(%438 : !dfcir.stream>, %350 : !dfcir.stream>) : !dfcir.stream> - %441 = dfcir.mul(%440 : !dfcir.stream>, %14 : !dfcir.const>) : !dfcir.stream> - %442 = dfcir.add(%441 : !dfcir.stream>, %239 : !dfcir.const>) : !dfcir.stream> - %443 = dfcir.add(%442 : !dfcir.stream>, %439 : !dfcir.stream>) : !dfcir.stream> - %444 = dfcir.shr(%443 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %445 = dfcir.sub(%442 : !dfcir.stream>, %351 : !dfcir.stream>) : !dfcir.stream> - %446 = dfcir.shr(%445 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %447 = dfcir.add(%422 : !dfcir.stream>, %399 : !dfcir.stream>) : !dfcir.stream> - %448 = dfcir.mul(%447 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %449 = dfcir.add(%448 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %450 = dfcir.shr(%449 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %451 = dfcir.sub(%228 : !dfcir.stream>, %450 : !dfcir.stream>) : !dfcir.stream> - %452 = dfcir.shr(%451 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %453 = dfcir.mul(%62 : !dfcir.const>, %452 : !dfcir.stream>) : !dfcir.stream> - %454 = dfcir.add(%452 : !dfcir.stream>, %357 : !dfcir.stream>) : !dfcir.stream> - %455 = dfcir.mul(%454 : !dfcir.stream>, %14 : !dfcir.const>) : !dfcir.stream> - %456 = dfcir.add(%455 : !dfcir.stream>, %239 : !dfcir.const>) : !dfcir.stream> - %457 = dfcir.add(%456 : !dfcir.stream>, %453 : !dfcir.stream>) : !dfcir.stream> - %458 = dfcir.shr(%457 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %459 = dfcir.sub(%456 : !dfcir.stream>, %358 : !dfcir.stream>) : !dfcir.stream> - %460 = dfcir.shr(%459 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %461 = dfcir.add(%228 : !dfcir.stream>, %450 : !dfcir.stream>) : !dfcir.stream> - %462 = dfcir.shr(%461 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %463 = dfcir.mul(%72 : !dfcir.const>, %462 : !dfcir.stream>) : !dfcir.stream> - %464 = dfcir.add(%462 : !dfcir.stream>, %360 : !dfcir.stream>) : !dfcir.stream> - %465 = dfcir.mul(%464 : !dfcir.stream>, %14 : !dfcir.const>) : !dfcir.stream> - %466 = dfcir.add(%465 : !dfcir.stream>, %239 : !dfcir.const>) : !dfcir.stream> - %467 = dfcir.add(%466 : !dfcir.stream>, %463 : !dfcir.stream>) : !dfcir.stream> - %468 = dfcir.shr(%467 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %469 = dfcir.sub(%466 : !dfcir.stream>, %361 : !dfcir.stream>) : !dfcir.stream> - %470 = dfcir.shr(%469 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %471 = dfcir.add(%195 : !dfcir.stream>, %421 : !dfcir.stream>) : !dfcir.stream> - %472 = dfcir.sub(%231 : !dfcir.stream>, %471 : !dfcir.stream>) : !dfcir.stream> - %473 = dfcir.shr(%472 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %474 = dfcir.mul(%60 : !dfcir.const>, %473 : !dfcir.stream>) : !dfcir.stream> - %475 = dfcir.add(%473 : !dfcir.stream>, %364 : !dfcir.stream>) : !dfcir.stream> - %476 = dfcir.mul(%475 : !dfcir.stream>, %14 : !dfcir.const>) : !dfcir.stream> - %477 = dfcir.add(%476 : !dfcir.stream>, %239 : !dfcir.const>) : !dfcir.stream> - %478 = dfcir.add(%477 : !dfcir.stream>, %474 : !dfcir.stream>) : !dfcir.stream> - %479 = dfcir.shr(%478 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %480 = dfcir.sub(%477 : !dfcir.stream>, %365 : !dfcir.stream>) : !dfcir.stream> - %481 = dfcir.shr(%480 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %482 = dfcir.add(%231 : !dfcir.stream>, %471 : !dfcir.stream>) : !dfcir.stream> - %483 = dfcir.shr(%482 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %484 = dfcir.mul(%74 : !dfcir.const>, %483 : !dfcir.stream>) : !dfcir.stream> - %485 = dfcir.add(%483 : !dfcir.stream>, %367 : !dfcir.stream>) : !dfcir.stream> - %486 = dfcir.mul(%485 : !dfcir.stream>, %14 : !dfcir.const>) : !dfcir.stream> - %487 = dfcir.add(%486 : !dfcir.stream>, %239 : !dfcir.const>) : !dfcir.stream> - %488 = dfcir.add(%487 : !dfcir.stream>, %484 : !dfcir.stream>) : !dfcir.stream> - %489 = dfcir.shr(%488 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %490 = dfcir.sub(%487 : !dfcir.stream>, %368 : !dfcir.stream>) : !dfcir.stream> - %491 = dfcir.shr(%490 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %492 = dfcir.add(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %493 = dfcir.mul(%492 : !dfcir.const>, %56 : !dfcir.stream>) : !dfcir.stream> - %494 = dfcir.sub(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %495 = dfcir.mul(%494 : !dfcir.const>, %148 : !dfcir.stream>) : !dfcir.stream> - %496 = dfcir.mul(%266 : !dfcir.const>, %149 : !dfcir.stream>) : !dfcir.stream> - %497 = dfcir.sub(%496 : !dfcir.stream>, %493 : !dfcir.stream>) : !dfcir.stream> - %498 = dfcir.sub(%198 : !dfcir.stream>, %497 : !dfcir.stream>) : !dfcir.stream> - %499 = dfcir.add(%198 : !dfcir.stream>, %497 : !dfcir.stream>) : !dfcir.stream> - %500 = dfcir.sub(%237 : !dfcir.stream>, %499 : !dfcir.stream>) : !dfcir.stream> - %501 = dfcir.shr(%500 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %502 = dfcir.mul(%158 : !dfcir.const>, %501 : !dfcir.stream>) : !dfcir.stream> - %503 = dfcir.add(%501 : !dfcir.stream>, %292 : !dfcir.stream>) : !dfcir.stream> - %504 = dfcir.mul(%503 : !dfcir.stream>, %116 : !dfcir.const>) : !dfcir.stream> - %505 = dfcir.add(%504 : !dfcir.stream>, %239 : !dfcir.const>) : !dfcir.stream> - %506 = dfcir.sub(%505 : !dfcir.stream>, %293 : !dfcir.stream>) : !dfcir.stream> - %507 = dfcir.shr(%506 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %508 = dfcir.add(%505 : !dfcir.stream>, %502 : !dfcir.stream>) : !dfcir.stream> - %509 = dfcir.shr(%508 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %510 = dfcir.add(%237 : !dfcir.stream>, %499 : !dfcir.stream>) : !dfcir.stream> - %511 = dfcir.shr(%510 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %512 = dfcir.mul(%160 : !dfcir.const>, %511 : !dfcir.stream>) : !dfcir.stream> - %513 = dfcir.add(%511 : !dfcir.stream>, %295 : !dfcir.stream>) : !dfcir.stream> - %514 = dfcir.mul(%513 : !dfcir.stream>, %116 : !dfcir.const>) : !dfcir.stream> - %515 = dfcir.add(%514 : !dfcir.stream>, %239 : !dfcir.const>) : !dfcir.stream> - %516 = dfcir.sub(%515 : !dfcir.stream>, %296 : !dfcir.stream>) : !dfcir.stream> - %517 = dfcir.shr(%516 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %518 = dfcir.add(%515 : !dfcir.stream>, %512 : !dfcir.stream>) : !dfcir.stream> - %519 = dfcir.shr(%518 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %520 = dfcir.sub(%496 : !dfcir.stream>, %495 : !dfcir.stream>) : !dfcir.stream> - %521 = dfcir.sub(%201 : !dfcir.stream>, %520 : !dfcir.stream>) : !dfcir.stream> - %522 = dfcir.sub(%521 : !dfcir.stream>, %498 : !dfcir.stream>) : !dfcir.stream> - %523 = dfcir.mul(%522 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %524 = dfcir.add(%523 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %525 = dfcir.shr(%524 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %526 = dfcir.sub(%234 : !dfcir.stream>, %525 : !dfcir.stream>) : !dfcir.stream> - %527 = dfcir.shr(%526 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %528 = dfcir.mul(%156 : !dfcir.const>, %527 : !dfcir.stream>) : !dfcir.stream> - %529 = dfcir.add(%527 : !dfcir.stream>, %304 : !dfcir.stream>) : !dfcir.stream> - %530 = dfcir.mul(%529 : !dfcir.stream>, %116 : !dfcir.const>) : !dfcir.stream> - %531 = dfcir.add(%530 : !dfcir.stream>, %239 : !dfcir.const>) : !dfcir.stream> - %532 = dfcir.sub(%531 : !dfcir.stream>, %305 : !dfcir.stream>) : !dfcir.stream> - %533 = dfcir.shr(%532 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %534 = dfcir.add(%531 : !dfcir.stream>, %528 : !dfcir.stream>) : !dfcir.stream> + %413 = dfcir.mul[?] (%412 : !dfcir.stream>, %46 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %414 = dfcir.add[?] (%381 : !dfcir.stream>, %410 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %415 = dfcir.shr(%414 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %416 = dfcir.mul[?] (%415 : !dfcir.stream>, %21 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %417 = dfcir.sub[?] (%407 : !dfcir.stream>, %405 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %418 = dfcir.sub[?] (%111 : !dfcir.stream>, %417 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %419 = dfcir.sub[?] (%418 : !dfcir.stream>, %409 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %420 = dfcir.mul[?] (%419 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %421 = dfcir.add[?] (%420 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %422 = dfcir.shr(%421 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %423 = dfcir.sub[?] (%190 : !dfcir.stream>, %422 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %424 = dfcir.shr(%423 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %425 = dfcir.mul[?] (%424 : !dfcir.stream>, %7 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %426 = dfcir.add[?] (%190 : !dfcir.stream>, %422 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %427 = dfcir.shr(%426 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %428 = dfcir.mul[?] (%427 : !dfcir.stream>, %101 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %429 = dfcir.add[?] (%418 : !dfcir.stream>, %409 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %430 = dfcir.mul[?] (%429 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %431 = dfcir.add[?] (%430 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %432 = dfcir.shr(%431 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %433 = dfcir.sub[?] (%191 : !dfcir.stream>, %432 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %434 = dfcir.shr(%433 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %435 = dfcir.mul[?] (%434 : !dfcir.stream>, %221 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %436 = dfcir.add[?] (%191 : !dfcir.stream>, %432 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %437 = dfcir.shr(%436 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %438 = dfcir.mul[?] (%437 : !dfcir.stream>, %34 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %439 = dfcir.add[?] (%111 : !dfcir.stream>, %417 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %440 = dfcir.sub[?] (%382 : !dfcir.stream>, %439 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %441 = dfcir.shr(%440 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %442 = dfcir.add[?] (%382 : !dfcir.stream>, %439 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %443 = dfcir.shr(%442 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %444 = dfcir.mul[?] (%443 : !dfcir.stream>, %26 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %445 = dfcir.constant> 2276 : si32 + %446 = dfcir.mul[?] (%70 : !dfcir.stream>, %445 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %447 = dfcir.add[?] (%115 : !dfcir.stream>, %446 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %448 = dfcir.sub[?] (%447 : !dfcir.stream>, %206 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %449 = dfcir.sub[?] (%448 : !dfcir.stream>, %227 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %450 = dfcir.mul[?] (%449 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %451 = dfcir.add[?] (%450 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %452 = dfcir.shr(%451 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %453 = dfcir.sub[?] (%173 : !dfcir.stream>, %452 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %454 = dfcir.shr(%453 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %455 = dfcir.mul[?] (%454 : !dfcir.stream>, %112 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %456 = dfcir.add[?] (%173 : !dfcir.stream>, %452 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %457 = dfcir.shr(%456 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %458 = dfcir.mul[?] (%457 : !dfcir.stream>, %18 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %459 = dfcir.add[?] (%448 : !dfcir.stream>, %227 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %460 = dfcir.mul[?] (%459 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %461 = dfcir.add[?] (%460 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %462 = dfcir.shr(%461 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %463 = dfcir.sub[?] (%174 : !dfcir.stream>, %462 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %464 = dfcir.shr(%463 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %465 = dfcir.mul[?] (%464 : !dfcir.stream>, %29 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %466 = dfcir.add[?] (%174 : !dfcir.stream>, %462 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %467 = dfcir.shr(%466 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %468 = dfcir.mul[?] (%467 : !dfcir.stream>, %24 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %469 = dfcir.add[?] (%447 : !dfcir.stream>, %206 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %470 = dfcir.constant> 1568 : si32 + %471 = dfcir.mul[?] (%141 : !dfcir.stream>, %470 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %472 = dfcir.add[?] (%143 : !dfcir.stream>, %471 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %473 = dfcir.constant> 1568 : si32 + %474 = dfcir.mul[?] (%88 : !dfcir.stream>, %473 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %475 = dfcir.add[?] (%90 : !dfcir.stream>, %474 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %476 = dfcir.sub[?] (%175 : !dfcir.stream>, %475 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %477 = dfcir.sub[?] (%476 : !dfcir.stream>, %228 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %478 = dfcir.shr(%477 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %479 = dfcir.mul[?] (%478 : !dfcir.stream>, %11 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %480 = dfcir.add[?] (%476 : !dfcir.stream>, %228 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %481 = dfcir.shr(%480 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %482 = dfcir.mul[?] (%481 : !dfcir.stream>, %14 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %483 = dfcir.add[?] (%175 : !dfcir.stream>, %475 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %484 = dfcir.sub[?] (%483 : !dfcir.stream>, %469 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %485 = dfcir.shr(%484 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %486 = dfcir.mul[?] (%485 : !dfcir.stream>, %1 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %487 = dfcir.add[?] (%483 : !dfcir.stream>, %469 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %488 = dfcir.shr(%487 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %489 = dfcir.constant> 4017 : si32 + %490 = dfcir.constant> 3406 : si32 + %491 = dfcir.mul[?] (%214 : !dfcir.stream>, %490 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %492 = dfcir.sub[?] (%216 : !dfcir.stream>, %491 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %493 = dfcir.input> ("x28") + %494 = dfcir.shl(%493 : !dfcir.stream>, 11 : i32) : !dfcir.stream> + %495 = dfcir.sub[?] (%176 : !dfcir.stream>, %494 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %496 = dfcir.sub[?] (%495 : !dfcir.stream>, %79 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %497 = dfcir.sub[?] (%496 : !dfcir.stream>, %390 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %498 = dfcir.shr(%497 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %499 = dfcir.mul[?] (%498 : !dfcir.stream>, %489 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %500 = dfcir.add[?] (%454 : !dfcir.stream>, %498 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %501 = dfcir.mul[?] (%500 : !dfcir.stream>, %73 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %502 = dfcir.add[?] (%501 : !dfcir.stream>, %137 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %503 = dfcir.sub[?] (%502 : !dfcir.stream>, %499 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %504 = dfcir.shr(%503 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %505 = dfcir.sub[?] (%502 : !dfcir.stream>, %455 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %506 = dfcir.shr(%505 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %507 = dfcir.add[?] (%496 : !dfcir.stream>, %390 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %508 = dfcir.shr(%507 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %509 = dfcir.mul[?] (%508 : !dfcir.stream>, %17 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %510 = dfcir.add[?] (%457 : !dfcir.stream>, %508 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %511 = dfcir.mul[?] (%510 : !dfcir.stream>, %73 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %512 = dfcir.add[?] (%511 : !dfcir.stream>, %137 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %513 = dfcir.sub[?] (%512 : !dfcir.stream>, %509 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %514 = dfcir.shr(%513 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %515 = dfcir.sub[?] (%512 : !dfcir.stream>, %458 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %516 = dfcir.shr(%515 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %517 = dfcir.add[?] (%495 : !dfcir.stream>, %79 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %518 = dfcir.sub[?] (%517 : !dfcir.stream>, %394 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %519 = dfcir.shr(%518 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %520 = dfcir.mul[?] (%519 : !dfcir.stream>, %5 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %521 = dfcir.add[?] (%464 : !dfcir.stream>, %519 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %522 = dfcir.mul[?] (%521 : !dfcir.stream>, %73 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %523 = dfcir.add[?] (%522 : !dfcir.stream>, %137 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %524 = dfcir.sub[?] (%523 : !dfcir.stream>, %520 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %525 = dfcir.shr(%524 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %526 = dfcir.sub[?] (%523 : !dfcir.stream>, %465 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %527 = dfcir.shr(%526 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %528 = dfcir.add[?] (%517 : !dfcir.stream>, %394 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %529 = dfcir.shr(%528 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %530 = dfcir.mul[?] (%529 : !dfcir.stream>, %22 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %531 = dfcir.add[?] (%467 : !dfcir.stream>, %529 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %532 = dfcir.mul[?] (%531 : !dfcir.stream>, %73 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %533 = dfcir.add[?] (%532 : !dfcir.stream>, %137 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %534 = dfcir.sub[?] (%533 : !dfcir.stream>, %530 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %535 = dfcir.shr(%534 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %536 = dfcir.add(%234 : !dfcir.stream>, %525 : !dfcir.stream>) : !dfcir.stream> - %537 = dfcir.shr(%536 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %538 = dfcir.mul(%162 : !dfcir.const>, %537 : !dfcir.stream>) : !dfcir.stream> - %539 = dfcir.add(%537 : !dfcir.stream>, %307 : !dfcir.stream>) : !dfcir.stream> - %540 = dfcir.mul(%539 : !dfcir.stream>, %116 : !dfcir.const>) : !dfcir.stream> - %541 = dfcir.add(%540 : !dfcir.stream>, %239 : !dfcir.const>) : !dfcir.stream> - %542 = dfcir.sub(%541 : !dfcir.stream>, %308 : !dfcir.stream>) : !dfcir.stream> - %543 = dfcir.shr(%542 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %544 = dfcir.add(%541 : !dfcir.stream>, %538 : !dfcir.stream>) : !dfcir.stream> - %545 = dfcir.shr(%544 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %546 = dfcir.add(%521 : !dfcir.stream>, %498 : !dfcir.stream>) : !dfcir.stream> - %547 = dfcir.mul(%546 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %548 = dfcir.add(%547 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %549 = dfcir.shr(%548 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %550 = dfcir.sub(%235 : !dfcir.stream>, %549 : !dfcir.stream>) : !dfcir.stream> + %536 = dfcir.sub[?] (%533 : !dfcir.stream>, %468 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %537 = dfcir.shr(%536 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %538 = dfcir.add[?] (%176 : !dfcir.stream>, %494 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %539 = dfcir.sub[?] (%538 : !dfcir.stream>, %65 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %540 = dfcir.sub[?] (%539 : !dfcir.stream>, %328 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %541 = dfcir.shr(%540 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %542 = dfcir.mul[?] (%541 : !dfcir.stream>, %61 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %543 = dfcir.add[?] (%478 : !dfcir.stream>, %541 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %544 = dfcir.mul[?] (%543 : !dfcir.stream>, %73 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %545 = dfcir.add[?] (%544 : !dfcir.stream>, %137 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %546 = dfcir.sub[?] (%545 : !dfcir.stream>, %542 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %547 = dfcir.shr(%546 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %548 = dfcir.sub[?] (%545 : !dfcir.stream>, %479 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %549 = dfcir.shr(%548 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %550 = dfcir.add[?] (%539 : !dfcir.stream>, %328 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %551 = dfcir.shr(%550 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %552 = dfcir.mul(%154 : !dfcir.const>, %551 : !dfcir.stream>) : !dfcir.stream> - %553 = dfcir.add(%551 : !dfcir.stream>, %314 : !dfcir.stream>) : !dfcir.stream> - %554 = dfcir.mul(%553 : !dfcir.stream>, %116 : !dfcir.const>) : !dfcir.stream> - %555 = dfcir.add(%554 : !dfcir.stream>, %239 : !dfcir.const>) : !dfcir.stream> - %556 = dfcir.sub(%555 : !dfcir.stream>, %315 : !dfcir.stream>) : !dfcir.stream> + %552 = dfcir.mul[?] (%551 : !dfcir.stream>, %13 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %553 = dfcir.add[?] (%481 : !dfcir.stream>, %551 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %554 = dfcir.mul[?] (%553 : !dfcir.stream>, %73 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %555 = dfcir.add[?] (%554 : !dfcir.stream>, %137 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %556 = dfcir.sub[?] (%555 : !dfcir.stream>, %552 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %557 = dfcir.shr(%556 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %558 = dfcir.add(%555 : !dfcir.stream>, %552 : !dfcir.stream>) : !dfcir.stream> + %558 = dfcir.sub[?] (%555 : !dfcir.stream>, %482 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %559 = dfcir.shr(%558 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %560 = dfcir.add(%235 : !dfcir.stream>, %549 : !dfcir.stream>) : !dfcir.stream> - %561 = dfcir.shr(%560 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %562 = dfcir.mul(%164 : !dfcir.const>, %561 : !dfcir.stream>) : !dfcir.stream> - %563 = dfcir.add(%561 : !dfcir.stream>, %317 : !dfcir.stream>) : !dfcir.stream> - %564 = dfcir.mul(%563 : !dfcir.stream>, %116 : !dfcir.const>) : !dfcir.stream> - %565 = dfcir.add(%564 : !dfcir.stream>, %239 : !dfcir.const>) : !dfcir.stream> - %566 = dfcir.sub(%565 : !dfcir.stream>, %318 : !dfcir.stream>) : !dfcir.stream> - %567 = dfcir.shr(%566 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %568 = dfcir.add(%565 : !dfcir.stream>, %562 : !dfcir.stream>) : !dfcir.stream> - %569 = dfcir.shr(%568 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %570 = dfcir.add(%201 : !dfcir.stream>, %520 : !dfcir.stream>) : !dfcir.stream> - %571 = dfcir.sub(%238 : !dfcir.stream>, %570 : !dfcir.stream>) : !dfcir.stream> + %560 = dfcir.add[?] (%538 : !dfcir.stream>, %65 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %561 = dfcir.sub[?] (%560 : !dfcir.stream>, %395 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %562 = dfcir.shr(%561 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %563 = dfcir.mul[?] (%562 : !dfcir.stream>, %0 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %564 = dfcir.add[?] (%485 : !dfcir.stream>, %562 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %565 = dfcir.mul[?] (%564 : !dfcir.stream>, %73 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %566 = dfcir.add[?] (%565 : !dfcir.stream>, %137 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %567 = dfcir.sub[?] (%566 : !dfcir.stream>, %563 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %568 = dfcir.shr(%567 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %569 = dfcir.sub[?] (%566 : !dfcir.stream>, %486 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %570 = dfcir.shr(%569 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %571 = dfcir.add[?] (%560 : !dfcir.stream>, %395 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %572 = dfcir.shr(%571 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %573 = dfcir.mul(%152 : !dfcir.const>, %572 : !dfcir.stream>) : !dfcir.stream> - %574 = dfcir.add(%572 : !dfcir.stream>, %321 : !dfcir.stream>) : !dfcir.stream> - %575 = dfcir.mul(%574 : !dfcir.stream>, %116 : !dfcir.const>) : !dfcir.stream> - %576 = dfcir.add(%575 : !dfcir.stream>, %239 : !dfcir.const>) : !dfcir.stream> - %577 = dfcir.sub(%576 : !dfcir.stream>, %322 : !dfcir.stream>) : !dfcir.stream> + %573 = dfcir.mul[?] (%572 : !dfcir.stream>, %196 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %574 = dfcir.add[?] (%488 : !dfcir.stream>, %572 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %575 = dfcir.mul[?] (%574 : !dfcir.stream>, %73 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %576 = dfcir.add[?] (%575 : !dfcir.stream>, %137 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %577 = dfcir.sub[?] (%576 : !dfcir.stream>, %573 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %578 = dfcir.shr(%577 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %579 = dfcir.add(%576 : !dfcir.stream>, %573 : !dfcir.stream>) : !dfcir.stream> - %580 = dfcir.shr(%579 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %581 = dfcir.add(%238 : !dfcir.stream>, %570 : !dfcir.stream>) : !dfcir.stream> - %582 = dfcir.shr(%581 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %583 = dfcir.mul(%166 : !dfcir.const>, %582 : !dfcir.stream>) : !dfcir.stream> - %584 = dfcir.add(%582 : !dfcir.stream>, %324 : !dfcir.stream>) : !dfcir.stream> - %585 = dfcir.mul(%584 : !dfcir.stream>, %116 : !dfcir.const>) : !dfcir.stream> - %586 = dfcir.add(%585 : !dfcir.stream>, %239 : !dfcir.const>) : !dfcir.stream> - %587 = dfcir.sub(%586 : !dfcir.stream>, %325 : !dfcir.stream>) : !dfcir.stream> - %588 = dfcir.shr(%587 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %589 = dfcir.add(%586 : !dfcir.stream>, %583 : !dfcir.stream>) : !dfcir.stream> - %590 = dfcir.shr(%589 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %591 = dfcir.add(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %592 = dfcir.mul(%591 : !dfcir.const>, %140 : !dfcir.stream>) : !dfcir.stream> - %593 = dfcir.sub(%266 : !dfcir.const>, %53 : !dfcir.const>) : !dfcir.const> - %594 = dfcir.mul(%593 : !dfcir.const>, %52 : !dfcir.stream>) : !dfcir.stream> - %595 = dfcir.mul(%266 : !dfcir.const>, %141 : !dfcir.stream>) : !dfcir.stream> - %596 = dfcir.sub(%595 : !dfcir.stream>, %592 : !dfcir.stream>) : !dfcir.stream> - %597 = dfcir.sub(%204 : !dfcir.stream>, %596 : !dfcir.stream>) : !dfcir.stream> - %598 = dfcir.add(%204 : !dfcir.stream>, %596 : !dfcir.stream>) : !dfcir.stream> - %599 = dfcir.sub(%251 : !dfcir.stream>, %598 : !dfcir.stream>) : !dfcir.stream> - %600 = dfcir.shr(%599 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %601 = dfcir.shl(%600 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %602 = dfcir.add(%601 : !dfcir.stream>, %109 : !dfcir.const>) : !dfcir.stream> - %603 = dfcir.add(%251 : !dfcir.stream>, %598 : !dfcir.stream>) : !dfcir.stream> - %604 = dfcir.shr(%603 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %605 = dfcir.shl(%604 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %606 = dfcir.add(%605 : !dfcir.stream>, %109 : !dfcir.const>) : !dfcir.stream> - %607 = dfcir.sub(%595 : !dfcir.stream>, %594 : !dfcir.stream>) : !dfcir.stream> - %608 = dfcir.sub(%207 : !dfcir.stream>, %607 : !dfcir.stream>) : !dfcir.stream> - %609 = dfcir.sub(%608 : !dfcir.stream>, %597 : !dfcir.stream>) : !dfcir.stream> - %610 = dfcir.mul(%609 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %611 = dfcir.add(%610 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %612 = dfcir.shr(%611 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %613 = dfcir.sub(%248 : !dfcir.stream>, %612 : !dfcir.stream>) : !dfcir.stream> - %614 = dfcir.shr(%613 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %615 = dfcir.shl(%614 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %616 = dfcir.add(%615 : !dfcir.stream>, %109 : !dfcir.const>) : !dfcir.stream> - %617 = dfcir.add(%248 : !dfcir.stream>, %612 : !dfcir.stream>) : !dfcir.stream> - %618 = dfcir.shr(%617 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %619 = dfcir.shl(%618 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %620 = dfcir.add(%619 : !dfcir.stream>, %109 : !dfcir.const>) : !dfcir.stream> - %621 = dfcir.add(%608 : !dfcir.stream>, %597 : !dfcir.stream>) : !dfcir.stream> - %622 = dfcir.mul(%621 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %623 = dfcir.add(%622 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %624 = dfcir.shr(%623 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %625 = dfcir.sub(%249 : !dfcir.stream>, %624 : !dfcir.stream>) : !dfcir.stream> - %626 = dfcir.shr(%625 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %627 = dfcir.shl(%626 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %628 = dfcir.add(%627 : !dfcir.stream>, %109 : !dfcir.const>) : !dfcir.stream> - %629 = dfcir.add(%249 : !dfcir.stream>, %624 : !dfcir.stream>) : !dfcir.stream> - %630 = dfcir.shr(%629 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %631 = dfcir.shl(%630 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %632 = dfcir.add(%631 : !dfcir.stream>, %109 : !dfcir.const>) : !dfcir.stream> - %633 = dfcir.add(%207 : !dfcir.stream>, %607 : !dfcir.stream>) : !dfcir.stream> - %634 = dfcir.sub(%252 : !dfcir.stream>, %633 : !dfcir.stream>) : !dfcir.stream> - %635 = dfcir.shr(%634 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %636 = dfcir.shl(%635 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %637 = dfcir.add(%636 : !dfcir.stream>, %109 : !dfcir.const>) : !dfcir.stream> - %638 = dfcir.add(%252 : !dfcir.stream>, %633 : !dfcir.stream>) : !dfcir.stream> - %639 = dfcir.shr(%638 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %640 = dfcir.shl(%639 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %641 = dfcir.add(%640 : !dfcir.stream>, %109 : !dfcir.const>) : !dfcir.stream> - %642 = dfcir.input> ("x35") - %643 = dfcir.mul(%371 : !dfcir.const>, %642 : !dfcir.stream>) : !dfcir.stream> - %644 = dfcir.add(%110 : !dfcir.stream>, %642 : !dfcir.stream>) : !dfcir.stream> - %645 = dfcir.mul(%266 : !dfcir.const>, %644 : !dfcir.stream>) : !dfcir.stream> - %646 = dfcir.sub(%645 : !dfcir.stream>, %643 : !dfcir.stream>) : !dfcir.stream> - %647 = dfcir.sub(%257 : !dfcir.stream>, %646 : !dfcir.stream>) : !dfcir.stream> - %648 = dfcir.add(%257 : !dfcir.stream>, %646 : !dfcir.stream>) : !dfcir.stream> - %649 = dfcir.sub(%645 : !dfcir.stream>, %373 : !dfcir.stream>) : !dfcir.stream> - %650 = dfcir.sub(%258 : !dfcir.stream>, %649 : !dfcir.stream>) : !dfcir.stream> - %651 = dfcir.sub(%650 : !dfcir.stream>, %647 : !dfcir.stream>) : !dfcir.stream> - %652 = dfcir.mul(%651 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %653 = dfcir.add(%652 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %654 = dfcir.shr(%653 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %655 = dfcir.add(%650 : !dfcir.stream>, %647 : !dfcir.stream>) : !dfcir.stream> - %656 = dfcir.mul(%655 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %657 = dfcir.add(%656 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %658 = dfcir.shr(%657 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %659 = dfcir.add(%258 : !dfcir.stream>, %649 : !dfcir.stream>) : !dfcir.stream> - %660 = dfcir.input> ("x36") - %661 = dfcir.shl(%660 : !dfcir.stream>, 11 : i32) : !dfcir.stream> - %662 = dfcir.sub(%223 : !dfcir.stream>, %661 : !dfcir.stream>) : !dfcir.stream> - %663 = dfcir.sub(%662 : !dfcir.stream>, %92 : !dfcir.stream>) : !dfcir.stream> - %664 = dfcir.sub(%663 : !dfcir.stream>, %654 : !dfcir.stream>) : !dfcir.stream> - %665 = dfcir.shr(%664 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %666 = dfcir.shl(%665 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %667 = dfcir.sub(%616 : !dfcir.stream>, %666 : !dfcir.stream>) : !dfcir.stream> - %668 = dfcir.sub(%667 : !dfcir.stream>, %436 : !dfcir.stream>) : !dfcir.stream> - %669 = dfcir.add(%667 : !dfcir.stream>, %436 : !dfcir.stream>) : !dfcir.stream> - %670 = dfcir.add(%616 : !dfcir.stream>, %666 : !dfcir.stream>) : !dfcir.stream> - %671 = dfcir.sub(%670 : !dfcir.stream>, %434 : !dfcir.stream>) : !dfcir.stream> - %672 = dfcir.add(%670 : !dfcir.stream>, %434 : !dfcir.stream>) : !dfcir.stream> - %673 = dfcir.add(%663 : !dfcir.stream>, %654 : !dfcir.stream>) : !dfcir.stream> - %674 = dfcir.shr(%673 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %675 = dfcir.shl(%674 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %676 = dfcir.sub(%620 : !dfcir.stream>, %675 : !dfcir.stream>) : !dfcir.stream> - %677 = dfcir.sub(%676 : !dfcir.stream>, %446 : !dfcir.stream>) : !dfcir.stream> - %678 = dfcir.add(%676 : !dfcir.stream>, %446 : !dfcir.stream>) : !dfcir.stream> - %679 = dfcir.add(%620 : !dfcir.stream>, %675 : !dfcir.stream>) : !dfcir.stream> - %680 = dfcir.sub(%679 : !dfcir.stream>, %444 : !dfcir.stream>) : !dfcir.stream> - %681 = dfcir.add(%679 : !dfcir.stream>, %444 : !dfcir.stream>) : !dfcir.stream> - %682 = dfcir.add(%662 : !dfcir.stream>, %92 : !dfcir.stream>) : !dfcir.stream> - %683 = dfcir.sub(%682 : !dfcir.stream>, %658 : !dfcir.stream>) : !dfcir.stream> - %684 = dfcir.shr(%683 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %685 = dfcir.shl(%684 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %686 = dfcir.sub(%628 : !dfcir.stream>, %685 : !dfcir.stream>) : !dfcir.stream> - %687 = dfcir.sub(%686 : !dfcir.stream>, %460 : !dfcir.stream>) : !dfcir.stream> - %688 = dfcir.add(%686 : !dfcir.stream>, %460 : !dfcir.stream>) : !dfcir.stream> - %689 = dfcir.add(%628 : !dfcir.stream>, %685 : !dfcir.stream>) : !dfcir.stream> - %690 = dfcir.sub(%689 : !dfcir.stream>, %458 : !dfcir.stream>) : !dfcir.stream> - %691 = dfcir.add(%689 : !dfcir.stream>, %458 : !dfcir.stream>) : !dfcir.stream> - %692 = dfcir.add(%682 : !dfcir.stream>, %658 : !dfcir.stream>) : !dfcir.stream> - %693 = dfcir.shr(%692 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %694 = dfcir.shl(%693 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %695 = dfcir.sub(%632 : !dfcir.stream>, %694 : !dfcir.stream>) : !dfcir.stream> - %696 = dfcir.sub(%695 : !dfcir.stream>, %470 : !dfcir.stream>) : !dfcir.stream> - %697 = dfcir.add(%695 : !dfcir.stream>, %470 : !dfcir.stream>) : !dfcir.stream> - %698 = dfcir.add(%632 : !dfcir.stream>, %694 : !dfcir.stream>) : !dfcir.stream> - %699 = dfcir.sub(%698 : !dfcir.stream>, %468 : !dfcir.stream>) : !dfcir.stream> - %700 = dfcir.add(%698 : !dfcir.stream>, %468 : !dfcir.stream>) : !dfcir.stream> - %701 = dfcir.add(%223 : !dfcir.stream>, %661 : !dfcir.stream>) : !dfcir.stream> - %702 = dfcir.sub(%701 : !dfcir.stream>, %89 : !dfcir.stream>) : !dfcir.stream> - %703 = dfcir.sub(%702 : !dfcir.stream>, %648 : !dfcir.stream>) : !dfcir.stream> - %704 = dfcir.shr(%703 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %705 = dfcir.shl(%704 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %706 = dfcir.sub(%602 : !dfcir.stream>, %705 : !dfcir.stream>) : !dfcir.stream> - %707 = dfcir.sub(%706 : !dfcir.stream>, %410 : !dfcir.stream>) : !dfcir.stream> - %708 = dfcir.add(%706 : !dfcir.stream>, %410 : !dfcir.stream>) : !dfcir.stream> - %709 = dfcir.add(%602 : !dfcir.stream>, %705 : !dfcir.stream>) : !dfcir.stream> - %710 = dfcir.sub(%709 : !dfcir.stream>, %408 : !dfcir.stream>) : !dfcir.stream> - %711 = dfcir.add(%709 : !dfcir.stream>, %408 : !dfcir.stream>) : !dfcir.stream> - %712 = dfcir.add(%702 : !dfcir.stream>, %648 : !dfcir.stream>) : !dfcir.stream> - %713 = dfcir.shr(%712 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %714 = dfcir.shl(%713 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %715 = dfcir.sub(%606 : !dfcir.stream>, %714 : !dfcir.stream>) : !dfcir.stream> - %716 = dfcir.sub(%715 : !dfcir.stream>, %420 : !dfcir.stream>) : !dfcir.stream> - %717 = dfcir.add(%715 : !dfcir.stream>, %420 : !dfcir.stream>) : !dfcir.stream> - %718 = dfcir.add(%606 : !dfcir.stream>, %714 : !dfcir.stream>) : !dfcir.stream> - %719 = dfcir.sub(%718 : !dfcir.stream>, %418 : !dfcir.stream>) : !dfcir.stream> - %720 = dfcir.add(%718 : !dfcir.stream>, %418 : !dfcir.stream>) : !dfcir.stream> - %721 = dfcir.add(%701 : !dfcir.stream>, %89 : !dfcir.stream>) : !dfcir.stream> - %722 = dfcir.sub(%721 : !dfcir.stream>, %659 : !dfcir.stream>) : !dfcir.stream> - %723 = dfcir.shr(%722 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %724 = dfcir.shl(%723 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %725 = dfcir.sub(%637 : !dfcir.stream>, %724 : !dfcir.stream>) : !dfcir.stream> - %726 = dfcir.sub(%725 : !dfcir.stream>, %481 : !dfcir.stream>) : !dfcir.stream> - %727 = dfcir.add(%725 : !dfcir.stream>, %481 : !dfcir.stream>) : !dfcir.stream> - %728 = dfcir.add(%637 : !dfcir.stream>, %724 : !dfcir.stream>) : !dfcir.stream> - %729 = dfcir.sub(%728 : !dfcir.stream>, %479 : !dfcir.stream>) : !dfcir.stream> - %730 = dfcir.add(%728 : !dfcir.stream>, %479 : !dfcir.stream>) : !dfcir.stream> - %731 = dfcir.add(%721 : !dfcir.stream>, %659 : !dfcir.stream>) : !dfcir.stream> - %732 = dfcir.shr(%731 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %733 = dfcir.shl(%732 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %734 = dfcir.sub(%641 : !dfcir.stream>, %733 : !dfcir.stream>) : !dfcir.stream> - %735 = dfcir.sub(%734 : !dfcir.stream>, %491 : !dfcir.stream>) : !dfcir.stream> - %736 = dfcir.add(%734 : !dfcir.stream>, %491 : !dfcir.stream>) : !dfcir.stream> - %737 = dfcir.add(%641 : !dfcir.stream>, %733 : !dfcir.stream>) : !dfcir.stream> - %738 = dfcir.sub(%737 : !dfcir.stream>, %489 : !dfcir.stream>) : !dfcir.stream> - %739 = dfcir.add(%737 : !dfcir.stream>, %489 : !dfcir.stream>) : !dfcir.stream> - %740 = dfcir.input> ("x41") - %741 = dfcir.mul(%180 : !dfcir.const>, %740 : !dfcir.stream>) : !dfcir.stream> - %742 = dfcir.input> ("x42") - %743 = dfcir.mul(%85 : !dfcir.const>, %742 : !dfcir.stream>) : !dfcir.stream> - %744 = dfcir.input> ("x43") - %745 = dfcir.mul(%369 : !dfcir.const>, %744 : !dfcir.stream>) : !dfcir.stream> - %746 = dfcir.input> ("x44") - %747 = dfcir.shl(%746 : !dfcir.stream>, 11 : i32) : !dfcir.stream> - %748 = dfcir.sub(%263 : !dfcir.stream>, %747 : !dfcir.stream>) : !dfcir.stream> - %749 = dfcir.add(%263 : !dfcir.stream>, %747 : !dfcir.stream>) : !dfcir.stream> - %750 = dfcir.input> ("x45") - %751 = dfcir.mul(%370 : !dfcir.const>, %750 : !dfcir.stream>) : !dfcir.stream> - %752 = dfcir.add(%750 : !dfcir.stream>, %744 : !dfcir.stream>) : !dfcir.stream> - %753 = dfcir.mul(%266 : !dfcir.const>, %752 : !dfcir.stream>) : !dfcir.stream> - %754 = dfcir.sub(%753 : !dfcir.stream>, %745 : !dfcir.stream>) : !dfcir.stream> - %755 = dfcir.sub(%753 : !dfcir.stream>, %751 : !dfcir.stream>) : !dfcir.stream> - %756 = dfcir.input> ("x46") - %757 = dfcir.mul(%86 : !dfcir.const>, %756 : !dfcir.stream>) : !dfcir.stream> - %758 = dfcir.add(%742 : !dfcir.stream>, %756 : !dfcir.stream>) : !dfcir.stream> - %759 = dfcir.mul(%758 : !dfcir.stream>, %14 : !dfcir.const>) : !dfcir.stream> - %760 = dfcir.add(%759 : !dfcir.stream>, %743 : !dfcir.stream>) : !dfcir.stream> - %761 = dfcir.sub(%749 : !dfcir.stream>, %760 : !dfcir.stream>) : !dfcir.stream> - %762 = dfcir.add(%749 : !dfcir.stream>, %760 : !dfcir.stream>) : !dfcir.stream> - %763 = dfcir.sub(%759 : !dfcir.stream>, %757 : !dfcir.stream>) : !dfcir.stream> - %764 = dfcir.sub(%748 : !dfcir.stream>, %763 : !dfcir.stream>) : !dfcir.stream> - %765 = dfcir.add(%748 : !dfcir.stream>, %763 : !dfcir.stream>) : !dfcir.stream> - %766 = dfcir.input> ("x30") - %767 = dfcir.mul(%95 : !dfcir.const>, %766 : !dfcir.stream>) : !dfcir.stream> - %768 = dfcir.add(%21 : !dfcir.stream>, %766 : !dfcir.stream>) : !dfcir.stream> - %769 = dfcir.mul(%768 : !dfcir.stream>, %14 : !dfcir.const>) : !dfcir.stream> - %770 = dfcir.add(%769 : !dfcir.stream>, %94 : !dfcir.stream>) : !dfcir.stream> - %771 = dfcir.sub(%243 : !dfcir.stream>, %770 : !dfcir.stream>) : !dfcir.stream> - %772 = dfcir.sub(%771 : !dfcir.stream>, %381 : !dfcir.stream>) : !dfcir.stream> - %773 = dfcir.shr(%772 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %774 = dfcir.mul(%273 : !dfcir.const>, %773 : !dfcir.stream>) : !dfcir.stream> - %775 = dfcir.add(%771 : !dfcir.stream>, %381 : !dfcir.stream>) : !dfcir.stream> - %776 = dfcir.shr(%775 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %777 = dfcir.mul(%275 : !dfcir.const>, %776 : !dfcir.stream>) : !dfcir.stream> - %778 = dfcir.add(%243 : !dfcir.stream>, %770 : !dfcir.stream>) : !dfcir.stream> - %779 = dfcir.sub(%778 : !dfcir.stream>, %392 : !dfcir.stream>) : !dfcir.stream> - %780 = dfcir.shr(%779 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %781 = dfcir.mul(%267 : !dfcir.const>, %780 : !dfcir.stream>) : !dfcir.stream> - %782 = dfcir.add(%778 : !dfcir.stream>, %392 : !dfcir.stream>) : !dfcir.stream> - %783 = dfcir.shr(%782 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %784 = dfcir.mul(%281 : !dfcir.const>, %783 : !dfcir.stream>) : !dfcir.stream> - %785 = dfcir.sub(%769 : !dfcir.stream>, %767 : !dfcir.stream>) : !dfcir.stream> - %786 = dfcir.sub(%242 : !dfcir.stream>, %785 : !dfcir.stream>) : !dfcir.stream> - %787 = dfcir.sub(%786 : !dfcir.stream>, %387 : !dfcir.stream>) : !dfcir.stream> - %788 = dfcir.shr(%787 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %789 = dfcir.mul(%271 : !dfcir.const>, %788 : !dfcir.stream>) : !dfcir.stream> - %790 = dfcir.add(%786 : !dfcir.stream>, %387 : !dfcir.stream>) : !dfcir.stream> - %791 = dfcir.shr(%790 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %792 = dfcir.mul(%277 : !dfcir.const>, %791 : !dfcir.stream>) : !dfcir.stream> - %793 = dfcir.add(%242 : !dfcir.stream>, %785 : !dfcir.stream>) : !dfcir.stream> - %794 = dfcir.sub(%793 : !dfcir.stream>, %391 : !dfcir.stream>) : !dfcir.stream> - %795 = dfcir.shr(%794 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %796 = dfcir.mul(%269 : !dfcir.const>, %795 : !dfcir.stream>) : !dfcir.stream> - %797 = dfcir.add(%793 : !dfcir.stream>, %391 : !dfcir.stream>) : !dfcir.stream> - %798 = dfcir.shr(%797 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %799 = dfcir.mul(%279 : !dfcir.const>, %798 : !dfcir.stream>) : !dfcir.stream> - %800 = dfcir.input> ("x47") - %801 = dfcir.mul(%179 : !dfcir.const>, %800 : !dfcir.stream>) : !dfcir.stream> - %802 = dfcir.add(%740 : !dfcir.stream>, %800 : !dfcir.stream>) : !dfcir.stream> - %803 = dfcir.mul(%802 : !dfcir.stream>, %116 : !dfcir.const>) : !dfcir.stream> - %804 = dfcir.sub(%803 : !dfcir.stream>, %801 : !dfcir.stream>) : !dfcir.stream> - %805 = dfcir.sub(%804 : !dfcir.stream>, %754 : !dfcir.stream>) : !dfcir.stream> - %806 = dfcir.add(%804 : !dfcir.stream>, %754 : !dfcir.stream>) : !dfcir.stream> - %807 = dfcir.sub(%761 : !dfcir.stream>, %806 : !dfcir.stream>) : !dfcir.stream> - %808 = dfcir.shr(%807 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %809 = dfcir.mul(%274 : !dfcir.const>, %808 : !dfcir.stream>) : !dfcir.stream> - %810 = dfcir.add(%808 : !dfcir.stream>, %773 : !dfcir.stream>) : !dfcir.stream> - %811 = dfcir.mul(%266 : !dfcir.const>, %810 : !dfcir.stream>) : !dfcir.stream> - %812 = dfcir.add(%811 : !dfcir.stream>, %239 : !dfcir.const>) : !dfcir.stream> - %813 = dfcir.sub(%812 : !dfcir.stream>, %774 : !dfcir.stream>) : !dfcir.stream> - %814 = dfcir.shr(%813 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %815 = dfcir.sub(%507 : !dfcir.stream>, %814 : !dfcir.stream>) : !dfcir.stream> - %816 = dfcir.add(%507 : !dfcir.stream>, %814 : !dfcir.stream>) : !dfcir.stream> - %817 = dfcir.sub(%710 : !dfcir.stream>, %816 : !dfcir.stream>) : !dfcir.stream> - %818 = dfcir.shr(%817 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %819 = dfcir.output> ("out36") {operandSegmentSizes = array} - dfcir.connect(%819 : !dfcir.stream>, %818 : !dfcir.stream>) - %820 = dfcir.add(%710 : !dfcir.stream>, %816 : !dfcir.stream>) : !dfcir.stream> - %821 = dfcir.shr(%820 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %822 = dfcir.output> ("out28") {operandSegmentSizes = array} - dfcir.connect(%822 : !dfcir.stream>, %821 : !dfcir.stream>) - %823 = dfcir.sub(%812 : !dfcir.stream>, %809 : !dfcir.stream>) : !dfcir.stream> - %824 = dfcir.shr(%823 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %825 = dfcir.sub(%509 : !dfcir.stream>, %824 : !dfcir.stream>) : !dfcir.stream> - %826 = dfcir.sub(%825 : !dfcir.stream>, %815 : !dfcir.stream>) : !dfcir.stream> - %827 = dfcir.mul(%826 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %828 = dfcir.add(%827 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %829 = dfcir.shr(%828 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %830 = dfcir.sub(%707 : !dfcir.stream>, %829 : !dfcir.stream>) : !dfcir.stream> - %831 = dfcir.shr(%830 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %832 = dfcir.output> ("out44") {operandSegmentSizes = array} - dfcir.connect(%832 : !dfcir.stream>, %831 : !dfcir.stream>) - %833 = dfcir.add(%707 : !dfcir.stream>, %829 : !dfcir.stream>) : !dfcir.stream> - %834 = dfcir.shr(%833 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %835 = dfcir.output> ("out20") {operandSegmentSizes = array} - dfcir.connect(%835 : !dfcir.stream>, %834 : !dfcir.stream>) - %836 = dfcir.add(%825 : !dfcir.stream>, %815 : !dfcir.stream>) : !dfcir.stream> - %837 = dfcir.mul(%836 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %838 = dfcir.add(%837 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %839 = dfcir.shr(%838 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %840 = dfcir.sub(%708 : !dfcir.stream>, %839 : !dfcir.stream>) : !dfcir.stream> - %841 = dfcir.shr(%840 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %842 = dfcir.output> ("out52") {operandSegmentSizes = array} - dfcir.connect(%842 : !dfcir.stream>, %841 : !dfcir.stream>) - %843 = dfcir.add(%708 : !dfcir.stream>, %839 : !dfcir.stream>) : !dfcir.stream> - %844 = dfcir.shr(%843 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %845 = dfcir.output> ("out12") {operandSegmentSizes = array} - dfcir.connect(%845 : !dfcir.stream>, %844 : !dfcir.stream>) - %846 = dfcir.add(%509 : !dfcir.stream>, %824 : !dfcir.stream>) : !dfcir.stream> - %847 = dfcir.sub(%711 : !dfcir.stream>, %846 : !dfcir.stream>) : !dfcir.stream> - %848 = dfcir.shr(%847 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %849 = dfcir.output> ("out60") {operandSegmentSizes = array} - dfcir.connect(%849 : !dfcir.stream>, %848 : !dfcir.stream>) - %850 = dfcir.add(%711 : !dfcir.stream>, %846 : !dfcir.stream>) : !dfcir.stream> - %851 = dfcir.shr(%850 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %852 = dfcir.output> ("out4") {operandSegmentSizes = array} - dfcir.connect(%852 : !dfcir.stream>, %851 : !dfcir.stream>) - %853 = dfcir.add(%761 : !dfcir.stream>, %806 : !dfcir.stream>) : !dfcir.stream> - %854 = dfcir.shr(%853 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %855 = dfcir.mul(%276 : !dfcir.const>, %854 : !dfcir.stream>) : !dfcir.stream> - %856 = dfcir.add(%854 : !dfcir.stream>, %776 : !dfcir.stream>) : !dfcir.stream> - %857 = dfcir.mul(%266 : !dfcir.const>, %856 : !dfcir.stream>) : !dfcir.stream> - %858 = dfcir.add(%857 : !dfcir.stream>, %239 : !dfcir.const>) : !dfcir.stream> - %859 = dfcir.sub(%858 : !dfcir.stream>, %777 : !dfcir.stream>) : !dfcir.stream> - %860 = dfcir.shr(%859 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %861 = dfcir.sub(%517 : !dfcir.stream>, %860 : !dfcir.stream>) : !dfcir.stream> - %862 = dfcir.add(%517 : !dfcir.stream>, %860 : !dfcir.stream>) : !dfcir.stream> - %863 = dfcir.sub(%719 : !dfcir.stream>, %862 : !dfcir.stream>) : !dfcir.stream> - %864 = dfcir.shr(%863 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %865 = dfcir.output> ("out35") {operandSegmentSizes = array} - dfcir.connect(%865 : !dfcir.stream>, %864 : !dfcir.stream>) - %866 = dfcir.add(%719 : !dfcir.stream>, %862 : !dfcir.stream>) : !dfcir.stream> - %867 = dfcir.shr(%866 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %868 = dfcir.output> ("out27") {operandSegmentSizes = array} - dfcir.connect(%868 : !dfcir.stream>, %867 : !dfcir.stream>) - %869 = dfcir.sub(%858 : !dfcir.stream>, %855 : !dfcir.stream>) : !dfcir.stream> - %870 = dfcir.shr(%869 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %871 = dfcir.sub(%519 : !dfcir.stream>, %870 : !dfcir.stream>) : !dfcir.stream> - %872 = dfcir.sub(%871 : !dfcir.stream>, %861 : !dfcir.stream>) : !dfcir.stream> - %873 = dfcir.mul(%872 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %874 = dfcir.add(%873 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %875 = dfcir.shr(%874 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %876 = dfcir.sub(%716 : !dfcir.stream>, %875 : !dfcir.stream>) : !dfcir.stream> - %877 = dfcir.shr(%876 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %878 = dfcir.output> ("out43") {operandSegmentSizes = array} - dfcir.connect(%878 : !dfcir.stream>, %877 : !dfcir.stream>) - %879 = dfcir.add(%716 : !dfcir.stream>, %875 : !dfcir.stream>) : !dfcir.stream> - %880 = dfcir.shr(%879 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %881 = dfcir.output> ("out19") {operandSegmentSizes = array} - dfcir.connect(%881 : !dfcir.stream>, %880 : !dfcir.stream>) - %882 = dfcir.add(%871 : !dfcir.stream>, %861 : !dfcir.stream>) : !dfcir.stream> - %883 = dfcir.mul(%882 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %884 = dfcir.add(%883 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %885 = dfcir.shr(%884 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %886 = dfcir.sub(%717 : !dfcir.stream>, %885 : !dfcir.stream>) : !dfcir.stream> - %887 = dfcir.shr(%886 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %888 = dfcir.output> ("out51") {operandSegmentSizes = array} - dfcir.connect(%888 : !dfcir.stream>, %887 : !dfcir.stream>) - %889 = dfcir.add(%717 : !dfcir.stream>, %885 : !dfcir.stream>) : !dfcir.stream> - %890 = dfcir.shr(%889 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %891 = dfcir.output> ("out11") {operandSegmentSizes = array} - dfcir.connect(%891 : !dfcir.stream>, %890 : !dfcir.stream>) - %892 = dfcir.add(%519 : !dfcir.stream>, %870 : !dfcir.stream>) : !dfcir.stream> - %893 = dfcir.sub(%720 : !dfcir.stream>, %892 : !dfcir.stream>) : !dfcir.stream> - %894 = dfcir.shr(%893 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %895 = dfcir.output> ("out59") {operandSegmentSizes = array} - dfcir.connect(%895 : !dfcir.stream>, %894 : !dfcir.stream>) - %896 = dfcir.add(%720 : !dfcir.stream>, %892 : !dfcir.stream>) : !dfcir.stream> - %897 = dfcir.shr(%896 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %898 = dfcir.output> ("out3") {operandSegmentSizes = array} - dfcir.connect(%898 : !dfcir.stream>, %897 : !dfcir.stream>) - %899 = dfcir.add(%803 : !dfcir.stream>, %741 : !dfcir.stream>) : !dfcir.stream> - %900 = dfcir.sub(%899 : !dfcir.stream>, %755 : !dfcir.stream>) : !dfcir.stream> - %901 = dfcir.sub(%900 : !dfcir.stream>, %805 : !dfcir.stream>) : !dfcir.stream> - %902 = dfcir.mul(%901 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %903 = dfcir.add(%902 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %904 = dfcir.shr(%903 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %905 = dfcir.sub(%764 : !dfcir.stream>, %904 : !dfcir.stream>) : !dfcir.stream> - %906 = dfcir.shr(%905 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %907 = dfcir.mul(%272 : !dfcir.const>, %906 : !dfcir.stream>) : !dfcir.stream> - %908 = dfcir.add(%906 : !dfcir.stream>, %788 : !dfcir.stream>) : !dfcir.stream> - %909 = dfcir.mul(%266 : !dfcir.const>, %908 : !dfcir.stream>) : !dfcir.stream> - %910 = dfcir.add(%909 : !dfcir.stream>, %239 : !dfcir.const>) : !dfcir.stream> - %911 = dfcir.sub(%910 : !dfcir.stream>, %789 : !dfcir.stream>) : !dfcir.stream> - %912 = dfcir.shr(%911 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %913 = dfcir.sub(%533 : !dfcir.stream>, %912 : !dfcir.stream>) : !dfcir.stream> - %914 = dfcir.add(%533 : !dfcir.stream>, %912 : !dfcir.stream>) : !dfcir.stream> - %915 = dfcir.sub(%671 : !dfcir.stream>, %914 : !dfcir.stream>) : !dfcir.stream> - %916 = dfcir.shr(%915 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %917 = dfcir.output> ("out37") {operandSegmentSizes = array} - dfcir.connect(%917 : !dfcir.stream>, %916 : !dfcir.stream>) - %918 = dfcir.add(%671 : !dfcir.stream>, %914 : !dfcir.stream>) : !dfcir.stream> - %919 = dfcir.shr(%918 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %920 = dfcir.output> ("out29") {operandSegmentSizes = array} - dfcir.connect(%920 : !dfcir.stream>, %919 : !dfcir.stream>) - %921 = dfcir.sub(%910 : !dfcir.stream>, %907 : !dfcir.stream>) : !dfcir.stream> - %922 = dfcir.shr(%921 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %923 = dfcir.sub(%535 : !dfcir.stream>, %922 : !dfcir.stream>) : !dfcir.stream> - %924 = dfcir.sub(%923 : !dfcir.stream>, %913 : !dfcir.stream>) : !dfcir.stream> - %925 = dfcir.mul(%924 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %926 = dfcir.add(%925 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %927 = dfcir.shr(%926 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %928 = dfcir.sub(%668 : !dfcir.stream>, %927 : !dfcir.stream>) : !dfcir.stream> - %929 = dfcir.shr(%928 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %930 = dfcir.output> ("out45") {operandSegmentSizes = array} - dfcir.connect(%930 : !dfcir.stream>, %929 : !dfcir.stream>) - %931 = dfcir.add(%668 : !dfcir.stream>, %927 : !dfcir.stream>) : !dfcir.stream> + %579 = dfcir.constant> 799 : si32 + %580 = dfcir.mul[?] (%201 : !dfcir.stream>, %579 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %581 = dfcir.sub[?] (%203 : !dfcir.stream>, %580 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %582 = dfcir.sub[?] (%217 : !dfcir.stream>, %581 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %583 = dfcir.add[?] (%217 : !dfcir.stream>, %581 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %584 = dfcir.constant> 4017 : si32 + %585 = dfcir.mul[?] (%51 : !dfcir.stream>, %584 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %586 = dfcir.sub[?] (%203 : !dfcir.stream>, %585 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %587 = dfcir.sub[?] (%492 : !dfcir.stream>, %586 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %588 = dfcir.sub[?] (%582 : !dfcir.stream>, %587 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %589 = dfcir.mul[?] (%588 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %590 = dfcir.add[?] (%589 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %591 = dfcir.shr(%590 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %592 = dfcir.sub[?] (%212 : !dfcir.stream>, %591 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %593 = dfcir.shr(%592 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %594 = dfcir.mul[?] (%593 : !dfcir.stream>, %8 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %595 = dfcir.add[?] (%424 : !dfcir.stream>, %593 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %596 = dfcir.mul[?] (%595 : !dfcir.stream>, %63 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %597 = dfcir.add[?] (%596 : !dfcir.stream>, %137 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %598 = dfcir.add[?] (%597 : !dfcir.stream>, %425 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %599 = dfcir.shr(%598 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %600 = dfcir.sub[?] (%597 : !dfcir.stream>, %594 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %601 = dfcir.shr(%600 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %602 = dfcir.add[?] (%212 : !dfcir.stream>, %591 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %603 = dfcir.shr(%602 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %604 = dfcir.mul[?] (%603 : !dfcir.stream>, %16 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %605 = dfcir.add[?] (%427 : !dfcir.stream>, %603 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %606 = dfcir.mul[?] (%605 : !dfcir.stream>, %63 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %607 = dfcir.add[?] (%606 : !dfcir.stream>, %137 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %608 = dfcir.add[?] (%607 : !dfcir.stream>, %428 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %609 = dfcir.shr(%608 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %610 = dfcir.sub[?] (%607 : !dfcir.stream>, %604 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %611 = dfcir.shr(%610 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %612 = dfcir.add[?] (%582 : !dfcir.stream>, %587 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %613 = dfcir.mul[?] (%612 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %614 = dfcir.add[?] (%613 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %615 = dfcir.shr(%614 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %616 = dfcir.sub[?] (%213 : !dfcir.stream>, %615 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %617 = dfcir.shr(%616 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %618 = dfcir.mul[?] (%617 : !dfcir.stream>, %4 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %619 = dfcir.add[?] (%434 : !dfcir.stream>, %617 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %620 = dfcir.mul[?] (%619 : !dfcir.stream>, %63 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %621 = dfcir.add[?] (%620 : !dfcir.stream>, %137 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %622 = dfcir.add[?] (%621 : !dfcir.stream>, %435 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %623 = dfcir.shr(%622 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %624 = dfcir.sub[?] (%621 : !dfcir.stream>, %618 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %625 = dfcir.shr(%624 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %626 = dfcir.add[?] (%213 : !dfcir.stream>, %615 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %627 = dfcir.shr(%626 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %628 = dfcir.mul[?] (%627 : !dfcir.stream>, %20 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %629 = dfcir.add[?] (%437 : !dfcir.stream>, %627 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %630 = dfcir.mul[?] (%629 : !dfcir.stream>, %63 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %631 = dfcir.add[?] (%630 : !dfcir.stream>, %137 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %632 = dfcir.add[?] (%631 : !dfcir.stream>, %438 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %633 = dfcir.shr(%632 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %634 = dfcir.sub[?] (%631 : !dfcir.stream>, %628 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %635 = dfcir.shr(%634 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %636 = dfcir.add[?] (%492 : !dfcir.stream>, %586 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %637 = dfcir.constant> 1568 : si32 + %638 = dfcir.mul[?] (%195 : !dfcir.stream>, %637 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %639 = dfcir.add[?] (%210 : !dfcir.stream>, %638 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %640 = dfcir.sub[?] (%200 : !dfcir.stream>, %639 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %641 = dfcir.sub[?] (%640 : !dfcir.stream>, %636 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %642 = dfcir.shr(%641 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %643 = dfcir.mul[?] (%642 : !dfcir.stream>, %10 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %644 = dfcir.add[?] (%412 : !dfcir.stream>, %642 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %645 = dfcir.mul[?] (%644 : !dfcir.stream>, %63 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %646 = dfcir.add[?] (%645 : !dfcir.stream>, %137 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %647 = dfcir.add[?] (%646 : !dfcir.stream>, %413 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %648 = dfcir.shr(%647 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %649 = dfcir.sub[?] (%646 : !dfcir.stream>, %643 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %650 = dfcir.shr(%649 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %651 = dfcir.add[?] (%640 : !dfcir.stream>, %636 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %652 = dfcir.shr(%651 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %653 = dfcir.mul[?] (%652 : !dfcir.stream>, %23 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %654 = dfcir.add[?] (%415 : !dfcir.stream>, %652 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %655 = dfcir.mul[?] (%654 : !dfcir.stream>, %63 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %656 = dfcir.add[?] (%655 : !dfcir.stream>, %137 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %657 = dfcir.add[?] (%656 : !dfcir.stream>, %416 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %658 = dfcir.shr(%657 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %659 = dfcir.sub[?] (%656 : !dfcir.stream>, %653 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %660 = dfcir.shr(%659 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %661 = dfcir.add[?] (%200 : !dfcir.stream>, %639 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %662 = dfcir.sub[?] (%661 : !dfcir.stream>, %583 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %663 = dfcir.shr(%662 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %664 = dfcir.mul[?] (%663 : !dfcir.stream>, %116 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %665 = dfcir.add[?] (%441 : !dfcir.stream>, %663 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %666 = dfcir.mul[?] (%665 : !dfcir.stream>, %63 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %667 = dfcir.add[?] (%666 : !dfcir.stream>, %137 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %668 = dfcir.sub[?] (%667 : !dfcir.stream>, %664 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %669 = dfcir.shr(%668 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %670 = dfcir.add[?] (%661 : !dfcir.stream>, %583 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %671 = dfcir.shr(%670 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %672 = dfcir.add[?] (%443 : !dfcir.stream>, %671 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %673 = dfcir.mul[?] (%672 : !dfcir.stream>, %63 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %674 = dfcir.add[?] (%673 : !dfcir.stream>, %137 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %675 = dfcir.add[?] (%674 : !dfcir.stream>, %444 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %676 = dfcir.shr(%675 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %677 = dfcir.constant> 3406 : si32 + %678 = dfcir.constant> 3406 : si32 + %679 = dfcir.mul[?] (%259 : !dfcir.stream>, %678 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %680 = dfcir.sub[?] (%261 : !dfcir.stream>, %679 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %681 = dfcir.constant> 799 : si32 + %682 = dfcir.mul[?] (%75 : !dfcir.stream>, %681 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %683 = dfcir.sub[?] (%234 : !dfcir.stream>, %682 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %684 = dfcir.sub[?] (%262 : !dfcir.stream>, %683 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %685 = dfcir.add[?] (%262 : !dfcir.stream>, %683 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %686 = dfcir.constant> 799 : si32 + %687 = dfcir.mul[?] (%241 : !dfcir.stream>, %686 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %688 = dfcir.sub[?] (%243 : !dfcir.stream>, %687 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %689 = dfcir.sub[?] (%105 : !dfcir.stream>, %688 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %690 = dfcir.sub[?] (%689 : !dfcir.stream>, %247 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %691 = dfcir.mul[?] (%690 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %692 = dfcir.add[?] (%691 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %693 = dfcir.shr(%692 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %694 = dfcir.add[?] (%689 : !dfcir.stream>, %247 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %695 = dfcir.mul[?] (%694 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %696 = dfcir.add[?] (%695 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %697 = dfcir.shr(%696 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %698 = dfcir.add[?] (%105 : !dfcir.stream>, %688 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %699 = dfcir.constant> 4017 : si32 + %700 = dfcir.mul[?] (%232 : !dfcir.stream>, %699 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %701 = dfcir.sub[?] (%234 : !dfcir.stream>, %700 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %702 = dfcir.sub[?] (%680 : !dfcir.stream>, %701 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %703 = dfcir.sub[?] (%684 : !dfcir.stream>, %702 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %704 = dfcir.mul[?] (%703 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %705 = dfcir.add[?] (%704 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %706 = dfcir.shr(%705 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %707 = dfcir.add[?] (%684 : !dfcir.stream>, %702 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %708 = dfcir.mul[?] (%707 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %709 = dfcir.add[?] (%708 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %710 = dfcir.shr(%709 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %711 = dfcir.add[?] (%680 : !dfcir.stream>, %701 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %712 = dfcir.constant> 3406 : si32 + %713 = dfcir.input> ("x32") + %714 = dfcir.shl(%713 : !dfcir.stream>, 11 : i32) : !dfcir.stream> + %715 = dfcir.add[?] (%714 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %716 = dfcir.sub[?] (%715 : !dfcir.stream>, %96 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %717 = dfcir.sub[?] (%716 : !dfcir.stream>, %401 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %718 = dfcir.sub[?] (%717 : !dfcir.stream>, %693 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %719 = dfcir.shr(%718 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %720 = dfcir.shl(%719 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %721 = dfcir.sub[?] (%288 : !dfcir.stream>, %720 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %722 = dfcir.sub[?] (%721 : !dfcir.stream>, %601 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %723 = dfcir.add[?] (%721 : !dfcir.stream>, %601 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %724 = dfcir.add[?] (%288 : !dfcir.stream>, %720 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %725 = dfcir.sub[?] (%724 : !dfcir.stream>, %599 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %726 = dfcir.add[?] (%724 : !dfcir.stream>, %599 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %727 = dfcir.add[?] (%717 : !dfcir.stream>, %693 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %728 = dfcir.shr(%727 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %729 = dfcir.shl(%728 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %730 = dfcir.sub[?] (%292 : !dfcir.stream>, %729 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %731 = dfcir.sub[?] (%730 : !dfcir.stream>, %611 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %732 = dfcir.add[?] (%730 : !dfcir.stream>, %611 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %733 = dfcir.add[?] (%292 : !dfcir.stream>, %729 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %734 = dfcir.sub[?] (%733 : !dfcir.stream>, %609 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %735 = dfcir.add[?] (%733 : !dfcir.stream>, %609 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %736 = dfcir.add[?] (%716 : !dfcir.stream>, %401 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %737 = dfcir.sub[?] (%736 : !dfcir.stream>, %697 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %738 = dfcir.shr(%737 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %739 = dfcir.shl(%738 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %740 = dfcir.sub[?] (%297 : !dfcir.stream>, %739 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %741 = dfcir.sub[?] (%740 : !dfcir.stream>, %625 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %742 = dfcir.add[?] (%740 : !dfcir.stream>, %625 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %743 = dfcir.add[?] (%297 : !dfcir.stream>, %739 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %744 = dfcir.sub[?] (%743 : !dfcir.stream>, %623 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %745 = dfcir.add[?] (%743 : !dfcir.stream>, %623 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %746 = dfcir.add[?] (%736 : !dfcir.stream>, %697 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %747 = dfcir.shr(%746 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %748 = dfcir.shl(%747 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %749 = dfcir.sub[?] (%301 : !dfcir.stream>, %748 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %750 = dfcir.sub[?] (%749 : !dfcir.stream>, %635 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %751 = dfcir.add[?] (%749 : !dfcir.stream>, %635 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %752 = dfcir.add[?] (%301 : !dfcir.stream>, %748 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %753 = dfcir.sub[?] (%752 : !dfcir.stream>, %633 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %754 = dfcir.add[?] (%752 : !dfcir.stream>, %633 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %755 = dfcir.add[?] (%715 : !dfcir.stream>, %96 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %756 = dfcir.sub[?] (%755 : !dfcir.stream>, %472 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %757 = dfcir.sub[?] (%756 : !dfcir.stream>, %248 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %758 = dfcir.shr(%757 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %759 = dfcir.shl(%758 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %760 = dfcir.sub[?] (%310 : !dfcir.stream>, %759 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %761 = dfcir.sub[?] (%760 : !dfcir.stream>, %650 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %762 = dfcir.add[?] (%760 : !dfcir.stream>, %650 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %763 = dfcir.add[?] (%310 : !dfcir.stream>, %759 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %764 = dfcir.sub[?] (%763 : !dfcir.stream>, %648 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %765 = dfcir.add[?] (%763 : !dfcir.stream>, %648 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %766 = dfcir.add[?] (%756 : !dfcir.stream>, %248 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %767 = dfcir.shr(%766 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %768 = dfcir.shl(%767 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %769 = dfcir.sub[?] (%314 : !dfcir.stream>, %768 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %770 = dfcir.sub[?] (%769 : !dfcir.stream>, %660 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %771 = dfcir.add[?] (%769 : !dfcir.stream>, %660 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %772 = dfcir.add[?] (%314 : !dfcir.stream>, %768 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %773 = dfcir.sub[?] (%772 : !dfcir.stream>, %658 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %774 = dfcir.add[?] (%772 : !dfcir.stream>, %658 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %775 = dfcir.add[?] (%755 : !dfcir.stream>, %472 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %776 = dfcir.sub[?] (%775 : !dfcir.stream>, %698 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %777 = dfcir.shr(%776 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %778 = dfcir.shl(%777 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %779 = dfcir.sub[?] (%319 : !dfcir.stream>, %778 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %780 = dfcir.sub[?] (%779 : !dfcir.stream>, %669 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %781 = dfcir.add[?] (%779 : !dfcir.stream>, %669 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %782 = dfcir.add[?] (%319 : !dfcir.stream>, %778 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %783 = dfcir.add[?] (%775 : !dfcir.stream>, %698 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %784 = dfcir.shr(%783 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %785 = dfcir.shl(%784 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %786 = dfcir.sub[?] (%323 : !dfcir.stream>, %785 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %787 = dfcir.add[?] (%323 : !dfcir.stream>, %785 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %788 = dfcir.sub[?] (%787 : !dfcir.stream>, %676 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %789 = dfcir.add[?] (%787 : !dfcir.stream>, %676 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %790 = dfcir.constant> 3784 : si32 + %791 = dfcir.mul[?] (%238 : !dfcir.stream>, %790 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %792 = dfcir.sub[?] (%240 : !dfcir.stream>, %791 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %793 = dfcir.constant> 3406 : si32 + %794 = dfcir.input> ("x60") + %795 = dfcir.shl(%794 : !dfcir.stream>, 11 : i32) : !dfcir.stream> + %796 = dfcir.sub[?] (%220 : !dfcir.stream>, %795 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %797 = dfcir.sub[?] (%796 : !dfcir.stream>, %792 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %798 = dfcir.sub[?] (%797 : !dfcir.stream>, %706 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %799 = dfcir.shr(%798 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %800 = dfcir.mul[?] (%799 : !dfcir.stream>, %677 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %801 = dfcir.add[?] (%351 : !dfcir.stream>, %799 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %802 = dfcir.mul[?] (%801 : !dfcir.stream>, %102 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %803 = dfcir.add[?] (%802 : !dfcir.stream>, %137 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %804 = dfcir.sub[?] (%803 : !dfcir.stream>, %800 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %805 = dfcir.shr(%804 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %806 = dfcir.sub[?] (%805 : !dfcir.stream>, %504 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %807 = dfcir.add[?] (%805 : !dfcir.stream>, %504 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %808 = dfcir.sub[?] (%725 : !dfcir.stream>, %807 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %809 = dfcir.shr(%808 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %810 = dfcir.output> ("out37") {operandSegmentSizes = array} + dfcir.connect(%810 : !dfcir.stream>, %809 : !dfcir.stream>) + %811 = dfcir.add[?] (%725 : !dfcir.stream>, %807 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %812 = dfcir.shr(%811 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %813 = dfcir.output> ("out29") {operandSegmentSizes = array} + dfcir.connect(%813 : !dfcir.stream>, %812 : !dfcir.stream>) + %814 = dfcir.add[?] (%803 : !dfcir.stream>, %352 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %815 = dfcir.shr(%814 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %816 = dfcir.sub[?] (%815 : !dfcir.stream>, %506 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %817 = dfcir.sub[?] (%816 : !dfcir.stream>, %806 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %818 = dfcir.mul[?] (%817 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %819 = dfcir.add[?] (%818 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %820 = dfcir.shr(%819 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %821 = dfcir.sub[?] (%722 : !dfcir.stream>, %820 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %822 = dfcir.shr(%821 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %823 = dfcir.output> ("out45") {operandSegmentSizes = array} + dfcir.connect(%823 : !dfcir.stream>, %822 : !dfcir.stream>) + %824 = dfcir.add[?] (%722 : !dfcir.stream>, %820 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %825 = dfcir.shr(%824 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %826 = dfcir.output> ("out21") {operandSegmentSizes = array} + dfcir.connect(%826 : !dfcir.stream>, %825 : !dfcir.stream>) + %827 = dfcir.add[?] (%816 : !dfcir.stream>, %806 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %828 = dfcir.mul[?] (%827 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %829 = dfcir.add[?] (%828 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %830 = dfcir.shr(%829 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %831 = dfcir.sub[?] (%723 : !dfcir.stream>, %830 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %832 = dfcir.shr(%831 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %833 = dfcir.output> ("out53") {operandSegmentSizes = array} + dfcir.connect(%833 : !dfcir.stream>, %832 : !dfcir.stream>) + %834 = dfcir.add[?] (%723 : !dfcir.stream>, %830 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %835 = dfcir.shr(%834 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %836 = dfcir.output> ("out13") {operandSegmentSizes = array} + dfcir.connect(%836 : !dfcir.stream>, %835 : !dfcir.stream>) + %837 = dfcir.add[?] (%815 : !dfcir.stream>, %506 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %838 = dfcir.sub[?] (%726 : !dfcir.stream>, %837 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %839 = dfcir.shr(%838 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %840 = dfcir.output> ("out61") {operandSegmentSizes = array} + dfcir.connect(%840 : !dfcir.stream>, %839 : !dfcir.stream>) + %841 = dfcir.add[?] (%726 : !dfcir.stream>, %837 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %842 = dfcir.shr(%841 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %843 = dfcir.output> ("out5") {operandSegmentSizes = array} + dfcir.connect(%843 : !dfcir.stream>, %842 : !dfcir.stream>) + %844 = dfcir.add[?] (%797 : !dfcir.stream>, %706 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %845 = dfcir.shr(%844 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %846 = dfcir.mul[?] (%845 : !dfcir.stream>, %712 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %847 = dfcir.add[?] (%354 : !dfcir.stream>, %845 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %848 = dfcir.mul[?] (%847 : !dfcir.stream>, %102 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %849 = dfcir.add[?] (%848 : !dfcir.stream>, %137 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %850 = dfcir.sub[?] (%849 : !dfcir.stream>, %846 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %851 = dfcir.shr(%850 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %852 = dfcir.sub[?] (%851 : !dfcir.stream>, %514 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %853 = dfcir.add[?] (%851 : !dfcir.stream>, %514 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %854 = dfcir.sub[?] (%734 : !dfcir.stream>, %853 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %855 = dfcir.shr(%854 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %856 = dfcir.output> ("out34") {operandSegmentSizes = array} + dfcir.connect(%856 : !dfcir.stream>, %855 : !dfcir.stream>) + %857 = dfcir.add[?] (%734 : !dfcir.stream>, %853 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %858 = dfcir.shr(%857 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %859 = dfcir.output> ("out26") {operandSegmentSizes = array} + dfcir.connect(%859 : !dfcir.stream>, %858 : !dfcir.stream>) + %860 = dfcir.add[?] (%849 : !dfcir.stream>, %355 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %861 = dfcir.shr(%860 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %862 = dfcir.sub[?] (%861 : !dfcir.stream>, %516 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %863 = dfcir.sub[?] (%862 : !dfcir.stream>, %852 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %864 = dfcir.mul[?] (%863 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %865 = dfcir.add[?] (%864 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %866 = dfcir.shr(%865 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %867 = dfcir.sub[?] (%731 : !dfcir.stream>, %866 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %868 = dfcir.shr(%867 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %869 = dfcir.output> ("out42") {operandSegmentSizes = array} + dfcir.connect(%869 : !dfcir.stream>, %868 : !dfcir.stream>) + %870 = dfcir.add[?] (%731 : !dfcir.stream>, %866 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %871 = dfcir.shr(%870 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %872 = dfcir.output> ("out18") {operandSegmentSizes = array} + dfcir.connect(%872 : !dfcir.stream>, %871 : !dfcir.stream>) + %873 = dfcir.add[?] (%862 : !dfcir.stream>, %852 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %874 = dfcir.mul[?] (%873 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %875 = dfcir.add[?] (%874 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %876 = dfcir.shr(%875 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %877 = dfcir.sub[?] (%732 : !dfcir.stream>, %876 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %878 = dfcir.shr(%877 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %879 = dfcir.output> ("out50") {operandSegmentSizes = array} + dfcir.connect(%879 : !dfcir.stream>, %878 : !dfcir.stream>) + %880 = dfcir.add[?] (%732 : !dfcir.stream>, %876 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %881 = dfcir.shr(%880 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %882 = dfcir.output> ("out10") {operandSegmentSizes = array} + dfcir.connect(%882 : !dfcir.stream>, %881 : !dfcir.stream>) + %883 = dfcir.add[?] (%861 : !dfcir.stream>, %516 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %884 = dfcir.sub[?] (%735 : !dfcir.stream>, %883 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %885 = dfcir.shr(%884 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %886 = dfcir.output> ("out58") {operandSegmentSizes = array} + dfcir.connect(%886 : !dfcir.stream>, %885 : !dfcir.stream>) + %887 = dfcir.add[?] (%735 : !dfcir.stream>, %883 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %888 = dfcir.shr(%887 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %889 = dfcir.output> ("out2") {operandSegmentSizes = array} + dfcir.connect(%889 : !dfcir.stream>, %888 : !dfcir.stream>) + %890 = dfcir.add[?] (%796 : !dfcir.stream>, %792 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %891 = dfcir.sub[?] (%890 : !dfcir.stream>, %710 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %892 = dfcir.shr(%891 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %893 = dfcir.mul[?] (%892 : !dfcir.stream>, %69 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %894 = dfcir.add[?] (%361 : !dfcir.stream>, %892 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %895 = dfcir.mul[?] (%894 : !dfcir.stream>, %102 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %896 = dfcir.add[?] (%895 : !dfcir.stream>, %137 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %897 = dfcir.sub[?] (%896 : !dfcir.stream>, %893 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %898 = dfcir.shr(%897 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %899 = dfcir.sub[?] (%898 : !dfcir.stream>, %525 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %900 = dfcir.add[?] (%898 : !dfcir.stream>, %525 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %901 = dfcir.sub[?] (%744 : !dfcir.stream>, %900 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %902 = dfcir.shr(%901 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %903 = dfcir.output> ("out38") {operandSegmentSizes = array} + dfcir.connect(%903 : !dfcir.stream>, %902 : !dfcir.stream>) + %904 = dfcir.add[?] (%744 : !dfcir.stream>, %900 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %905 = dfcir.shr(%904 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %906 = dfcir.output> ("out30") {operandSegmentSizes = array} + dfcir.connect(%906 : !dfcir.stream>, %905 : !dfcir.stream>) + %907 = dfcir.add[?] (%896 : !dfcir.stream>, %362 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %908 = dfcir.shr(%907 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %909 = dfcir.sub[?] (%908 : !dfcir.stream>, %527 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %910 = dfcir.sub[?] (%909 : !dfcir.stream>, %899 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %911 = dfcir.mul[?] (%910 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %912 = dfcir.add[?] (%911 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %913 = dfcir.shr(%912 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %914 = dfcir.sub[?] (%741 : !dfcir.stream>, %913 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %915 = dfcir.shr(%914 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %916 = dfcir.output> ("out46") {operandSegmentSizes = array} + dfcir.connect(%916 : !dfcir.stream>, %915 : !dfcir.stream>) + %917 = dfcir.add[?] (%741 : !dfcir.stream>, %913 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %918 = dfcir.shr(%917 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %919 = dfcir.output> ("out22") {operandSegmentSizes = array} + dfcir.connect(%919 : !dfcir.stream>, %918 : !dfcir.stream>) + %920 = dfcir.add[?] (%909 : !dfcir.stream>, %899 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %921 = dfcir.mul[?] (%920 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %922 = dfcir.add[?] (%921 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %923 = dfcir.shr(%922 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %924 = dfcir.sub[?] (%742 : !dfcir.stream>, %923 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %925 = dfcir.shr(%924 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %926 = dfcir.output> ("out54") {operandSegmentSizes = array} + dfcir.connect(%926 : !dfcir.stream>, %925 : !dfcir.stream>) + %927 = dfcir.add[?] (%742 : !dfcir.stream>, %923 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %928 = dfcir.shr(%927 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %929 = dfcir.output> ("out14") {operandSegmentSizes = array} + dfcir.connect(%929 : !dfcir.stream>, %928 : !dfcir.stream>) + %930 = dfcir.add[?] (%908 : !dfcir.stream>, %527 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %931 = dfcir.sub[?] (%745 : !dfcir.stream>, %930 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %932 = dfcir.shr(%931 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %933 = dfcir.output> ("out21") {operandSegmentSizes = array} + %933 = dfcir.output> ("out62") {operandSegmentSizes = array} dfcir.connect(%933 : !dfcir.stream>, %932 : !dfcir.stream>) - %934 = dfcir.add(%923 : !dfcir.stream>, %913 : !dfcir.stream>) : !dfcir.stream> - %935 = dfcir.mul(%934 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %936 = dfcir.add(%935 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %937 = dfcir.shr(%936 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %938 = dfcir.sub(%669 : !dfcir.stream>, %937 : !dfcir.stream>) : !dfcir.stream> - %939 = dfcir.shr(%938 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %940 = dfcir.output> ("out53") {operandSegmentSizes = array} - dfcir.connect(%940 : !dfcir.stream>, %939 : !dfcir.stream>) - %941 = dfcir.add(%669 : !dfcir.stream>, %937 : !dfcir.stream>) : !dfcir.stream> - %942 = dfcir.shr(%941 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %943 = dfcir.output> ("out13") {operandSegmentSizes = array} - dfcir.connect(%943 : !dfcir.stream>, %942 : !dfcir.stream>) - %944 = dfcir.add(%535 : !dfcir.stream>, %922 : !dfcir.stream>) : !dfcir.stream> - %945 = dfcir.sub(%672 : !dfcir.stream>, %944 : !dfcir.stream>) : !dfcir.stream> - %946 = dfcir.shr(%945 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %947 = dfcir.output> ("out61") {operandSegmentSizes = array} - dfcir.connect(%947 : !dfcir.stream>, %946 : !dfcir.stream>) - %948 = dfcir.add(%672 : !dfcir.stream>, %944 : !dfcir.stream>) : !dfcir.stream> - %949 = dfcir.shr(%948 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %950 = dfcir.output> ("out5") {operandSegmentSizes = array} - dfcir.connect(%950 : !dfcir.stream>, %949 : !dfcir.stream>) - %951 = dfcir.add(%764 : !dfcir.stream>, %904 : !dfcir.stream>) : !dfcir.stream> - %952 = dfcir.shr(%951 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %953 = dfcir.mul(%278 : !dfcir.const>, %952 : !dfcir.stream>) : !dfcir.stream> - %954 = dfcir.add(%952 : !dfcir.stream>, %791 : !dfcir.stream>) : !dfcir.stream> - %955 = dfcir.mul(%266 : !dfcir.const>, %954 : !dfcir.stream>) : !dfcir.stream> - %956 = dfcir.add(%955 : !dfcir.stream>, %239 : !dfcir.const>) : !dfcir.stream> - %957 = dfcir.sub(%956 : !dfcir.stream>, %792 : !dfcir.stream>) : !dfcir.stream> - %958 = dfcir.shr(%957 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %959 = dfcir.sub(%543 : !dfcir.stream>, %958 : !dfcir.stream>) : !dfcir.stream> - %960 = dfcir.add(%543 : !dfcir.stream>, %958 : !dfcir.stream>) : !dfcir.stream> - %961 = dfcir.sub(%680 : !dfcir.stream>, %960 : !dfcir.stream>) : !dfcir.stream> - %962 = dfcir.shr(%961 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %963 = dfcir.output> ("out34") {operandSegmentSizes = array} - dfcir.connect(%963 : !dfcir.stream>, %962 : !dfcir.stream>) - %964 = dfcir.add(%680 : !dfcir.stream>, %960 : !dfcir.stream>) : !dfcir.stream> - %965 = dfcir.shr(%964 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %966 = dfcir.output> ("out26") {operandSegmentSizes = array} - dfcir.connect(%966 : !dfcir.stream>, %965 : !dfcir.stream>) - %967 = dfcir.sub(%956 : !dfcir.stream>, %953 : !dfcir.stream>) : !dfcir.stream> - %968 = dfcir.shr(%967 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %969 = dfcir.sub(%545 : !dfcir.stream>, %968 : !dfcir.stream>) : !dfcir.stream> - %970 = dfcir.sub(%969 : !dfcir.stream>, %959 : !dfcir.stream>) : !dfcir.stream> - %971 = dfcir.mul(%970 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %972 = dfcir.add(%971 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %973 = dfcir.shr(%972 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %974 = dfcir.sub(%677 : !dfcir.stream>, %973 : !dfcir.stream>) : !dfcir.stream> - %975 = dfcir.shr(%974 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %976 = dfcir.output> ("out42") {operandSegmentSizes = array} - dfcir.connect(%976 : !dfcir.stream>, %975 : !dfcir.stream>) - %977 = dfcir.add(%677 : !dfcir.stream>, %973 : !dfcir.stream>) : !dfcir.stream> + %934 = dfcir.add[?] (%745 : !dfcir.stream>, %930 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %935 = dfcir.shr(%934 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %936 = dfcir.output> ("out6") {operandSegmentSizes = array} + dfcir.connect(%936 : !dfcir.stream>, %935 : !dfcir.stream>) + %937 = dfcir.add[?] (%890 : !dfcir.stream>, %710 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %938 = dfcir.shr(%937 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %939 = dfcir.mul[?] (%938 : !dfcir.stream>, %302 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %940 = dfcir.add[?] (%364 : !dfcir.stream>, %938 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %941 = dfcir.mul[?] (%940 : !dfcir.stream>, %102 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %942 = dfcir.add[?] (%941 : !dfcir.stream>, %137 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %943 = dfcir.sub[?] (%942 : !dfcir.stream>, %939 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %944 = dfcir.shr(%943 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %945 = dfcir.sub[?] (%944 : !dfcir.stream>, %535 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %946 = dfcir.add[?] (%944 : !dfcir.stream>, %535 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %947 = dfcir.sub[?] (%753 : !dfcir.stream>, %946 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %948 = dfcir.shr(%947 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %949 = dfcir.output> ("out33") {operandSegmentSizes = array} + dfcir.connect(%949 : !dfcir.stream>, %948 : !dfcir.stream>) + %950 = dfcir.add[?] (%753 : !dfcir.stream>, %946 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %951 = dfcir.shr(%950 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %952 = dfcir.output> ("out25") {operandSegmentSizes = array} + dfcir.connect(%952 : !dfcir.stream>, %951 : !dfcir.stream>) + %953 = dfcir.add[?] (%942 : !dfcir.stream>, %365 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %954 = dfcir.shr(%953 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %955 = dfcir.sub[?] (%954 : !dfcir.stream>, %537 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %956 = dfcir.sub[?] (%955 : !dfcir.stream>, %945 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %957 = dfcir.mul[?] (%956 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %958 = dfcir.add[?] (%957 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %959 = dfcir.shr(%958 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %960 = dfcir.sub[?] (%750 : !dfcir.stream>, %959 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %961 = dfcir.shr(%960 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %962 = dfcir.output> ("out41") {operandSegmentSizes = array} + dfcir.connect(%962 : !dfcir.stream>, %961 : !dfcir.stream>) + %963 = dfcir.add[?] (%750 : !dfcir.stream>, %959 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %964 = dfcir.shr(%963 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %965 = dfcir.output> ("out17") {operandSegmentSizes = array} + dfcir.connect(%965 : !dfcir.stream>, %964 : !dfcir.stream>) + %966 = dfcir.add[?] (%955 : !dfcir.stream>, %945 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %967 = dfcir.mul[?] (%966 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %968 = dfcir.add[?] (%967 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %969 = dfcir.shr(%968 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %970 = dfcir.sub[?] (%751 : !dfcir.stream>, %969 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %971 = dfcir.shr(%970 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %972 = dfcir.output> ("out49") {operandSegmentSizes = array} + dfcir.connect(%972 : !dfcir.stream>, %971 : !dfcir.stream>) + %973 = dfcir.add[?] (%751 : !dfcir.stream>, %969 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %974 = dfcir.shr(%973 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %975 = dfcir.output> ("out9") {operandSegmentSizes = array} + dfcir.connect(%975 : !dfcir.stream>, %974 : !dfcir.stream>) + %976 = dfcir.add[?] (%954 : !dfcir.stream>, %537 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %977 = dfcir.sub[?] (%754 : !dfcir.stream>, %976 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %978 = dfcir.shr(%977 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %979 = dfcir.output> ("out18") {operandSegmentSizes = array} + %979 = dfcir.output> ("out57") {operandSegmentSizes = array} dfcir.connect(%979 : !dfcir.stream>, %978 : !dfcir.stream>) - %980 = dfcir.add(%969 : !dfcir.stream>, %959 : !dfcir.stream>) : !dfcir.stream> - %981 = dfcir.mul(%980 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %982 = dfcir.add(%981 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %983 = dfcir.shr(%982 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %984 = dfcir.sub(%678 : !dfcir.stream>, %983 : !dfcir.stream>) : !dfcir.stream> - %985 = dfcir.shr(%984 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %986 = dfcir.output> ("out50") {operandSegmentSizes = array} - dfcir.connect(%986 : !dfcir.stream>, %985 : !dfcir.stream>) - %987 = dfcir.add(%678 : !dfcir.stream>, %983 : !dfcir.stream>) : !dfcir.stream> - %988 = dfcir.shr(%987 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %989 = dfcir.output> ("out10") {operandSegmentSizes = array} - dfcir.connect(%989 : !dfcir.stream>, %988 : !dfcir.stream>) - %990 = dfcir.add(%545 : !dfcir.stream>, %968 : !dfcir.stream>) : !dfcir.stream> - %991 = dfcir.sub(%681 : !dfcir.stream>, %990 : !dfcir.stream>) : !dfcir.stream> - %992 = dfcir.shr(%991 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %993 = dfcir.output> ("out58") {operandSegmentSizes = array} - dfcir.connect(%993 : !dfcir.stream>, %992 : !dfcir.stream>) - %994 = dfcir.add(%681 : !dfcir.stream>, %990 : !dfcir.stream>) : !dfcir.stream> - %995 = dfcir.shr(%994 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %996 = dfcir.output> ("out2") {operandSegmentSizes = array} - dfcir.connect(%996 : !dfcir.stream>, %995 : !dfcir.stream>) - %997 = dfcir.add(%900 : !dfcir.stream>, %805 : !dfcir.stream>) : !dfcir.stream> - %998 = dfcir.mul(%997 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %999 = dfcir.add(%998 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %1000 = dfcir.shr(%999 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %1001 = dfcir.sub(%765 : !dfcir.stream>, %1000 : !dfcir.stream>) : !dfcir.stream> - %1002 = dfcir.shr(%1001 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %1003 = dfcir.mul(%270 : !dfcir.const>, %1002 : !dfcir.stream>) : !dfcir.stream> - %1004 = dfcir.add(%1002 : !dfcir.stream>, %795 : !dfcir.stream>) : !dfcir.stream> - %1005 = dfcir.mul(%266 : !dfcir.const>, %1004 : !dfcir.stream>) : !dfcir.stream> - %1006 = dfcir.add(%1005 : !dfcir.stream>, %239 : !dfcir.const>) : !dfcir.stream> - %1007 = dfcir.sub(%1006 : !dfcir.stream>, %796 : !dfcir.stream>) : !dfcir.stream> - %1008 = dfcir.shr(%1007 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %1009 = dfcir.sub(%557 : !dfcir.stream>, %1008 : !dfcir.stream>) : !dfcir.stream> - %1010 = dfcir.add(%557 : !dfcir.stream>, %1008 : !dfcir.stream>) : !dfcir.stream> - %1011 = dfcir.sub(%690 : !dfcir.stream>, %1010 : !dfcir.stream>) : !dfcir.stream> + %980 = dfcir.add[?] (%754 : !dfcir.stream>, %976 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %981 = dfcir.shr(%980 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %982 = dfcir.output> ("out1") {operandSegmentSizes = array} + dfcir.connect(%982 : !dfcir.stream>, %981 : !dfcir.stream>) + %983 = dfcir.add[?] (%220 : !dfcir.stream>, %795 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %984 = dfcir.sub[?] (%983 : !dfcir.stream>, %398 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %985 = dfcir.sub[?] (%984 : !dfcir.stream>, %711 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %986 = dfcir.shr(%985 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %987 = dfcir.mul[?] (%986 : !dfcir.stream>, %12 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %988 = dfcir.add[?] (%340 : !dfcir.stream>, %986 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %989 = dfcir.mul[?] (%988 : !dfcir.stream>, %102 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %990 = dfcir.add[?] (%989 : !dfcir.stream>, %137 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %991 = dfcir.sub[?] (%990 : !dfcir.stream>, %987 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %992 = dfcir.shr(%991 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %993 = dfcir.sub[?] (%992 : !dfcir.stream>, %547 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %994 = dfcir.add[?] (%992 : !dfcir.stream>, %547 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %995 = dfcir.sub[?] (%764 : !dfcir.stream>, %994 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %996 = dfcir.shr(%995 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %997 = dfcir.output> ("out36") {operandSegmentSizes = array} + dfcir.connect(%997 : !dfcir.stream>, %996 : !dfcir.stream>) + %998 = dfcir.add[?] (%764 : !dfcir.stream>, %994 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %999 = dfcir.shr(%998 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %1000 = dfcir.output> ("out28") {operandSegmentSizes = array} + dfcir.connect(%1000 : !dfcir.stream>, %999 : !dfcir.stream>) + %1001 = dfcir.add[?] (%990 : !dfcir.stream>, %341 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1002 = dfcir.shr(%1001 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %1003 = dfcir.sub[?] (%1002 : !dfcir.stream>, %549 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1004 = dfcir.sub[?] (%1003 : !dfcir.stream>, %993 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1005 = dfcir.mul[?] (%1004 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1006 = dfcir.add[?] (%1005 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1007 = dfcir.shr(%1006 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %1008 = dfcir.sub[?] (%761 : !dfcir.stream>, %1007 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1009 = dfcir.shr(%1008 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %1010 = dfcir.output> ("out44") {operandSegmentSizes = array} + dfcir.connect(%1010 : !dfcir.stream>, %1009 : !dfcir.stream>) + %1011 = dfcir.add[?] (%761 : !dfcir.stream>, %1007 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %1012 = dfcir.shr(%1011 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1013 = dfcir.output> ("out38") {operandSegmentSizes = array} + %1013 = dfcir.output> ("out20") {operandSegmentSizes = array} dfcir.connect(%1013 : !dfcir.stream>, %1012 : !dfcir.stream>) - %1014 = dfcir.add(%690 : !dfcir.stream>, %1010 : !dfcir.stream>) : !dfcir.stream> - %1015 = dfcir.shr(%1014 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1016 = dfcir.output> ("out30") {operandSegmentSizes = array} - dfcir.connect(%1016 : !dfcir.stream>, %1015 : !dfcir.stream>) - %1017 = dfcir.sub(%1006 : !dfcir.stream>, %1003 : !dfcir.stream>) : !dfcir.stream> - %1018 = dfcir.shr(%1017 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %1019 = dfcir.sub(%559 : !dfcir.stream>, %1018 : !dfcir.stream>) : !dfcir.stream> - %1020 = dfcir.sub(%1019 : !dfcir.stream>, %1009 : !dfcir.stream>) : !dfcir.stream> - %1021 = dfcir.mul(%1020 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %1022 = dfcir.add(%1021 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %1023 = dfcir.shr(%1022 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %1024 = dfcir.sub(%687 : !dfcir.stream>, %1023 : !dfcir.stream>) : !dfcir.stream> - %1025 = dfcir.shr(%1024 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1026 = dfcir.output> ("out46") {operandSegmentSizes = array} - dfcir.connect(%1026 : !dfcir.stream>, %1025 : !dfcir.stream>) - %1027 = dfcir.add(%687 : !dfcir.stream>, %1023 : !dfcir.stream>) : !dfcir.stream> - %1028 = dfcir.shr(%1027 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1029 = dfcir.output> ("out22") {operandSegmentSizes = array} - dfcir.connect(%1029 : !dfcir.stream>, %1028 : !dfcir.stream>) - %1030 = dfcir.add(%1019 : !dfcir.stream>, %1009 : !dfcir.stream>) : !dfcir.stream> - %1031 = dfcir.mul(%1030 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %1032 = dfcir.add(%1031 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %1033 = dfcir.shr(%1032 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %1034 = dfcir.sub(%688 : !dfcir.stream>, %1033 : !dfcir.stream>) : !dfcir.stream> - %1035 = dfcir.shr(%1034 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1036 = dfcir.output> ("out54") {operandSegmentSizes = array} - dfcir.connect(%1036 : !dfcir.stream>, %1035 : !dfcir.stream>) - %1037 = dfcir.add(%688 : !dfcir.stream>, %1033 : !dfcir.stream>) : !dfcir.stream> - %1038 = dfcir.shr(%1037 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1039 = dfcir.output> ("out14") {operandSegmentSizes = array} - dfcir.connect(%1039 : !dfcir.stream>, %1038 : !dfcir.stream>) - %1040 = dfcir.add(%559 : !dfcir.stream>, %1018 : !dfcir.stream>) : !dfcir.stream> - %1041 = dfcir.sub(%691 : !dfcir.stream>, %1040 : !dfcir.stream>) : !dfcir.stream> + %1014 = dfcir.add[?] (%1003 : !dfcir.stream>, %993 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1015 = dfcir.mul[?] (%1014 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1016 = dfcir.add[?] (%1015 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1017 = dfcir.shr(%1016 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %1018 = dfcir.sub[?] (%762 : !dfcir.stream>, %1017 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1019 = dfcir.shr(%1018 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %1020 = dfcir.output> ("out52") {operandSegmentSizes = array} + dfcir.connect(%1020 : !dfcir.stream>, %1019 : !dfcir.stream>) + %1021 = dfcir.add[?] (%762 : !dfcir.stream>, %1017 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1022 = dfcir.shr(%1021 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %1023 = dfcir.output> ("out12") {operandSegmentSizes = array} + dfcir.connect(%1023 : !dfcir.stream>, %1022 : !dfcir.stream>) + %1024 = dfcir.add[?] (%1002 : !dfcir.stream>, %549 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1025 = dfcir.sub[?] (%765 : !dfcir.stream>, %1024 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1026 = dfcir.shr(%1025 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %1027 = dfcir.output> ("out60") {operandSegmentSizes = array} + dfcir.connect(%1027 : !dfcir.stream>, %1026 : !dfcir.stream>) + %1028 = dfcir.add[?] (%765 : !dfcir.stream>, %1024 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1029 = dfcir.shr(%1028 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %1030 = dfcir.output> ("out4") {operandSegmentSizes = array} + dfcir.connect(%1030 : !dfcir.stream>, %1029 : !dfcir.stream>) + %1031 = dfcir.add[?] (%984 : !dfcir.stream>, %711 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1032 = dfcir.shr(%1031 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %1033 = dfcir.mul[?] (%1032 : !dfcir.stream>, %15 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1034 = dfcir.add[?] (%343 : !dfcir.stream>, %1032 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1035 = dfcir.mul[?] (%1034 : !dfcir.stream>, %102 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1036 = dfcir.add[?] (%1035 : !dfcir.stream>, %137 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1037 = dfcir.sub[?] (%1036 : !dfcir.stream>, %1033 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1038 = dfcir.shr(%1037 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %1039 = dfcir.sub[?] (%1038 : !dfcir.stream>, %557 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1040 = dfcir.add[?] (%1038 : !dfcir.stream>, %557 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1041 = dfcir.sub[?] (%773 : !dfcir.stream>, %1040 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %1042 = dfcir.shr(%1041 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1043 = dfcir.output> ("out62") {operandSegmentSizes = array} + %1043 = dfcir.output> ("out35") {operandSegmentSizes = array} dfcir.connect(%1043 : !dfcir.stream>, %1042 : !dfcir.stream>) - %1044 = dfcir.add(%691 : !dfcir.stream>, %1040 : !dfcir.stream>) : !dfcir.stream> + %1044 = dfcir.add[?] (%773 : !dfcir.stream>, %1040 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %1045 = dfcir.shr(%1044 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1046 = dfcir.output> ("out6") {operandSegmentSizes = array} + %1046 = dfcir.output> ("out27") {operandSegmentSizes = array} dfcir.connect(%1046 : !dfcir.stream>, %1045 : !dfcir.stream>) - %1047 = dfcir.add(%765 : !dfcir.stream>, %1000 : !dfcir.stream>) : !dfcir.stream> - %1048 = dfcir.shr(%1047 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %1049 = dfcir.mul(%280 : !dfcir.const>, %1048 : !dfcir.stream>) : !dfcir.stream> - %1050 = dfcir.add(%1048 : !dfcir.stream>, %798 : !dfcir.stream>) : !dfcir.stream> - %1051 = dfcir.mul(%266 : !dfcir.const>, %1050 : !dfcir.stream>) : !dfcir.stream> - %1052 = dfcir.add(%1051 : !dfcir.stream>, %239 : !dfcir.const>) : !dfcir.stream> - %1053 = dfcir.sub(%1052 : !dfcir.stream>, %799 : !dfcir.stream>) : !dfcir.stream> - %1054 = dfcir.shr(%1053 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %1055 = dfcir.sub(%567 : !dfcir.stream>, %1054 : !dfcir.stream>) : !dfcir.stream> - %1056 = dfcir.add(%567 : !dfcir.stream>, %1054 : !dfcir.stream>) : !dfcir.stream> - %1057 = dfcir.sub(%699 : !dfcir.stream>, %1056 : !dfcir.stream>) : !dfcir.stream> + %1047 = dfcir.add[?] (%1036 : !dfcir.stream>, %403 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1048 = dfcir.shr(%1047 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %1049 = dfcir.sub[?] (%1048 : !dfcir.stream>, %559 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1050 = dfcir.sub[?] (%1049 : !dfcir.stream>, %1039 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1051 = dfcir.mul[?] (%1050 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1052 = dfcir.add[?] (%1051 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1053 = dfcir.shr(%1052 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %1054 = dfcir.sub[?] (%770 : !dfcir.stream>, %1053 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1055 = dfcir.shr(%1054 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %1056 = dfcir.output> ("out43") {operandSegmentSizes = array} + dfcir.connect(%1056 : !dfcir.stream>, %1055 : !dfcir.stream>) + %1057 = dfcir.add[?] (%770 : !dfcir.stream>, %1053 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %1058 = dfcir.shr(%1057 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1059 = dfcir.output> ("out33") {operandSegmentSizes = array} + %1059 = dfcir.output> ("out19") {operandSegmentSizes = array} dfcir.connect(%1059 : !dfcir.stream>, %1058 : !dfcir.stream>) - %1060 = dfcir.add(%699 : !dfcir.stream>, %1056 : !dfcir.stream>) : !dfcir.stream> - %1061 = dfcir.shr(%1060 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1062 = dfcir.output> ("out25") {operandSegmentSizes = array} - dfcir.connect(%1062 : !dfcir.stream>, %1061 : !dfcir.stream>) - %1063 = dfcir.sub(%1052 : !dfcir.stream>, %1049 : !dfcir.stream>) : !dfcir.stream> - %1064 = dfcir.shr(%1063 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %1065 = dfcir.sub(%569 : !dfcir.stream>, %1064 : !dfcir.stream>) : !dfcir.stream> - %1066 = dfcir.sub(%1065 : !dfcir.stream>, %1055 : !dfcir.stream>) : !dfcir.stream> - %1067 = dfcir.mul(%1066 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %1068 = dfcir.add(%1067 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %1069 = dfcir.shr(%1068 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %1070 = dfcir.sub(%696 : !dfcir.stream>, %1069 : !dfcir.stream>) : !dfcir.stream> - %1071 = dfcir.shr(%1070 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1072 = dfcir.output> ("out41") {operandSegmentSizes = array} - dfcir.connect(%1072 : !dfcir.stream>, %1071 : !dfcir.stream>) - %1073 = dfcir.add(%696 : !dfcir.stream>, %1069 : !dfcir.stream>) : !dfcir.stream> - %1074 = dfcir.shr(%1073 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1075 = dfcir.output> ("out17") {operandSegmentSizes = array} - dfcir.connect(%1075 : !dfcir.stream>, %1074 : !dfcir.stream>) - %1076 = dfcir.add(%1065 : !dfcir.stream>, %1055 : !dfcir.stream>) : !dfcir.stream> - %1077 = dfcir.mul(%1076 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %1078 = dfcir.add(%1077 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %1079 = dfcir.shr(%1078 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %1080 = dfcir.sub(%697 : !dfcir.stream>, %1079 : !dfcir.stream>) : !dfcir.stream> - %1081 = dfcir.shr(%1080 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1082 = dfcir.output> ("out49") {operandSegmentSizes = array} - dfcir.connect(%1082 : !dfcir.stream>, %1081 : !dfcir.stream>) - %1083 = dfcir.add(%697 : !dfcir.stream>, %1079 : !dfcir.stream>) : !dfcir.stream> - %1084 = dfcir.shr(%1083 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1085 = dfcir.output> ("out9") {operandSegmentSizes = array} - dfcir.connect(%1085 : !dfcir.stream>, %1084 : !dfcir.stream>) - %1086 = dfcir.add(%569 : !dfcir.stream>, %1064 : !dfcir.stream>) : !dfcir.stream> - %1087 = dfcir.sub(%700 : !dfcir.stream>, %1086 : !dfcir.stream>) : !dfcir.stream> - %1088 = dfcir.shr(%1087 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1089 = dfcir.output> ("out57") {operandSegmentSizes = array} - dfcir.connect(%1089 : !dfcir.stream>, %1088 : !dfcir.stream>) - %1090 = dfcir.add(%700 : !dfcir.stream>, %1086 : !dfcir.stream>) : !dfcir.stream> - %1091 = dfcir.shr(%1090 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1092 = dfcir.output> ("out1") {operandSegmentSizes = array} - dfcir.connect(%1092 : !dfcir.stream>, %1091 : !dfcir.stream>) - %1093 = dfcir.add(%899 : !dfcir.stream>, %755 : !dfcir.stream>) : !dfcir.stream> - %1094 = dfcir.sub(%762 : !dfcir.stream>, %1093 : !dfcir.stream>) : !dfcir.stream> - %1095 = dfcir.shr(%1094 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %1096 = dfcir.mul(%268 : !dfcir.const>, %1095 : !dfcir.stream>) : !dfcir.stream> - %1097 = dfcir.add(%1095 : !dfcir.stream>, %780 : !dfcir.stream>) : !dfcir.stream> - %1098 = dfcir.mul(%266 : !dfcir.const>, %1097 : !dfcir.stream>) : !dfcir.stream> - %1099 = dfcir.add(%1098 : !dfcir.stream>, %239 : !dfcir.const>) : !dfcir.stream> - %1100 = dfcir.sub(%1099 : !dfcir.stream>, %781 : !dfcir.stream>) : !dfcir.stream> - %1101 = dfcir.shr(%1100 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %1102 = dfcir.sub(%578 : !dfcir.stream>, %1101 : !dfcir.stream>) : !dfcir.stream> - %1103 = dfcir.add(%578 : !dfcir.stream>, %1101 : !dfcir.stream>) : !dfcir.stream> - %1104 = dfcir.sub(%729 : !dfcir.stream>, %1103 : !dfcir.stream>) : !dfcir.stream> - %1105 = dfcir.shr(%1104 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1106 = dfcir.output> ("out39") {operandSegmentSizes = array} - dfcir.connect(%1106 : !dfcir.stream>, %1105 : !dfcir.stream>) - %1107 = dfcir.add(%729 : !dfcir.stream>, %1103 : !dfcir.stream>) : !dfcir.stream> - %1108 = dfcir.shr(%1107 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1109 = dfcir.output> ("out31") {operandSegmentSizes = array} - dfcir.connect(%1109 : !dfcir.stream>, %1108 : !dfcir.stream>) - %1110 = dfcir.sub(%1099 : !dfcir.stream>, %1096 : !dfcir.stream>) : !dfcir.stream> - %1111 = dfcir.shr(%1110 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %1112 = dfcir.sub(%580 : !dfcir.stream>, %1111 : !dfcir.stream>) : !dfcir.stream> - %1113 = dfcir.sub(%1112 : !dfcir.stream>, %1102 : !dfcir.stream>) : !dfcir.stream> - %1114 = dfcir.mul(%1113 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %1115 = dfcir.add(%1114 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %1116 = dfcir.shr(%1115 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %1117 = dfcir.sub(%726 : !dfcir.stream>, %1116 : !dfcir.stream>) : !dfcir.stream> - %1118 = dfcir.shr(%1117 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1119 = dfcir.output> ("out47") {operandSegmentSizes = array} - dfcir.connect(%1119 : !dfcir.stream>, %1118 : !dfcir.stream>) - %1120 = dfcir.add(%726 : !dfcir.stream>, %1116 : !dfcir.stream>) : !dfcir.stream> - %1121 = dfcir.shr(%1120 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1122 = dfcir.output> ("out23") {operandSegmentSizes = array} - dfcir.connect(%1122 : !dfcir.stream>, %1121 : !dfcir.stream>) - %1123 = dfcir.add(%1112 : !dfcir.stream>, %1102 : !dfcir.stream>) : !dfcir.stream> - %1124 = dfcir.mul(%1123 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %1125 = dfcir.add(%1124 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %1126 = dfcir.shr(%1125 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %1127 = dfcir.sub(%727 : !dfcir.stream>, %1126 : !dfcir.stream>) : !dfcir.stream> - %1128 = dfcir.shr(%1127 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1129 = dfcir.output> ("out55") {operandSegmentSizes = array} - dfcir.connect(%1129 : !dfcir.stream>, %1128 : !dfcir.stream>) - %1130 = dfcir.add(%727 : !dfcir.stream>, %1126 : !dfcir.stream>) : !dfcir.stream> - %1131 = dfcir.shr(%1130 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1132 = dfcir.output> ("out15") {operandSegmentSizes = array} - dfcir.connect(%1132 : !dfcir.stream>, %1131 : !dfcir.stream>) - %1133 = dfcir.add(%580 : !dfcir.stream>, %1111 : !dfcir.stream>) : !dfcir.stream> - %1134 = dfcir.sub(%730 : !dfcir.stream>, %1133 : !dfcir.stream>) : !dfcir.stream> - %1135 = dfcir.shr(%1134 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1136 = dfcir.output> ("out63") {operandSegmentSizes = array} - dfcir.connect(%1136 : !dfcir.stream>, %1135 : !dfcir.stream>) - %1137 = dfcir.add(%730 : !dfcir.stream>, %1133 : !dfcir.stream>) : !dfcir.stream> - %1138 = dfcir.shr(%1137 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1139 = dfcir.output> ("out7") {operandSegmentSizes = array} - dfcir.connect(%1139 : !dfcir.stream>, %1138 : !dfcir.stream>) - %1140 = dfcir.add(%762 : !dfcir.stream>, %1093 : !dfcir.stream>) : !dfcir.stream> - %1141 = dfcir.shr(%1140 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %1142 = dfcir.mul(%282 : !dfcir.const>, %1141 : !dfcir.stream>) : !dfcir.stream> - %1143 = dfcir.add(%1141 : !dfcir.stream>, %783 : !dfcir.stream>) : !dfcir.stream> - %1144 = dfcir.mul(%266 : !dfcir.const>, %1143 : !dfcir.stream>) : !dfcir.stream> - %1145 = dfcir.add(%1144 : !dfcir.stream>, %239 : !dfcir.const>) : !dfcir.stream> - %1146 = dfcir.sub(%1145 : !dfcir.stream>, %784 : !dfcir.stream>) : !dfcir.stream> - %1147 = dfcir.shr(%1146 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %1148 = dfcir.sub(%588 : !dfcir.stream>, %1147 : !dfcir.stream>) : !dfcir.stream> - %1149 = dfcir.add(%588 : !dfcir.stream>, %1147 : !dfcir.stream>) : !dfcir.stream> - %1150 = dfcir.sub(%738 : !dfcir.stream>, %1149 : !dfcir.stream>) : !dfcir.stream> - %1151 = dfcir.shr(%1150 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1152 = dfcir.output> ("out32") {operandSegmentSizes = array} - dfcir.connect(%1152 : !dfcir.stream>, %1151 : !dfcir.stream>) - %1153 = dfcir.add(%738 : !dfcir.stream>, %1149 : !dfcir.stream>) : !dfcir.stream> - %1154 = dfcir.shr(%1153 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1155 = dfcir.output> ("out24") {operandSegmentSizes = array} - dfcir.connect(%1155 : !dfcir.stream>, %1154 : !dfcir.stream>) - %1156 = dfcir.sub(%1145 : !dfcir.stream>, %1142 : !dfcir.stream>) : !dfcir.stream> - %1157 = dfcir.shr(%1156 : !dfcir.stream>, 3 : i32) : !dfcir.stream> - %1158 = dfcir.sub(%590 : !dfcir.stream>, %1157 : !dfcir.stream>) : !dfcir.stream> - %1159 = dfcir.sub(%1158 : !dfcir.stream>, %1148 : !dfcir.stream>) : !dfcir.stream> - %1160 = dfcir.mul(%1159 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %1161 = dfcir.add(%1160 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %1162 = dfcir.shr(%1161 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %1163 = dfcir.sub(%735 : !dfcir.stream>, %1162 : !dfcir.stream>) : !dfcir.stream> - %1164 = dfcir.shr(%1163 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1165 = dfcir.output> ("out40") {operandSegmentSizes = array} - dfcir.connect(%1165 : !dfcir.stream>, %1164 : !dfcir.stream>) - %1166 = dfcir.add(%735 : !dfcir.stream>, %1162 : !dfcir.stream>) : !dfcir.stream> - %1167 = dfcir.shr(%1166 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1168 = dfcir.output> ("out16") {operandSegmentSizes = array} - dfcir.connect(%1168 : !dfcir.stream>, %1167 : !dfcir.stream>) - %1169 = dfcir.add(%1158 : !dfcir.stream>, %1148 : !dfcir.stream>) : !dfcir.stream> - %1170 = dfcir.mul(%1169 : !dfcir.stream>, %111 : !dfcir.const>) : !dfcir.stream> - %1171 = dfcir.add(%1170 : !dfcir.stream>, %208 : !dfcir.const>) : !dfcir.stream> - %1172 = dfcir.shr(%1171 : !dfcir.stream>, 8 : i32) : !dfcir.stream> - %1173 = dfcir.sub(%736 : !dfcir.stream>, %1172 : !dfcir.stream>) : !dfcir.stream> + %1060 = dfcir.add[?] (%1049 : !dfcir.stream>, %1039 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1061 = dfcir.mul[?] (%1060 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1062 = dfcir.add[?] (%1061 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1063 = dfcir.shr(%1062 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %1064 = dfcir.sub[?] (%771 : !dfcir.stream>, %1063 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1065 = dfcir.shr(%1064 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %1066 = dfcir.output> ("out51") {operandSegmentSizes = array} + dfcir.connect(%1066 : !dfcir.stream>, %1065 : !dfcir.stream>) + %1067 = dfcir.add[?] (%771 : !dfcir.stream>, %1063 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1068 = dfcir.shr(%1067 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %1069 = dfcir.output> ("out11") {operandSegmentSizes = array} + dfcir.connect(%1069 : !dfcir.stream>, %1068 : !dfcir.stream>) + %1070 = dfcir.add[?] (%1048 : !dfcir.stream>, %559 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1071 = dfcir.sub[?] (%774 : !dfcir.stream>, %1070 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1072 = dfcir.shr(%1071 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %1073 = dfcir.output> ("out59") {operandSegmentSizes = array} + dfcir.connect(%1073 : !dfcir.stream>, %1072 : !dfcir.stream>) + %1074 = dfcir.add[?] (%774 : !dfcir.stream>, %1070 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1075 = dfcir.shr(%1074 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %1076 = dfcir.output> ("out3") {operandSegmentSizes = array} + dfcir.connect(%1076 : !dfcir.stream>, %1075 : !dfcir.stream>) + %1077 = dfcir.add[?] (%983 : !dfcir.stream>, %398 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1078 = dfcir.sub[?] (%1077 : !dfcir.stream>, %685 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1079 = dfcir.shr(%1078 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %1080 = dfcir.mul[?] (%1079 : !dfcir.stream>, %2 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1081 = dfcir.add[?] (%368 : !dfcir.stream>, %1079 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1082 = dfcir.mul[?] (%1081 : !dfcir.stream>, %102 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1083 = dfcir.add[?] (%1082 : !dfcir.stream>, %137 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1084 = dfcir.sub[?] (%1083 : !dfcir.stream>, %1080 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1085 = dfcir.shr(%1084 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %1086 = dfcir.sub[?] (%1085 : !dfcir.stream>, %568 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1087 = dfcir.add[?] (%1085 : !dfcir.stream>, %568 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1088 = dfcir.add[?] (%1083 : !dfcir.stream>, %369 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1089 = dfcir.shr(%1088 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %1090 = dfcir.sub[?] (%1089 : !dfcir.stream>, %570 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1091 = dfcir.sub[?] (%1090 : !dfcir.stream>, %1086 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1092 = dfcir.mul[?] (%1091 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1093 = dfcir.add[?] (%1092 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1094 = dfcir.shr(%1093 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %1095 = dfcir.sub[?] (%780 : !dfcir.stream>, %1094 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1096 = dfcir.shr(%1095 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %1097 = dfcir.output> ("out47") {operandSegmentSizes = array} + dfcir.connect(%1097 : !dfcir.stream>, %1096 : !dfcir.stream>) + %1098 = dfcir.add[?] (%780 : !dfcir.stream>, %1094 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1099 = dfcir.shr(%1098 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %1100 = dfcir.output> ("out23") {operandSegmentSizes = array} + dfcir.connect(%1100 : !dfcir.stream>, %1099 : !dfcir.stream>) + %1101 = dfcir.add[?] (%1090 : !dfcir.stream>, %1086 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1102 = dfcir.mul[?] (%1101 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1103 = dfcir.add[?] (%1102 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1104 = dfcir.shr(%1103 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %1105 = dfcir.sub[?] (%781 : !dfcir.stream>, %1104 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1106 = dfcir.shr(%1105 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %1107 = dfcir.output> ("out55") {operandSegmentSizes = array} + dfcir.connect(%1107 : !dfcir.stream>, %1106 : !dfcir.stream>) + %1108 = dfcir.add[?] (%781 : !dfcir.stream>, %1104 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1109 = dfcir.shr(%1108 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %1110 = dfcir.output> ("out15") {operandSegmentSizes = array} + dfcir.connect(%1110 : !dfcir.stream>, %1109 : !dfcir.stream>) + %1111 = dfcir.add[?] (%1089 : !dfcir.stream>, %570 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1112 = dfcir.add[?] (%1077 : !dfcir.stream>, %685 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1113 = dfcir.shr(%1112 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %1114 = dfcir.mul[?] (%1113 : !dfcir.stream>, %793 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1115 = dfcir.add[?] (%371 : !dfcir.stream>, %1113 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1116 = dfcir.mul[?] (%1115 : !dfcir.stream>, %102 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1117 = dfcir.add[?] (%1116 : !dfcir.stream>, %137 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1118 = dfcir.sub[?] (%1117 : !dfcir.stream>, %1114 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1119 = dfcir.shr(%1118 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %1120 = dfcir.sub[?] (%1119 : !dfcir.stream>, %578 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1121 = dfcir.add[?] (%1119 : !dfcir.stream>, %578 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1122 = dfcir.sub[?] (%788 : !dfcir.stream>, %1121 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1123 = dfcir.shr(%1122 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %1124 = dfcir.output> ("out32") {operandSegmentSizes = array} + dfcir.connect(%1124 : !dfcir.stream>, %1123 : !dfcir.stream>) + %1125 = dfcir.add[?] (%788 : !dfcir.stream>, %1121 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1126 = dfcir.shr(%1125 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %1127 = dfcir.output> ("out24") {operandSegmentSizes = array} + dfcir.connect(%1127 : !dfcir.stream>, %1126 : !dfcir.stream>) + %1128 = dfcir.add[?] (%1117 : !dfcir.stream>, %372 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1129 = dfcir.shr(%1128 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %1130 = dfcir.constant> 799 : si32 + %1131 = dfcir.mul[?] (%488 : !dfcir.stream>, %1130 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1132 = dfcir.sub[?] (%576 : !dfcir.stream>, %1131 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1133 = dfcir.shr(%1132 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %1134 = dfcir.sub[?] (%1129 : !dfcir.stream>, %1133 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1135 = dfcir.sub[?] (%1134 : !dfcir.stream>, %1120 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1136 = dfcir.mul[?] (%1135 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1137 = dfcir.add[?] (%1136 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1138 = dfcir.shr(%1137 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %1139 = dfcir.add[?] (%1134 : !dfcir.stream>, %1120 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1140 = dfcir.mul[?] (%1139 : !dfcir.stream>, %62 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1141 = dfcir.add[?] (%1140 : !dfcir.stream>, %169 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1142 = dfcir.shr(%1141 : !dfcir.stream>, 8 : i32) : !dfcir.stream> + %1143 = dfcir.add[?] (%1129 : !dfcir.stream>, %1133 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1144 = dfcir.sub[?] (%789 : !dfcir.stream>, %1143 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1145 = dfcir.shr(%1144 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %1146 = dfcir.output> ("out56") {operandSegmentSizes = array} + dfcir.connect(%1146 : !dfcir.stream>, %1145 : !dfcir.stream>) + %1147 = dfcir.add[?] (%789 : !dfcir.stream>, %1143 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1148 = dfcir.shr(%1147 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %1149 = dfcir.output> ("out0") {operandSegmentSizes = array} + dfcir.connect(%1149 : !dfcir.stream>, %1148 : !dfcir.stream>) + %1150 = dfcir.constant> 1568 : si32 + %1151 = dfcir.mul[?] (%441 : !dfcir.stream>, %1150 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1152 = dfcir.add[?] (%667 : !dfcir.stream>, %1151 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1153 = dfcir.shr(%1152 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %1154 = dfcir.sub[?] (%782 : !dfcir.stream>, %1153 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1155 = dfcir.sub[?] (%1154 : !dfcir.stream>, %1087 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1156 = dfcir.shr(%1155 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %1157 = dfcir.output> ("out39") {operandSegmentSizes = array} + dfcir.connect(%1157 : !dfcir.stream>, %1156 : !dfcir.stream>) + %1158 = dfcir.add[?] (%1154 : !dfcir.stream>, %1087 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1159 = dfcir.shr(%1158 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %1160 = dfcir.output> ("out31") {operandSegmentSizes = array} + dfcir.connect(%1160 : !dfcir.stream>, %1159 : !dfcir.stream>) + %1161 = dfcir.add[?] (%782 : !dfcir.stream>, %1153 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1162 = dfcir.sub[?] (%1161 : !dfcir.stream>, %1111 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1163 = dfcir.shr(%1162 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %1164 = dfcir.output> ("out63") {operandSegmentSizes = array} + dfcir.connect(%1164 : !dfcir.stream>, %1163 : !dfcir.stream>) + %1165 = dfcir.add[?] (%1161 : !dfcir.stream>, %1111 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1166 = dfcir.shr(%1165 : !dfcir.stream>, 14 : i32) : !dfcir.stream> + %1167 = dfcir.output> ("out7") {operandSegmentSizes = array} + dfcir.connect(%1167 : !dfcir.stream>, %1166 : !dfcir.stream>) + %1168 = dfcir.constant> 3784 : si32 + %1169 = dfcir.mul[?] (%671 : !dfcir.stream>, %1168 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} + %1170 = dfcir.sub[?] (%674 : !dfcir.stream>, %1169 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1171 = dfcir.shr(%1170 : !dfcir.stream>, 3 : i32) : !dfcir.stream> + %1172 = dfcir.sub[?] (%786 : !dfcir.stream>, %1171 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1173 = dfcir.sub[?] (%1172 : !dfcir.stream>, %1138 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %1174 = dfcir.shr(%1173 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1175 = dfcir.output> ("out48") {operandSegmentSizes = array} + %1175 = dfcir.output> ("out40") {operandSegmentSizes = array} dfcir.connect(%1175 : !dfcir.stream>, %1174 : !dfcir.stream>) - %1176 = dfcir.add(%736 : !dfcir.stream>, %1172 : !dfcir.stream>) : !dfcir.stream> + %1176 = dfcir.add[?] (%1172 : !dfcir.stream>, %1138 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %1177 = dfcir.shr(%1176 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1178 = dfcir.output> ("out8") {operandSegmentSizes = array} + %1178 = dfcir.output> ("out16") {operandSegmentSizes = array} dfcir.connect(%1178 : !dfcir.stream>, %1177 : !dfcir.stream>) - %1179 = dfcir.add(%590 : !dfcir.stream>, %1157 : !dfcir.stream>) : !dfcir.stream> - %1180 = dfcir.sub(%739 : !dfcir.stream>, %1179 : !dfcir.stream>) : !dfcir.stream> + %1179 = dfcir.add[?] (%786 : !dfcir.stream>, %1171 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %1180 = dfcir.sub[?] (%1179 : !dfcir.stream>, %1142 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %1181 = dfcir.shr(%1180 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1182 = dfcir.output> ("out56") {operandSegmentSizes = array} + %1182 = dfcir.output> ("out48") {operandSegmentSizes = array} dfcir.connect(%1182 : !dfcir.stream>, %1181 : !dfcir.stream>) - %1183 = dfcir.add(%739 : !dfcir.stream>, %1179 : !dfcir.stream>) : !dfcir.stream> + %1183 = dfcir.add[?] (%1179 : !dfcir.stream>, %1142 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %1184 = dfcir.shr(%1183 : !dfcir.stream>, 14 : i32) : !dfcir.stream> - %1185 = dfcir.output> ("out0") {operandSegmentSizes = array} + %1185 = dfcir.output> ("out8") {operandSegmentSizes = array} dfcir.connect(%1185 : !dfcir.stream>, %1184 : !dfcir.stream>) } } diff --git a/test/data/matrixmul2.mlir b/test/data/matrixmul2.mlir index f7d539a..f81b3b9 100644 --- a/test/data/matrixmul2.mlir +++ b/test/data/matrixmul2.mlir @@ -1,31 +1,31 @@ module { dfcir.kernel "MatrixMul2" { - %0 = dfcir.input> ("y22") - %1 = dfcir.input> ("y21") - %2 = dfcir.input> ("y12") - %3 = dfcir.input> ("y11") - %4 = dfcir.input> ("x22") - %5 = dfcir.mul(%4 : !dfcir.stream>, %0 : !dfcir.stream>) : !dfcir.stream> - %6 = dfcir.mul(%4 : !dfcir.stream>, %1 : !dfcir.stream>) : !dfcir.stream> + %0 = dfcir.input> ("y21") + %1 = dfcir.input> ("y12") + %2 = dfcir.input> ("y11") + %3 = dfcir.input> ("x22") + %4 = dfcir.mul[?] (%3 : !dfcir.stream>, %0 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %5 = dfcir.input> ("y22") + %6 = dfcir.mul[?] (%3 : !dfcir.stream>, %5 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %7 = dfcir.input> ("x21") - %8 = dfcir.mul(%7 : !dfcir.stream>, %2 : !dfcir.stream>) : !dfcir.stream> - %9 = dfcir.add(%8 : !dfcir.stream>, %5 : !dfcir.stream>) : !dfcir.stream> + %8 = dfcir.mul[?] (%7 : !dfcir.stream>, %1 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %9 = dfcir.add[?] (%8 : !dfcir.stream>, %6 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %10 = dfcir.output> ("out22") {operandSegmentSizes = array} dfcir.connect(%10 : !dfcir.stream>, %9 : !dfcir.stream>) - %11 = dfcir.mul(%7 : !dfcir.stream>, %3 : !dfcir.stream>) : !dfcir.stream> - %12 = dfcir.add(%11 : !dfcir.stream>, %6 : !dfcir.stream>) : !dfcir.stream> + %11 = dfcir.mul[?] (%7 : !dfcir.stream>, %2 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %12 = dfcir.add[?] (%11 : !dfcir.stream>, %4 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %13 = dfcir.output> ("out21") {operandSegmentSizes = array} dfcir.connect(%13 : !dfcir.stream>, %12 : !dfcir.stream>) %14 = dfcir.input> ("x12") - %15 = dfcir.mul(%14 : !dfcir.stream>, %0 : !dfcir.stream>) : !dfcir.stream> - %16 = dfcir.mul(%14 : !dfcir.stream>, %1 : !dfcir.stream>) : !dfcir.stream> + %15 = dfcir.mul[?] (%14 : !dfcir.stream>, %5 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %16 = dfcir.mul[?] (%14 : !dfcir.stream>, %0 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %17 = dfcir.input> ("x11") - %18 = dfcir.mul(%17 : !dfcir.stream>, %2 : !dfcir.stream>) : !dfcir.stream> - %19 = dfcir.add(%18 : !dfcir.stream>, %15 : !dfcir.stream>) : !dfcir.stream> + %18 = dfcir.mul[?] (%17 : !dfcir.stream>, %1 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %19 = dfcir.add[?] (%18 : !dfcir.stream>, %15 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %20 = dfcir.output> ("out12") {operandSegmentSizes = array} dfcir.connect(%20 : !dfcir.stream>, %19 : !dfcir.stream>) - %21 = dfcir.mul(%17 : !dfcir.stream>, %3 : !dfcir.stream>) : !dfcir.stream> - %22 = dfcir.add(%21 : !dfcir.stream>, %16 : !dfcir.stream>) : !dfcir.stream> + %21 = dfcir.mul[?] (%17 : !dfcir.stream>, %2 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %22 = dfcir.add[?] (%21 : !dfcir.stream>, %16 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %23 = dfcir.output> ("out11") {operandSegmentSizes = array} dfcir.connect(%23 : !dfcir.stream>, %22 : !dfcir.stream>) } diff --git a/test/data/movingsum.mlir b/test/data/movingsum.mlir index 83d2afc..2642bc5 100644 --- a/test/data/movingsum.mlir +++ b/test/data/movingsum.mlir @@ -3,8 +3,8 @@ module { %0 = dfcir.input> ("x") %1 = dfcir.offset(%0, 1 : i64) : !dfcir.stream> %2 = dfcir.offset(%0, -1 : i64) : !dfcir.stream> - %3 = dfcir.add(%2 : !dfcir.stream>, %0 : !dfcir.stream>) : !dfcir.stream> - %4 = dfcir.add(%3 : !dfcir.stream>, %1 : !dfcir.stream>) : !dfcir.stream> + %3 = dfcir.add[?] (%2 : !dfcir.stream>, %0 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %4 = dfcir.add[?] (%3 : !dfcir.stream>, %1 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %5 = dfcir.output> ("out") {operandSegmentSizes = array} dfcir.connect(%5 : !dfcir.stream>, %4 : !dfcir.stream>) } diff --git a/test/data/muxmul.mlir b/test/data/muxmul.mlir index 78a6988..0e2500a 100644 --- a/test/data/muxmul.mlir +++ b/test/data/muxmul.mlir @@ -5,8 +5,8 @@ module { %2 = dfcir.input> ("ctrl") %3 = dfcir.mux(%2: !dfcir.stream>, %0, %1) : !dfcir.const> %4 = dfcir.input> ("x") - %5 = dfcir.add(%4 : !dfcir.stream>, %4 : !dfcir.stream>) : !dfcir.stream> - %6 = dfcir.mul(%5 : !dfcir.stream>, %3 : !dfcir.const>) : !dfcir.stream> + %5 = dfcir.add[?] (%4 : !dfcir.stream>, %4 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %6 = dfcir.mul[?] (%5 : !dfcir.stream>, %3 : !dfcir.const>) : !dfcir.stream> {latency = -1 : i32} %7 = dfcir.output> ("out") {operandSegmentSizes = array} dfcir.connect(%7 : !dfcir.stream>, %6 : !dfcir.stream>) } diff --git a/test/data/polynomial2.mlir b/test/data/polynomial2.mlir index 8df2cac..0879707 100644 --- a/test/data/polynomial2.mlir +++ b/test/data/polynomial2.mlir @@ -1,9 +1,9 @@ module { dfcir.kernel "Polynomial2" { %0 = dfcir.input> ("x") - %1 = dfcir.mul(%0 : !dfcir.stream>, %0 : !dfcir.stream>) : !dfcir.stream> - %2 = dfcir.add(%1 : !dfcir.stream>, %0 : !dfcir.stream>) : !dfcir.stream> - %3 = dfcir.add(%2 : !dfcir.stream>, %0 : !dfcir.stream>) : !dfcir.stream> + %1 = dfcir.mul[?] (%0 : !dfcir.stream>, %0 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %2 = dfcir.add[?] (%1 : !dfcir.stream>, %0 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %3 = dfcir.add[?] (%2 : !dfcir.stream>, %0 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %4 = dfcir.output> ("out") {operandSegmentSizes = array} dfcir.connect(%4 : !dfcir.stream>, %3 : !dfcir.stream>) } diff --git a/test/data/scalar3.mlir b/test/data/scalar3.mlir index 1b0e9ea..cd83026 100644 --- a/test/data/scalar3.mlir +++ b/test/data/scalar3.mlir @@ -2,15 +2,15 @@ module { dfcir.kernel "Scalar3" { %0 = dfcir.input> ("y3") %1 = dfcir.input> ("x3") - %2 = dfcir.mul(%1 : !dfcir.stream>, %0 : !dfcir.stream>) : !dfcir.stream> + %2 = dfcir.mul[?] (%1 : !dfcir.stream>, %0 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %3 = dfcir.input> ("y2") %4 = dfcir.input> ("x2") - %5 = dfcir.mul(%4 : !dfcir.stream>, %3 : !dfcir.stream>) : !dfcir.stream> + %5 = dfcir.mul[?] (%4 : !dfcir.stream>, %3 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %6 = dfcir.input> ("y1") %7 = dfcir.input> ("x1") - %8 = dfcir.mul(%7 : !dfcir.stream>, %6 : !dfcir.stream>) : !dfcir.stream> - %9 = dfcir.add(%8 : !dfcir.stream>, %5 : !dfcir.stream>) : !dfcir.stream> - %10 = dfcir.add(%9 : !dfcir.stream>, %2 : !dfcir.stream>) : !dfcir.stream> + %8 = dfcir.mul[?] (%7 : !dfcir.stream>, %6 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %9 = dfcir.add[?] (%8 : !dfcir.stream>, %5 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} + %10 = dfcir.add[?] (%9 : !dfcir.stream>, %2 : !dfcir.stream>) : !dfcir.stream> {latency = -1 : i32} %11 = dfcir.output> ("out") {operandSegmentSizes = array} dfcir.connect(%11 : !dfcir.stream>, %10 : !dfcir.stream>) } diff --git a/test/model/dfcxx/addconst.cpp b/test/model/dfcxx/addconst.cpp index 2996619..6253bc8 100644 --- a/test/model/dfcxx/addconst.cpp +++ b/test/model/dfcxx/addconst.cpp @@ -15,16 +15,22 @@ static const DFOutputPaths nullDevicePath = TEST(DFCxx, AddConstAddInt2Asap) { AddConst kernel; - DFLatencyConfig config = { - {dfcxx::ADD_INT, 2} - }; + DFLatencyConfig config = DFLatencyConfig( + { + {dfcxx::ADD_INT, 2} + }, + {} + ); EXPECT_EQ(kernel.compile(config, nullDevicePath, dfcxx::ASAP), true); } TEST(DFCxx, AddConstAddInt2Linear) { AddConst kernel; - DFLatencyConfig config = { - {dfcxx::ADD_INT, 2} - }; + DFLatencyConfig config = DFLatencyConfig( + { + {dfcxx::ADD_INT, 2} + }, + {} + ); EXPECT_EQ(kernel.compile(config, nullDevicePath, dfcxx::Linear), true); } diff --git a/test/model/dfcxx/idct.cpp b/test/model/dfcxx/idct.cpp index a9c31b1..ec33dc4 100644 --- a/test/model/dfcxx/idct.cpp +++ b/test/model/dfcxx/idct.cpp @@ -15,11 +15,14 @@ static const DFOutputPaths nullDevicePath = TEST(DFCxx, IdctAsap) { IDCT kernel; - DFLatencyConfig config = { - {dfcxx::ADD_INT, 1}, - {dfcxx::SUB_INT, 1}, - {dfcxx::MUL_INT, 3}, - }; + DFLatencyConfig config = DFLatencyConfig( + { + {dfcxx::ADD_INT, 1}, + {dfcxx::SUB_INT, 1}, + {dfcxx::MUL_INT, 3}, + }, + {} + ); EXPECT_EQ(kernel.compile(config, nullDevicePath, dfcxx::ASAP), true); } @@ -27,10 +30,13 @@ TEST(DFCxx, IdctAsap) { // TEST(DFCxx, IdctLinear) { // IDCT kernel; -// DFLatencyConfig config = { -// {dfcxx::ADD_INT, 1}, -// {dfcxx::SUB_INT, 1}, -// {dfcxx::MUL_INT, 3} -// }; +// DFLatencyConfig config = DFLatencyConfig( +// { +// {dfcxx::ADD_INT, 1}, +// {dfcxx::SUB_INT, 1}, +// {dfcxx::MUL_INT, 3}, +// }, +// {} +// ); // EXPECT_EQ(kernel.compile(config, nullDevicePath, dfcxx::Linear), true); // } diff --git a/test/model/dfcxx/matrixmul2.cpp b/test/model/dfcxx/matrixmul2.cpp index d2990ea..fef11a3 100644 --- a/test/model/dfcxx/matrixmul2.cpp +++ b/test/model/dfcxx/matrixmul2.cpp @@ -15,18 +15,24 @@ static const DFOutputPaths nullDevicePath = TEST(DFCxx, MatrixMul2AddInt2MulInt3Asap) { MatrixMul2 kernel; - DFLatencyConfig config = { - {dfcxx::ADD_INT, 2}, - {dfcxx::MUL_INT, 3}, - }; + DFLatencyConfig config = DFLatencyConfig( + { + {dfcxx::ADD_INT, 2}, + {dfcxx::MUL_INT, 3}, + }, + {} + ); EXPECT_EQ(kernel.compile(config, nullDevicePath, dfcxx::ASAP), true); } TEST(DFCxx, MatrixMul2AddInt2MulInt3Linear) { MatrixMul2 kernel; - DFLatencyConfig config = { - {dfcxx::ADD_INT, 2}, - {dfcxx::MUL_INT, 2}, - }; + DFLatencyConfig config = DFLatencyConfig( + { + {dfcxx::ADD_INT, 2}, + {dfcxx::MUL_INT, 3}, + }, + {} + ); EXPECT_EQ(kernel.compile(config, nullDevicePath, dfcxx::Linear), true); } diff --git a/test/model/dfcxx/movingsum.cpp b/test/model/dfcxx/movingsum.cpp index c459eef..55f5a45 100644 --- a/test/model/dfcxx/movingsum.cpp +++ b/test/model/dfcxx/movingsum.cpp @@ -15,32 +15,44 @@ static const DFOutputPaths nullDevicePath = TEST(DFCxx, MovingSumAddInt2Asap) { MovingSum kernel; - DFLatencyConfig config = { - {dfcxx::ADD_INT, 2} - }; + DFLatencyConfig config = DFLatencyConfig( + { + {dfcxx::ADD_INT, 2}, + }, + {} + ); EXPECT_EQ(kernel.compile(config, nullDevicePath, dfcxx::ASAP), true); } TEST(DFCxx, MovingSumAddInt2Linear) { MovingSum kernel; - DFLatencyConfig config = { - {dfcxx::ADD_INT, 2} - }; + DFLatencyConfig config = DFLatencyConfig( + { + {dfcxx::ADD_INT, 2}, + }, + {} + ); EXPECT_EQ(kernel.compile(config, nullDevicePath, dfcxx::Linear), true); } TEST(DFCxx, MovingSumAddInt8Asap) { MovingSum kernel; - DFLatencyConfig config = { - {dfcxx::ADD_INT, 8} - }; + DFLatencyConfig config = DFLatencyConfig( + { + {dfcxx::ADD_INT, 8}, + }, + {} + ); EXPECT_EQ(kernel.compile(config, nullDevicePath, dfcxx::ASAP), true); } TEST(DFCxx, MovingSumAddInt8Linear) { MovingSum kernel; - DFLatencyConfig config = { - {dfcxx::ADD_INT, 8} - }; + DFLatencyConfig config = DFLatencyConfig( + { + {dfcxx::ADD_INT, 8}, + }, + {} + ); EXPECT_EQ(kernel.compile(config, nullDevicePath, dfcxx::Linear), true); } diff --git a/test/model/dfcxx/muxmul.cpp b/test/model/dfcxx/muxmul.cpp index ebb1747..3bc51e4 100644 --- a/test/model/dfcxx/muxmul.cpp +++ b/test/model/dfcxx/muxmul.cpp @@ -15,18 +15,24 @@ static const DFOutputPaths nullDevicePath = TEST(DFCxx, MuxMulAddInt2MulInt3Asap) { MuxMul kernel; - DFLatencyConfig config = { - {dfcxx::ADD_INT, 2}, - {dfcxx::MUL_INT, 3} - }; + DFLatencyConfig config = DFLatencyConfig( + { + {dfcxx::ADD_INT, 2}, + {dfcxx::MUL_INT, 3} + }, + {} + ); EXPECT_EQ(kernel.compile(config, nullDevicePath, dfcxx::ASAP), true); } TEST(DFCxx, MuxMulAddInt2MulInt3Linear) { MuxMul kernel; - DFLatencyConfig config = { - {dfcxx::ADD_INT, 2}, - {dfcxx::MUL_INT, 3} - }; + DFLatencyConfig config = DFLatencyConfig( + { + {dfcxx::ADD_INT, 2}, + {dfcxx::MUL_INT, 3} + }, + {} + ); EXPECT_EQ(kernel.compile(config, nullDevicePath, dfcxx::Linear), true); } diff --git a/test/model/dfcxx/output_formats.cpp b/test/model/dfcxx/output_formats.cpp index 337af74..bf16754 100644 --- a/test/model/dfcxx/output_formats.cpp +++ b/test/model/dfcxx/output_formats.cpp @@ -13,7 +13,7 @@ static const Polynomial2 kernel; static const DFLatencyConfig config = - {{dfcxx::ADD_INT, 2}, {dfcxx::MUL_INT, 3}}; + DFLatencyConfig({{dfcxx::ADD_INT, 2}, {dfcxx::MUL_INT, 3}}, {}); TEST(DFCxxOutputFormats, SystemVerilog) { Polynomial2 kernel; @@ -31,10 +31,10 @@ TEST(DFCxxOutputFormats, SystemVerilogLibrary) { EXPECT_EQ(kernel.compile(config, paths, dfcxx::ASAP), true); } -TEST(DFCxxOutputFormats, DFCIR) { +TEST(DFCxxOutputFormats, UnscheduledDFCIR) { Polynomial2 kernel; DFOutputPaths paths = { - {dfcxx::OutputFormatID::DFCIR, NULLDEVICE} + {dfcxx::OutputFormatID::UnscheduledDFCIR, NULLDEVICE} }; EXPECT_EQ(kernel.compile(config, paths, dfcxx::ASAP), true); } @@ -60,7 +60,8 @@ TEST(DFCxxOutputFormats, All) { DFOutputPaths paths = { {dfcxx::OutputFormatID::SystemVerilog, NULLDEVICE}, {dfcxx::OutputFormatID::SVLibrary, NULLDEVICE}, - {dfcxx::OutputFormatID::DFCIR, NULLDEVICE}, + {dfcxx::OutputFormatID::UnscheduledDFCIR, NULLDEVICE}, + {dfcxx::OutputFormatID::ScheduledDFCIR, NULLDEVICE}, {dfcxx::OutputFormatID::FIRRTL, NULLDEVICE}, {dfcxx::OutputFormatID::DOT, NULLDEVICE} }; diff --git a/test/model/dfcxx/polynomial2.cpp b/test/model/dfcxx/polynomial2.cpp index a9aa950..2374acd 100644 --- a/test/model/dfcxx/polynomial2.cpp +++ b/test/model/dfcxx/polynomial2.cpp @@ -15,36 +15,48 @@ static const DFOutputPaths nullDevicePath = TEST(DFCxx, Polynomial2AddInt2MulInt3Asap) { Polynomial2 kernel; - DFLatencyConfig config = { - {dfcxx::ADD_INT, 2}, - {dfcxx::MUL_INT, 3} - }; + DFLatencyConfig config = DFLatencyConfig( + { + {dfcxx::ADD_INT, 2}, + {dfcxx::MUL_INT, 3} + }, + {} + ); EXPECT_EQ(kernel.compile(config, nullDevicePath, dfcxx::ASAP), true); } TEST(DFCxx, Polynomial2AddInt2MulInt3Linear) { Polynomial2 kernel; - DFLatencyConfig config = { - {dfcxx::ADD_INT, 2}, - {dfcxx::MUL_INT, 3} - }; + DFLatencyConfig config = DFLatencyConfig( + { + {dfcxx::ADD_INT, 2}, + {dfcxx::MUL_INT, 3} + }, + {} + ); EXPECT_EQ(kernel.compile(config, nullDevicePath, dfcxx::Linear), true); } TEST(DFCxx, Polynomial2AddInt8MulInt15Asap) { Polynomial2 kernel; - DFLatencyConfig config = { - {dfcxx::ADD_INT, 8}, - {dfcxx::MUL_INT, 15} - }; + DFLatencyConfig config = DFLatencyConfig( + { + {dfcxx::ADD_INT, 8}, + {dfcxx::MUL_INT, 15} + }, + {} + ); EXPECT_EQ(kernel.compile(config, nullDevicePath, dfcxx::ASAP), true); } TEST(DFCxx, Polynomial2AddInt8MulInt15Linear) { Polynomial2 kernel; - DFLatencyConfig config = { - {dfcxx::ADD_INT, 8}, - {dfcxx::MUL_INT, 15} - }; + DFLatencyConfig config = DFLatencyConfig( + { + {dfcxx::ADD_INT, 8}, + {dfcxx::MUL_INT, 15} + }, + {} + ); EXPECT_EQ(kernel.compile(config, nullDevicePath, dfcxx::Linear), true); } diff --git a/test/model/dfcxx/scalar3.cpp b/test/model/dfcxx/scalar3.cpp index 4dbffe7..49befea 100644 --- a/test/model/dfcxx/scalar3.cpp +++ b/test/model/dfcxx/scalar3.cpp @@ -15,18 +15,24 @@ static const DFOutputPaths nullDevicePath = TEST(DFCxx, Scalar3AddInt2MulInt3Asap) { Scalar3 kernel; - DFLatencyConfig config = { - {dfcxx::ADD_INT, 2}, - {dfcxx::MUL_INT, 3} - }; + DFLatencyConfig config = DFLatencyConfig( + { + {dfcxx::ADD_INT, 2}, + {dfcxx::MUL_INT, 3} + }, + {} + ); EXPECT_EQ(kernel.compile(config, nullDevicePath, dfcxx::ASAP), true); } TEST(DFCxx, Scalar3AddInt2MulInt3Linear) { Scalar3 kernel; - DFLatencyConfig config = { - {dfcxx::ADD_INT, 2}, - {dfcxx::MUL_INT, 3} - }; + DFLatencyConfig config = DFLatencyConfig( + { + {dfcxx::ADD_INT, 2}, + {dfcxx::MUL_INT, 3} + }, + {} + ); EXPECT_EQ(kernel.compile(config, nullDevicePath, dfcxx::Linear), true); } From 8b84524e71f30cd559b566fdd1e9f1354c4f696e Mon Sep 17 00:00:00 2001 From: Muxianesty Date: Mon, 13 Jan 2025 15:31:55 +0300 Subject: [PATCH 10/11] CI: ubuntu-latest --> ubuntu-20.04 . --- .github/workflows/main.yml | 2 +- .github/workflows/synth-sv.yml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index b7db923..55878a7 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -23,7 +23,7 @@ jobs: strategy: matrix: compiler: [g++, clang++] - runs-on: ubuntu-latest + runs-on: ubuntu-20.04 steps: - name: Check out repository code uses: actions/checkout@v4 diff --git a/.github/workflows/synth-sv.yml b/.github/workflows/synth-sv.yml index 55df4da..c391fc5 100644 --- a/.github/workflows/synth-sv.yml +++ b/.github/workflows/synth-sv.yml @@ -50,7 +50,7 @@ jobs: - kernel: scalar3 config: add_int_2_mul_int_3 - runs-on: ubuntu-latest + runs-on: ubuntu-20.04 env: MODULE_OUTPUT_PATH: "output.sv" LIBRARY_OUTPUT_PATH: "lib.sv" From f1038ef0047d5e7f22e21c44e1b72b3ed4f3c88c Mon Sep 17 00:00:00 2001 From: Muxianesty Date: Fri, 17 Jan 2025 19:50:21 +0300 Subject: [PATCH 11/11] DFCIROperations.td, DFCIRPassesUtils: indent and codestyle fixes. --- .../dfcir/include/dfcir/DFCIROperations.td | 36 ++++++------ .../dfcir/conversions/DFCIRPassesUtils.h | 2 + .../dfcir/conversions/ModuleDefines.inc | 2 +- .../dfcir/conversions/DFCIRPassesUtils.cpp | 55 +++++++++++++++++-- 4 files changed, 71 insertions(+), 24 deletions(-) diff --git a/src/model/dfcir/include/dfcir/DFCIROperations.td b/src/model/dfcir/include/dfcir/DFCIROperations.td index 48a51b8..f260d34 100644 --- a/src/model/dfcir/include/dfcir/DFCIROperations.td +++ b/src/model/dfcir/include/dfcir/DFCIROperations.td @@ -197,12 +197,13 @@ class DFCIR_UnaryOp A == B. - if (bool(noQuestion) == bool(noAttr)) { - return parser.emitError(latencyLoc) << "'" << result.name.getStringRef() << - "' op requires either '?' or valid latency specified"; - } + if (bool(noQuestion) == bool(noAttr)) { + auto newErr = parser.emitError(latencyLoc); + return newErr << "'" << result.name.getStringRef() + << "' op requires either '?' or valid latency specified"; + } } else { latencyAttr = IntegerAttr::get(IntegerType::get(parser.getContext(), 32), -1); @@ -219,10 +220,10 @@ class DFCIR_UnaryOp A == B. - if (bool(noQuestion) == bool(noAttr)) { - return parser.emitError(latencyLoc) << "'" << result.name.getStringRef() << - "' op requires either '?' or valid latency specified"; - } + if (bool(noQuestion) == bool(noAttr)) { + auto newErr = parser.emitError(latencyLoc); + return newErr << "'" << result.name.getStringRef() + << "' op requires either '?' or valid latency specified"; + } } else { latencyAttr = IntegerAttr::get(IntegerType::get(parser.getContext(), 32), -1); @@ -335,11 +337,11 @@ class DFCIR_BinaryOp namespace mlir::dfcir::utils { @@ -97,9 +97,15 @@ void Graph::applyConfig(const LatencyConfig &cfg) { auto found = cfg.internalOps.find(opType); - int32_t latency = (found != cfg.internalOps.end()) ? - (*found).second : - 1; + int32_t latency; + if (found != cfg.internalOps.end()) { + latency = (*found).second; + } else { + std::cout << "No explicit config for operation type " + << opTypeToString(opType) + << " - latency 1 will be used" << std::endl; + latency = 1; + } casted.setLatency(latency); @@ -206,7 +212,6 @@ Graph::Graph(KernelOp kernel) : Graph() { Graph::Graph(ModuleOp module) : Graph(mlir::utils::findFirstOccurence(module)) {} - void insertBuffer(OpBuilder &builder, Channel *channel, int32_t latency) { builder.setInsertionPoint(channel->target->op); @@ -278,8 +283,46 @@ Ops resolveInternalOpType(mlir::Operation *op) { return (isFloat) ? Ops::NEQ_FLOAT : Ops::NEQ_INT; } - assert(false && "Shouldn't reach this"); + std::cout << "Couldn't find deduce the type for the operation below."; + std::cout << "Latency 0 will be used." << std::endl; + op->dump(); return Ops::UNDEFINED; } +std::string opTypeToString(const Ops &opType) { + switch (opType) { + case ADD_INT: return "ADD_INT"; + case ADD_FLOAT: return "ADD_FLOAT"; + case SUB_INT: return "SUB_INT"; + case SUB_FLOAT: return "SUB_FLOAT"; + case MUL_INT: return "MUL_INT"; + case MUL_FLOAT: return "MUL_FLOAT"; + case DIV_INT: return "DIV_INT"; + case DIV_FLOAT: return "DIV_FLOAT"; + case NEG_INT: return "NEG_INT"; + case NEG_FLOAT: return "NEG_FLOAT"; + case AND_INT: return "AND_INT"; + case AND_FLOAT: return "AND_FLOAT"; + case OR_INT: return "OR_INT"; + case OR_FLOAT: return "OR_FLOAT"; + case XOR_INT: return "XOR_INT"; + case XOR_FLOAT: return "XOR_FLOAT"; + case NOT_INT: return "NOT_INT"; + case NOT_FLOAT: return "NOT_FLOAT"; + case LESS_INT: return "LESS_INT"; + case LESS_FLOAT: return "LESS_FLOAT"; + case LESSEQ_INT: return "LESSEQ_INT"; + case LESSEQ_FLOAT: return "LESSEQ_FLOAT"; + case GREATER_INT: return "GREATER_INT"; + case GREATER_FLOAT: return "GREATER_FLOAT"; + case GREATEREQ_INT: return "GREATEREQ_INT"; + case GREATEREQ_FLOAT: return "GREATEREQ_FLOAT"; + case EQ_INT: return "EQ_INT"; + case EQ_FLOAT: return "EQ_FLOAT"; + case NEQ_INT: return "NEQ_INT"; + case NEQ_FLOAT: return "NEQ_FLOAT"; + default: return ""; + } +} + } // namespace mlir::dfcir::utils \ No newline at end of file