Add Connex vector processor back end

[alexsusu]

Summary

Connex is an established, almost 30-year old, very wide research vector processor (see, for example, http://users.dcae.pub.ro/~gstefan/2ndLevel/connex.html) with a number of lanes between 32 and 4096, easily changeable at synthesis time.
A very interesting feature is that the Connex processor has a local banked vector memory (each lane has its own local memory), which achieves 1 cycle latency with direct and indirect loads and stores - this implies that the memory bandwidth is very big.

The Connex vector processor has 16-bit signed integer Execution Units in each lane. It is emulating efficiently (via inlining the emulation subroutines in the instruction selection pass) 32-bit int and IEEE 754-2008 compliant 16-bit floating point (Clang type _Float16, C for ARM __fp16, LLVM IR half type). The emulation subroutines are in the lib/Target/Connex/Select_*_OpincaaCodeGen.h files, which are to be included in the ConnexISelDAGToDAG.cpp module, in the ConnexDAGToDAGISel::Select() method. These emulation subroutines can be easily adjusted using for example to increase performance by sacrificing accuracy of f16 - drop me an email to ask how can you do it. (They currently total almost 1 MB of C++ code.)
The Connex vector processor does not currently support the float, double, nor the 64-bit integer types.

The back end targets more exactly the Connex processor, used as an accelerator, a variant of the Connex processor, which is low-power. The working compiler is described at https://sites.google.com/site/alexsusu/myfilecabinet/OpincaaLLVM_TR_UPB.pdf .

Note that currently our back end targets only our Connex Opincaa assembler (very easy to learn and use) available at https://gitlab.dcae.pub.ro/research/ConnexRelated/opincaa/ .
The Connex Opincaa assembler allows to run arbitrary Connex vector-length, host (CPU) agnostic code.

The ISA of the Connex vector processor is available at https://gitlab.dcae.pub.ro/research/ConnexRelated/opincaa/blob/master/ConnexISA.pdf .
The Connex vector processor has also an open source C++ simulator available also at https://gitlab.dcae.pub.ro/research/ConnexRelated/opincaa/ .

The mailing list for the Connex processor and tools is: https://groups.google.com/forum/#!forum/connex-tools .

An interesting feature is that, in order to support recovering from from the Instruction selection pass' SelectionDAG back to the original source (C) code we require adding a simple data structure in include/llvm/CodeGen/SelectionDAG.h (and helper methods in related files) that maps an SDValue to the LLVM IR Value object it was used to translate from:
   DenseMap<const Value*, SDValue> *crtNodeMapPtr

The Connex back end is 3 years old. We published 1 academic paper on it at a CGO workshop: https://dl.acm.org/citation.cfm?id=3306166 . However, we are still adding features to the back end.

Small note: the Connex backend is rather small, it builds fast (in ~3-5 mins, single-threaded on a decent machine; in Apr 2019 the built objects have a total 71,168K, while the smallest LLVM backend, MSP430, has 63,387K and the biggest ones are X86 with 359,736K, and AMDGPU with 488,309K).

An important thing is that I think the test/MC/Connex folder should not be populated for this patch, because the Connex back end is able to generate only an assembly code that is required to be used by the special Opincaa assembler, which is not integrated in LLVM. I've seen other back ends doing a similar thing such as the NVPTX back end, which doesn't support object file generation. The Connex back end also doesn't support object file generation.
The eBPF+ConnexS processor has the same ABI as the eBPF processor it extends, except that Connex-S supports natively only 16-bit integers and it is able to access the banked vector memory only by line (so Connex-S can't perform unaligned accesses).

The Connex processor is currently implemented in FPGA, but was also implemented in silicon also:
    - an older version for HDTV: Gheorghe M. Stefan, "The CA1024: A Massively Parallel Processor for Cost-Effective HDTV", 2006 (http://users.dcae.pub.ro/~gstefan/2ndLevel/images/connex_v4.ppt)
    - M. Malita and Gheorghe M. Stefan, "Map-scan Node Accelerator for Big-data"
    - Gheorghe M. Stefan and Mihaela Malita, "Can One-Chip Parallel Computing Be Liberated From Ad Hoc Solutions? A Computation Model Based Approach and Its Implementation"

[alexsusu]

Added 2 more files. I still have to add another about 50 files.

[alexsusu]

A few corrections to ConnexInstrInfoVec.td .

[alexsusu]

More refactoring on the .td TableGen files. Added also more source files.

[alexsusu]

Added all source files for the Connex back end.
Followed coding standards from https://llvm.org/docs/CodingStandards.html .

[alexsusu]

Added myself as maintainer of the Connex backend in CODE_OWNERS.TXT.

[asb]

Some initial feedback:

• This patch is pretty huge which makes it pretty hard to meaningfully review
• There seem to be effectively no tests. I'd expect test/CodeGen/Connex and test/MC/Connex to be reasonably well populated
• Plenty of code commented out or with date-based comments that don't match our style, e.g. // 2018_*
• Files have the old license header rather than the new one

[alexsusu]

Made a first round of corrections following Alex Bradbury's review.

[alexsusu]

In D60052#1471560, @asb wrote:

Some initial feedback:

• This patch is pretty huge which makes it pretty hard to meaningfully review
• There seem to be effectively no tests. I'd expect test/CodeGen/Connex and test/MC/Connex to be reasonably well populated
• Plenty of code commented out or with date-based comments that don't match our style, e.g. // 2018_*
• Files have the old license header rather than the new one

Hi, Alex.

I addressed a few of your concerns and I'm working on the others.

An important thing is that I think test/MC/Connex should not be populated for this patch, because the Connex back end is able to generate only an assembly code that is required to be used by the special Opincaa assembler, which is not integrated in LLVM. I've seen other back ends doing a similar thing such as the NVPTX back end, which doesn't support object file generation. The Connex back end also doesn't support object file generation.

Thank you,
  Alex Susu

[alexsusu]

Added all required files for the back end (a few were missing).

[efriedma]

Just quickly reviewing the target-independent changes.

In general, commented-out code should be cleaned up.

Could you explain the need for crtNodeMapPtr a bit more? In general, IR instructions should be lowered to SelectionDAG nodes in a way that doesn't require referring back to the original Instruction afterwards.

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

9092–9093

If you have operations with multiple results you need to custom-legalize, your backend should just override LowerOperationWrapper.

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h

41

Stray include?

[arsenm]

There's a lot of clutter that makes this hard to review. All of the extra debug, special ifdef blocks, and commented out code should be removed.

This should also be split into smaller patches. For example, the triple patches, then adding the basic target machine definition, and then MC parts before moving on to codegen and optimizations

include/llvm/ADT/Triple.h

56

The triple patches are usually committed as a first, separate patch

include/llvm/CodeGen/SelectionDAG.h

273–277

This probably should be dropped

1226–1231

This should be a separate patch (or you could just use the ArrayRef version)

lib/Target/Connex/ConnexAsmPrinter.cpp

52 ↗

(On Diff #196163)

This should be after all includes

53–58 ↗

(On Diff #196163)

Sort includes

60–63 ↗

(On Diff #196163)

You should not need this, also no global

164 ↗

(On Diff #196163)

isInlineAsm() (also for others)

225–226 ↗

(On Diff #196163)

A large number of the debug statements seem like they're just noise for committing

234 ↗

(On Diff #196163)

No c string functions

957 ↗

(On Diff #196163)

You shouldn't be looking at the .data() on a StringRef as if it were a c string like this should just use the StringRef directly.

lib/Target/Connex/ConnexAsmPrinterLoopNests.h

1–2 ↗

(On Diff #196163)

I don't really understand anything that's going on in this file. You shouldn't have file IO, or globals

lib/Target/Connex/ConnexConfig.h

4

These macros mostly seem like a waste of effort

lib/Target/Connex/ConnexHazardRecognizers.cpp

304 ↗

(On Diff #196163)

Fewer TODOs

308 ↗

(On Diff #196163)

No random special ifdef blocks

lib/Target/Connex/ConnexInstrInfo.h

52 ↗

(On Diff #196163)

No macro for this

lib/Target/Connex/ConnexSelectionDAGInfo.cpp

113 ↗

(On Diff #196163)

static const

175 ↗

(On Diff #196163)

static const

201 ↗

(On Diff #196163)

More junk macros

lib/Target/Connex/ConnexTargetMachine.cpp

898 ↗

(On Diff #196163)

This needs to be broken down into smaller functions

lib/Target/Connex/ConnexTargetTransformInfo.h

117 ↗

(On Diff #196163)

Noisy debug

lib/Target/Connex/RecoverFromLlvmIR.h

1–2 ↗

(On Diff #196163)

I don't know what this file is trying to accomplish, but it is a separate patch from the backend

lib/Target/Connex/Select_ADDi32_OpincaaCodeGen.h

9–18 ↗

(On Diff #196163)

There shouldn't be any generated code. Generated selection should come from table gen, with some manual code in *ISelDAGToDAG

lib/Target/Connex/TargetInfo/Makefile

1 ↗

(On Diff #196163)

I thought Makefiles were all gone?

[alexsusu]

This comment was removed by alexsusu.

[luismarques]

CMakeLists.txt

324

New targets are generally considered experimental and not added to the default build list. You would generally build them by adding them to the cmake definition LLVM_EXPERIMENTAL_TARGETS_TO_BUILD.

[alexsusu]

Addressed most reviews of efriedma, arsenm, luismarques (and of asb).

[alexsusu]

Added relevant tests in test/CodeGen/Connex.

[arsenm]

This still needs a lot of work before it will be in a committable state. All of the parts touching generic code need to be reviewed and committed separately at an absolute minimum. The backend also could use some breaking up.

In particular the Value*/SDNode map doesn't in general make sense. What is it used for? It's certainly not the correct solution to whatever problem you're solving with it.

include/llvm/Analysis/ScalarEvolutionExpander.h

264–272 ↗

(On Diff #198358)

SCEV changes need to be split to separate patches

include/llvm/CodeGen/SelectionDAG.h

273–277

This still needs to be dropped

lib/CodeGen/LiveRangeCalc.cpp

25–38 ↗

(On Diff #198358)

This needs to be removed

lib/CodeGen/RegAllocGreedy.cpp

1223–1224 ↗

(On Diff #198358)

Needs to be removed

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

1472–1473

Needs to be removed

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

85

Ditto

lib/Target/Connex/ConnexAsmPrinter.cpp

79–86 ↗

(On Diff #198358)

These various places linking to other documentation should be removed. Doxygen generates the appropriate links

104–117 ↗

(On Diff #198358)

Remove commented out code

780–782 ↗

(On Diff #198358)

More macros to remove

lib/Target/Connex/Select_SUBi32_OpincaaCodeGen.h

1–6 ↗

(On Diff #198358)

This file needs to be dropped. There should be no committed, generated code. You should have table gen emit this, or manually write the code in ISelDAGToDAG

[arsenm]

Feel free to re-add me on a new revision

CMakeLists.txt

 set(LLVM_INCLUDE_DIR ${CMAKE_CURRENT_BINARY_DIR}/include)
 
 # List of all targets to be built by default:
 set(LLVM_ALL_TARGETS
   AArch64
   AMDGPU
   ARM
   BPF
+  Connex
   Hexagon
   Lanai
   Mips
   MSP430
   NVPTX
   PowerPC
   Sparc
   SystemZ

include/llvm/ADT/Triple.h

enum ArchType {
     arm,            // ARM (little endian): arm, armv.*, xscale
     armeb,          // ARM (big endian): armeb
     aarch64,        // AArch64 (little endian): aarch64
     aarch64_be,     // AArch64 (big endian): aarch64_be
     arc,            // ARC: Synopsys ARC
     avr,            // AVR: Atmel AVR microcontroller
     bpfel,          // eBPF or extended BPF or 64-bit BPF (little endian)
     bpfeb,          // eBPF or extended BPF or 64-bit BPF (big endian)
+    connex,         // Connex vector processor
     hexagon,        // Hexagon: hexagon
     mips,           // MIPS: mips, mipsallegrex, mipsr6
     mipsel,         // MIPSEL: mipsel, mipsallegrexe, mipsr6el
     mips64,         // MIPS64: mips64, mips64r6, mipsn32, mipsn32r6
     mips64el,       // MIPS64EL: mips64el, mips64r6el, mipsn32el, mipsn32r6el
     msp430,         // MSP430: msp430
     ppc,            // PPC: powerpc
     ppc64,          // PPC64: powerpc64, ppu

include/llvm/CodeGen/SelectionDAG.h

class SelectionDAG {
   BumpPtrAllocator Allocator;
 
   /// Tracks dbg_value and dbg_label information through SDISel.
   SDDbgInfo *DbgInfo;
 
   uint16_t NextPersistentId = 0;
 
 public:
+  DenseMap<const Value*, SDValue> *crtNodeMapPtr;
+
+  void SetNodeMap(DenseMap<const Value *, SDValue> *aCrtNodeMapPtr);
+
+  void UpdateNodeMapSDValue(SDNode *oldSDN, SDValue &newSDV);
+
   /// Clients of various APIs that cause global effects on
   /// the DAG can optionally implement this interface.  This allows the clients
   /// to handle the various sorts of updates that happen.
   ///
   /// A DAGUpdateListener automatically registers itself with DAG when it is
   /// constructed, and removes itself when destroyed in RAII fashion.
   struct DAGUpdateListener {
     DAGUpdateListener *const Next;
#endif
   MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT);
   MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT,
                                 SDValue Op1);
   MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT,
                                 SDValue Op1, SDValue Op2);
   MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT,
                                 SDValue Op1, SDValue Op2, SDValue Op3);
   MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT,
+                                SDValue Op1, SDValue Op2,
+                                SDValue Op3, SDValue Op4);
+  MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
+                                EVT VT2, SDValue Op1, SDValue Op2,
+                                SDValue Op3, SDValue Op4);
+  MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT,
                                 ArrayRef<SDValue> Ops);
   MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
                                 EVT VT2, SDValue Op1, SDValue Op2);
   MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
                                 EVT VT2, SDValue Op1, SDValue Op2, SDValue Op3);
   MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
                                 EVT VT2, ArrayRef<SDValue> Ops);
   MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,

include/llvm/CodeGen/SelectionDAGISel.h

public:
   SelectionDAGBuilder *SDB;
   AliasAnalysis *AA;
   GCFunctionInfo *GFI;
   CodeGenOpt::Level OptLevel;
   const TargetInstrInfo *TII;
   const TargetLowering *TLI;
   bool FastISelFailed;
   SmallPtrSet<const Instruction *, 4> ElidedArgCopyInstrs;
+  DenseMap<const Value*, SDValue> crtNodeMap;
 
   /// Current optimization remark emitter.
   /// Used to report things like combines and FastISel failures.
   std::unique_ptr<OptimizationRemarkEmitter> ORE;
 
   static char ID;
 
   explicit SelectionDAGISel(TargetMachine &tm,

include/llvm/IR/Intrinsics.td

 include "llvm/IR/IntrinsicsARM.td"
 include "llvm/IR/IntrinsicsAArch64.td"
 include "llvm/IR/IntrinsicsXCore.td"
 include "llvm/IR/IntrinsicsHexagon.td"
 include "llvm/IR/IntrinsicsNVVM.td"
 include "llvm/IR/IntrinsicsMips.td"
 include "llvm/IR/IntrinsicsAMDGPU.td"
 include "llvm/IR/IntrinsicsBPF.td"
+include "llvm/IR/IntrinsicsConnex.td"
 include "llvm/IR/IntrinsicsSystemZ.td"
 include "llvm/IR/IntrinsicsWebAssembly.td"
 include "llvm/IR/IntrinsicsRISCV.td"

include/llvm/IR/IntrinsicsConnex.td

+//===- IntrinsicsConnex.td - Defines Connex-S intrinsics ---*- tablegen -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines all of the Connex-specific intrinsics.
+//
+//===----------------------------------------------------------------------===//
+
+// All Connex-S vector processor intrinsics start with "llvm.connex."
+//
+let TargetPrefix = "connex" in {
+
+  /*
+   * Note: all intrinsics defined in these .td files start with
+   *   the int_ prefix (from intrinsic). For this file they start with
+   *   int_connex prefix - otherwise we get the following TableGen error
+   *   <<error:Intrinsic 'int_end_repeat' does not start with 'llvm.connex.'!>>
+   *
+   * The LLVM IR intrinsics extend the LLVM language s.t. we can use
+   *   these instructions in an LLVM IR program. We also need to define the
+   *   corresponding assembly instructions in the back end TableGen files.
+   */
+
+  /* Alex: following Intrinsics.td:
+    class Intrinsic<list<LLVMType> ret_types,
+                list<LLVMType> param_types = [],
+                list<IntrinsicProperty> properties = [],
+                string name = "">
+  */
+
+
+  /* Small-note:
+       llvm_i64_ty makes simpler my LLVM IR generation in the LoopVectorize.cpp
+      module:
+       def int_connex_repeat_x_times : Intrinsic<[], [llvm_i64_ty], []>;
+     But llvm_i32_ty is in accordance to the original i32 type of n.vec in the
+      LoopVectorize.cpp module:
+        def int_connex_repeat_x_times : Intrinsic<[], [llvm_i32_ty], []>;
+
+     Small-note: We get inspired from include/llvm/IR/IntrinsicsPowerPC.td:
+      // Intrinsics used to generate ctrl-based loops.
+      def int_ppc_mtctr : Intrinsic<[], [llvm_anyint_ty], []>;
+
+     Small-note: Trying to use a polymorphic definition, which requires
+       specifying the actual type in Function::Create(FunctionType::get(), ...)
+       is:
+         def int_connex_repeat_x_times : Intrinsic<[], [llvm_anyint_ty], []>;
+       When instantiating it in LoopVectorize.cpp like this:
+         Value *instrinsicFunc = Intrinsic::getDeclaration(M,
+                                            Intrinsic::connex_repeat_x_times);
+        it gives error at runtime:
+          llvm::ArrayRef<T>::operator[](size_t) const [with T = llvm::Type*;
+             size_t = long unsigned int]: Assertion `Index < Length &&
+              "Invalid index!"' failed.
+  */
+  def int_connex_repeat_x_times : Intrinsic<[], [llvm_i64_ty], []>;
+  def int_connex_end_repeat : Intrinsic<[], [], []>;
+
+  /* Note: Possibly useful in the future.
+     Connex Opincaa's END_REPEAT does not have a relative offset,
+       as the standard Connex assembly ijmpnzdec instruction,
+       since it falls on Opincaa to compute the jump back relative offset.
+      We can also use a setlc to position it outside the loop created by the
+       ijmpnzdec instruction by using it inside a delay-slot instruction.
+
+      def int_connex_setlc : Intrinsic<[], [llvm_i16_ty], []>;
+      def int_connex_ijmpnzdec : Intrinsic<[], [], []>;
+  */
+
+
+
+  /* IMPORTANT: REDUCE cannot return a value. It is the duty of the host (CPU)
+      to read the result itself from the REDUCE issued by Connex-S.
+   Therefore this definition is incorrect:
+      def int_connex_reduce : Intrinsic<[llvm_i32_ty], [llvm_v128i16_ty], []>;
+  */
+  /* GOOD:
+      def int_connex_reduce : Intrinsic<[], [llvm_v128i16_ty], []>;
+      def int_connex_reduce_i32 : Intrinsic<[], [llvm_v64i32_ty], []>;
+      def int_connex_reduce_f16 : Intrinsic<[], [llvm_v128f16_ty], []>;
+  */
+  def int_connex_reduce : Intrinsic<[], [llvm_anyvector_ty], []>;
+
+  /* Note: ctpop is already defined in Intrinsics.td.
+     So the below definition is not required:
+       def int_connex_ctpop : Intrinsic<[llvm_v8i16_ty],
+                                        [llvm_v8i16_ty], []>;
+  */
+
+
+  // Inherited BPF scalar intrinsics: Specialized loads from packet
+  def int_connex_load_byte : GCCBuiltin<"__builtin_connex_load_byte">,
+           Intrinsic<[llvm_i64_ty], [llvm_ptr_ty, llvm_i64_ty], [IntrReadMem]>;
+  def int_connex_load_half : GCCBuiltin<"__builtin_connex_load_half">,
+           Intrinsic<[llvm_i64_ty], [llvm_ptr_ty, llvm_i64_ty], [IntrReadMem]>;
+  def int_connex_load_word : GCCBuiltin<"__builtin_connex_load_word">,
+           Intrinsic<[llvm_i64_ty], [llvm_ptr_ty, llvm_i64_ty], [IntrReadMem]>;
+  def int_connex_pseudo : GCCBuiltin<"__builtin_connex_pseudo">,
+           Intrinsic<[llvm_i64_ty], [llvm_i64_ty, llvm_i64_ty]>;
+}
+

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

if (RV.getNode() == N)
       continue;
 
     assert(N->getOpcode() != ISD::DELETED_NODE &&
            RV.getOpcode() != ISD::DELETED_NODE &&
            "Node was deleted but visit returned new node!");
 
     LLVM_DEBUG(dbgs() << " ... into: "; RV.getNode()->dump(&DAG));
 
+    // Replacing SDNode N with RV in crtNodeMap
+    DAG.UpdateNodeMapSDValue(N, RV);
+
     if (N->getNumValues() == RV.getNode()->getNumValues())
       DAG.ReplaceAllUsesWith(N, RV.getNode());
     else {
       assert(N->getValueType(0) == RV.getValueType() &&
              N->getNumValues() == 1 && "Type mismatch");
       DAG.ReplaceAllUsesWith(N, &RV);
     }
 

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

 
 /// makeVTList - Return an instance of the SDVTList struct initialized with the
 /// specified members.
 static SDVTList makeVTList(const EVT *VTs, unsigned NumVTs) {
   SDVTList Res = {VTs, NumVTs};
   return Res;
 }
 
+void SelectionDAG::SetNodeMap(DenseMap<const Value *, SDValue> *aCrtNodeMapPtr) {
+  crtNodeMapPtr = aCrtNodeMapPtr;
+}
+
+void SelectionDAG::UpdateNodeMapSDValue(SDNode *oldSDN, SDValue &newSDV) {
+  /* NOTE: SelectionDAGBuilder defines DenseMap NodeMap.
+   *   I added in SelectionDAGISel a copy of it, crtNodeMap.
+   *   The pointer crtNodeMapPtr here is the pointer of crtNodeMap
+   *     initialized in SelectionDAGISel::CodeGenAndEmitDAG().
+   */
+  for (auto iterNodeMap = crtNodeMapPtr->begin();
+       iterNodeMap != crtNodeMapPtr->end(); iterNodeMap++) {
+    auto tmp1 = (*iterNodeMap);
+
+    const Value *crtValue = (const Value *)(tmp1.first);
+
+    SDValue crtSDValue = tmp1.second;
+    SDNode *crtSDNode = crtSDValue.getNode();
+
+    if (crtSDNode == oldSDN) {
+      (*crtNodeMapPtr)[crtValue] = newSDV;
+      break;
+    }
+  }
+}
+
+
 // Default null implementations of the callbacks.
 void SelectionDAG::DAGUpdateListener::NodeDeleted(SDNode*, SDNode*) {}
 void SelectionDAG::DAGUpdateListener::NodeUpdated(SDNode*) {}
 
 void SelectionDAG::DAGNodeDeletedListener::anchor() {}
 
 #define DEBUG_TYPE "selectiondag"
 
MachineSDNode *SelectionDAG::getMachineNode(unsigned Opcode, const SDLoc &dl,
                                             SDValue Op1, SDValue Op2,
                                             SDValue Op3) {
   SDVTList VTs = getVTList(VT1, VT2, VT3);
   SDValue Ops[] = { Op1, Op2, Op3 };
   return getMachineNode(Opcode, dl, VTs, Ops);
 }
 
 MachineSDNode *SelectionDAG::getMachineNode(unsigned Opcode, const SDLoc &dl,
+                                            EVT VT,
+                                            SDValue Op1, SDValue Op2,
+                                            SDValue Op3, SDValue Op4) {
+  SDVTList VTs = getVTList(VT);
+  SDValue Ops[] = { Op1, Op2, Op3, Op4 };
+  return getMachineNode(Opcode, dl, VTs, Ops);
+}
+
+MachineSDNode *SelectionDAG::getMachineNode(unsigned Opcode, const SDLoc &dl,
+                                            EVT VT1, EVT VT2,
+                                            SDValue Op1, SDValue Op2,
+                                            SDValue Op3, SDValue Op4) {
+  SDVTList VTs = getVTList(VT1, VT2);
+  SDValue Ops[] = { Op1, Op2, Op3, Op4 };
+  return getMachineNode(Opcode, dl, VTs, Ops);
+}
+
+MachineSDNode *SelectionDAG::getMachineNode(unsigned Opcode, const SDLoc &dl,
                                             EVT VT1, EVT VT2, EVT VT3,
                                             ArrayRef<SDValue> Ops) {
   SDVTList VTs = getVTList(VT1, VT2, VT3);
   return getMachineNode(Opcode, dl, VTs, Ops);
 }
 
 MachineSDNode *SelectionDAG::getMachineNode(unsigned Opcode, const SDLoc &dl,
                                             ArrayRef<EVT> ResultTys,

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h

 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MachineValueType.h"
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <utility>
 #include <vector>
+#include "llvm/Support/Debug.h"
 
 namespace llvm {
 
 class AllocaInst;
 class AtomicCmpXchgInst;
 class AtomicRMWInst;
 class BasicBlock;
 class BranchInst;
class SelectionDAGBuilder {
   /// Helper type for DanglingDebugInfoMap.
   typedef std::vector<DanglingDebugInfo> DanglingDebugInfoVector;
 
   /// Keeps track of dbg_values for which we have not yet seen the referent.
   /// We defer handling these until we do see it.
   MapVector<const Value*, DanglingDebugInfoVector> DanglingDebugInfoMap;
 
 public:
+  // Add a getter for NodeMap
+  DenseMap<const Value*, SDValue> &getNodeMap() {
+      return NodeMap;
+  }
+
   /// Loads are not emitted to the program immediately.  We bunch them up and
   /// then emit token factor nodes when possible.  This allows us to get simple
   /// disambiguation between loads without worrying about alias analysis.
   SmallVector<SDValue, 8> PendingLoads;
 
   /// State used while lowering a statepoint sequence (gc_statepoint,
   /// gc_relocate, and gc_result).  See StatepointLowering.hpp/cpp for details.
   StatepointLoweringState StatepointLowering;

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

#endif
 
   SDValue Res = CLI.DAG.getNode(ISD::MERGE_VALUES, CLI.DL,
                                 CLI.DAG.getVTList(RetTys), ReturnValues);
   return std::make_pair(Res, CLI.Chain);
 }
 
 void TargetLowering::LowerOperationWrapper(SDNode *N,
                                            SmallVectorImpl<SDValue> &Results,
                                            SelectionDAG &DAG) const {
-  if (SDValue Res = LowerOperation(SDValue(N, 0), DAG))
-    Results.push_back(Res);
+  SDValue Res1 = LowerOperation(SDValue(N, 0), DAG);
+  if (Res1.getNode())
+    Results.push_back(Res1);
+
+  if (N->getNumValues() > 1) {
+    SDValue Res2 = LowerOperation(SDValue(N, 1), DAG);
+    if (Res2.getNode())
+      Results.push_back(Res2);
+  }
 }
 
 SDValue TargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const {
   llvm_unreachable("LowerOperation not implemented for this target!");
 }
 
 void
 SelectionDAGBuilder::CopyValueToVirtualRegister(const Value *V, unsigned Reg) {

lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

for (BasicBlock::const_iterator I = Begin; I != End && !SDB->HasTailCall; ++I) {
     if (!ElidedArgCopyInstrs.count(&*I))
       SDB->visit(*I);
   }
 
   // Make sure the root of the DAG is up-to-date.
   CurDAG->setRoot(SDB->getControlRoot());
   HadTailCall = SDB->HasTailCall;
   SDB->resolveOrClearDbgInfo();
+
+  crtNodeMap = SDB->getNodeMap();
+
   SDB->clear();
 
   // Final step, emit the lowered DAG as machine code.
   CodeGenAndEmitDAG();
 }
 
 void SelectionDAGISel::ComputeLiveOutVRegInfo() {
   SmallPtrSet<SDNode*, 16> VisitedNodes;
LLVM_DEBUG(dbgs() << "Initial selection DAG: "
                     << "'\n";
              CurDAG->dump());
 
   if (ViewDAGCombine1 && MatchFilterBB)
     CurDAG->viewGraph("dag-combine1 input for " + BlockName);
 
   // Run the DAG combiner in pre-legalize mode.
   {
+    // We should do this only once
+    CurDAG->SetNodeMap(&crtNodeMap);
+
     NamedRegionTimer T("combine1", "DAG Combining 1", GroupName,
                        GroupDescription, TimePassesIsEnabled);
     CurDAG->Combine(BeforeLegalizeTypes, AA, OptLevel);
   }
 
 #ifndef NDEBUG
   if (TTI.hasBranchDivergence())
     CurDAG->VerifyDAGDiverence();

lib/Target/Connex/Connex.h

+//===-- Connex.h - Top-level interface for Connex representation ------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_TARGET_CONNEX_CONNEX_H
+#define LLVM_LIB_TARGET_CONNEX_CONNEX_H
+
+#include "MCTargetDesc/ConnexMCTargetDesc.h"
+#include "llvm/Target/TargetMachine.h"
+
+
+// We define reserved register(s) of Connex to use for:
+//    - handling COPY instructions in WHERE blocks
+//     (see ConnexTargetMachine.cpp and ConnexISelLowering.cpp), etc
+#define CONNEX_RESERVED_REGISTER_01 Connex::Wh30
+#define CONNEX_RESERVED_REGISTER_02 Connex::Wh31
+#define CONNEX_RESERVED_REGISTER_03 Connex::Wh29
+
+#define COPY_REGISTER_IMPLEMENTED_WITH_ORV_H
+
+namespace llvm {
+class ConnexTargetMachine;
+
+FunctionPass *createConnexISelDag(ConnexTargetMachine &TM);
+}
+
+#endif

lib/Target/Connex/ConnexConfig.h

+#ifndef CONNEX_CONFIG_ALEX
+#define CONNEX_CONFIG_ALEX
+
+// This file is used by... TODO TODO TODO
+
+// These 2 types are defined also in Opincaa lib, in include/Architecture.h
+typedef short TypeElement;
+typedef unsigned short UnsignedTypeElement;
+
+
+#define CONNEX_VECTOR_LENGTH 8
+#define TYPE_SIZEOF 2
+#define CONNEX_LINE_SIZE (CONNEX_VECTOR_LENGTH * TYPE_SIZEOF)
+
+//#define STR_LOOP_SYMBOLIC_INDEX "indexLLVM_LV / CONNEX_VECTOR_LENGTH"
+// NOTE: make sure it is equiavlent to the above commented macro
+// NOTE: keep the paranthesis since >> has low operator priority
+#define STR_LOOP_SYMBOLIC_INDEX "(indexLLVM_LV >> 7)"
+
+// This is the type of the scalar processor (basically the BPF processor) operand
+// TODO_CHANGE_BACKEND:
+#define TYPE_ELEMENT MVT::i64
+//#define TYPE_ELEMENT MVT::i32
+
+//#define TYPE_VECTOR MVT::v8i64
+//#define TYPE_VECTOR MVT::v16i32
+//#define TYPE_VECTOR MVT::v32i16
+//#define TYPE_VECTOR_I16 MVT::v128i16
+#define TYPE_VECTOR_I16 MVT::v8i16
+//#define TYPE_VECTOR_ELEMENT MVT::i64
+#define TYPE_VECTOR_I16_ELEMENT MVT::i16
+
+//#define TYPE_VECTOR_I32 MVT::v64i32
+#define TYPE_VECTOR_I32 MVT::v4i32
+#define TYPE_VECTOR_I32_ELEMENT MVT::i32
+
+//#define TYPE_VECTOR_F16 MVT::v128f16
+#define TYPE_VECTOR_F16 MVT::v8f16
+#define TYPE_VECTOR_F16_ELEMENT MVT::f16
+
+
+#define TYPE_VECTOR_I16_ELEMENT_BITSIZE 16
+#define TYPE_VECTOR_I32_ELEMENT_BITSIZE 32
+#define TYPE_VECTOR_F16_ELEMENT_BITSIZE 16
+
+
+//#define CONNEX_MEM_SIZE 1024
+#define CONNEX_MEM_NUM_ROWS 1024
+// Extra LS memory for spills and LUTs for div/sqrt.f16, etc
+#define CONNEX_MEM_NUM_ROWS_EXTRA 200
+// For 64 lanes: #define CONNEX_MEM_NUM_ROWS 2048
+
+// NOTE: normally REPEAT accepts immediates in interval 0..1023
+#define VALUE_BOGUS_REPEAT_X_TIMES 32761
+
+
+//#ifndef MAXLEN_STR
+#define MAXLEN_STR 8192
+//#endif
+
+// Used in ConnexAsmPrinter.cpp and LoopVectorize.cpp
+#define STR_OPINCAA_CODE_BEGIN "// START_OPINCAA_HOST_DEVICE_CODE"
+#define STR_OPINCAA_CODE_END "// END_OPINCAA_HOST_DEVICE_CODE"
+
+#define STR_OPINCAA_KERNEL_REDUCE_BEFORE_END "REDUCE R(0); // We add a 'bogus' REDUCE to wait for it"
+
+#endif
+

lib/Target/Connex/ConnexSubtarget.h

+//===-- ConnexSubtarget.h - Define Subtarget for the Connex -----------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the Connex specific subclass of TargetSubtargetInfo.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_TARGET_CONNEX_CONNEXSUBTARGET_H
+#define LLVM_LIB_TARGET_CONNEX_CONNEXSUBTARGET_H
+
+#include "ConnexFrameLowering.h"
+#include "ConnexISelLowering.h"
+#include "ConnexInstrInfo.h"
+#include "ConnexSelectionDAGInfo.h"
+
+#include "llvm/CodeGen/SelectionDAGTargetInfo.h"
+#include "llvm/CodeGen/TargetSubtargetInfo.h"
+#include "llvm/IR/DataLayout.h"
+#include "llvm/Target/TargetMachine.h"
+
+#define GET_SUBTARGETINFO_HEADER
+#include "ConnexGenSubtargetInfo.inc"
+
+namespace llvm {
+class StringRef;
+
+class ConnexSubtarget : public ConnexGenSubtargetInfo {
+  virtual void anchor();
+  ConnexInstrInfo InstrInfo;
+  ConnexFrameLowering FrameLowering;
+  ConnexTargetLowering TLInfo;
+
+  SelectionDAGTargetInfo TSInfo;
+  ConnexSelectionDAGInfo TSInfo2;
+
+public:
+  // This constructor initializes the data members to match that
+  // of the specified triple.
+  ConnexSubtarget(const Triple &TT, const std::string &CPU, const std::string &FS,
+               const TargetMachine &TM);
+
+  // ParseSubtargetFeatures - Parses features string setting specified
+  // subtarget options.  Definition of function is auto generated by tblgen.
+  void ParseSubtargetFeatures(StringRef CPU, StringRef FS);
+
+  const ConnexInstrInfo *getInstrInfo() const override { return &InstrInfo; }
+  const ConnexFrameLowering *getFrameLowering() const override {
+    return &FrameLowering;
+  }
+  const ConnexTargetLowering *getTargetLowering() const override {
+    return &TLInfo;
+  }
+
+  const TargetRegisterInfo *getRegisterInfo() const override {
+    return &InstrInfo.getRegisterInfo();
+  }
+
+  // Inspired from ARM/ARMSubtarget.cpp
+  const ConnexSelectionDAGInfo *getSelectionDAGInfo() const override {
+    return &TSInfo2;
+  }
+};
+} // End llvm namespace
+
+#endif

lib/Target/Connex/ConnexTargetMachine.h

+//===-- ConnexTargetMachine.h - Define TargetMachine for Connex --- C++ ---===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the Connex specific subclass of TargetMachine.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_TARGET_CONNEX_CONNEXTARGETMACHINE_H
+#define LLVM_LIB_TARGET_CONNEX_CONNEXTARGETMACHINE_H
+
+#include "ConnexSubtarget.h"
+// 2019_03_30
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Analysis/TargetTransformInfo.h"
+#include "llvm/Support/CodeGen.h"
+#include "llvm/Target/TargetMachine.h" // This was before
+#include <memory>
+// END 2019_03_30
+
+namespace llvm {
+class ConnexTargetMachine : public LLVMTargetMachine {
+  std::unique_ptr<TargetLoweringObjectFile> TLOF;
+  ConnexSubtarget Subtarget;
+
+public:
+  ConnexTargetMachine(const Target &T, const Triple &TT, StringRef CPU,
+                      StringRef FS, const TargetOptions &Options,
+                      Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
+                      CodeGenOpt::Level OL, bool JIT);
+
+  const ConnexSubtarget *getSubtargetImpl() const { return &Subtarget; }
+  const ConnexSubtarget *getSubtargetImpl(const Function &) const override {
+    return &Subtarget;
+  }
+
+  TargetPassConfig *createPassConfig(PassManagerBase &PM) override;
+
+  // 2019_03_30: Inspired from ARC/ARCTargetMachine.h
+  TargetTransformInfo getTargetTransformInfo(const Function &F) override;
+
+  TargetLoweringObjectFile *getObjFileLowering() const override {
+    return TLOF.get();
+  }
+};
+}
+
+#endif

lib/Target/Connex/LLVMBuild.txt

+;===- ./lib/Target/Connex/LLVMBuild.txt ---------------------------*- Conf -*--===;
+;
+;                     The LLVM Compiler Infrastructure
+;
+; This file is distributed under the University of Illinois Open Source
+; License. See LICENSE.TXT for details.
+;
+;===------------------------------------------------------------------------===;
+;
+; This is an LLVMBuild description file for the components in this subdirectory.
+;
+; For more information on the LLVMBuild system, please see:
+;
+;   http://llvm.org/docs/LLVMBuild.html
+;
+;===------------------------------------------------------------------------===;
+
+[common]
+subdirectories = InstPrinter MCTargetDesc TargetInfo
+
+[component_0]
+type = TargetGroup
+name = Connex
+parent = Target
+has_asmprinter = 1
+
+[component_1]
+type = Library
+name = ConnexCodeGen
+parent = Connex
+required_libraries =
+ Analysis
+ AsmPrinter
+ CodeGen
+ Core
+ MC
+ ConnexAsmPrinter
+ ConnexDesc
+ ConnexInfo
+ SelectionDAG
+ Support
+ Target
+add_to_library_groups = Connex

lib/Target/Connex/Makefile

+##===- lib/Target/Connex/Makefile -----------------------------*- Makefile -*-===##
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+##===----------------------------------------------------------------------===##
+
+LEVEL = ../../..
+LIBRARYNAME = LLVMConnexCodeGen
+TARGET = Connex
+
+# Make sure that tblgen is run, first thing.
+BUILT_SOURCES = ConnexGenRegisterInfo.inc ConnexGenInstrInfo.inc \
+    ConnexGenAsmWriter.inc ConnexGenAsmMatcher.inc ConnexGenDAGISel.inc \
+    ConnexGenMCCodeEmitter.inc ConnexGenSubtargetInfo.inc ConnexGenCallingConv.inc
+
+DIRS = InstPrinter TargetInfo MCTargetDesc
+
+include $(LEVEL)/Makefile.common

lib/Target/Connex/Select_ADDf16_OpincaaCodeGen.cpp

+// From /home/asusu/LLVM/Tests/opincaa_standalone_apps/Emulate_f16/ADD_SUB_f16_manual/DumpISel_OpincaaCodeGen_old36_C00_ADDf16.cpp
+
+// Code auto-generated by method Kernel::genLLVMISelManualCode() 
+//   from Opincaa lib from kernel: add_or_sub.f16.
+// It is important to put this code in the Select() method of the
+//   SelectionDAGISel class of your back end, after the ISelLowering pass,
+//   which contains the DAG Combiner, because the DAG Combiner can remove
+//   the getCopyToReg() we create, which can lead to the following error:
+//   <<Register use before def!>> assertion failed.
+// Number of instructions generated: 279.
+
+
+
+
+SDValue ct0 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R14 = 1;
+// Instr #0
+SDNode *vload0 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct0,
+                                    // glue (or chain) input edge
+                                    SDValue(nodeOpSrcCast1, 1)
+                                    );
+
+SDValue ct1 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R30 = 1;
+// Instr #1
+SDNode *vload1 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct1,
+                                    // glue (or chain) input edge
+                                    SDValue(vload0, 1)
+                                    );
+
+SDValue ct2 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R31 = 0;
+// Instr #2
+SDNode *vload2 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct2,
+                                    // glue (or chain) input edge
+                                    SDValue(vload1, 1)
+                                    );
+
+SDValue ct3 = CurDAG->getConstant(16, DL, MVT::i16, true, false);
+// R29 = 16;
+// Instr #3
+SDNode *vload3 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct3,
+                                    // glue (or chain) input edge
+                                    SDValue(vload2, 1)
+                                    );
+
+SDValue ct4 = CurDAG->getConstant(31, DL, MVT::i16, true, false);
+// R28 = 31;
+// Instr #4
+SDNode *vload4 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct4,
+                                    // glue (or chain) input edge
+                                    SDValue(vload3, 1)
+                                    );
+
+SDValue ct5 = CurDAG->getConstant(1023, DL, MVT::i16, true, false);
+// R13 = 1023;
+// Instr #5
+SDNode *vload5 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct5,
+                                    // glue (or chain) input edge
+                                    SDValue(vload4, 1)
+                                    );
+
+SDValue ct6 = CurDAG->getConstant(31744, DL, MVT::i16, true, false);
+// R12 = 31744;
+// Instr #6
+SDNode *vload6 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct6,
+                                    // glue (or chain) input edge
+                                    SDValue(vload5, 1)
+                                    );
+
+SDValue ct7 = CurDAG->getConstant(-32768, DL, MVT::i16, true, false);
+// R11 = -32768;
+// Instr #7
+SDNode *vload7 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct7,
+                                    // glue (or chain) input edge
+                                    SDValue(vload6, 1)
+                                    );
+
+SDValue ct8 = CurDAG->getConstant(1024, DL, MVT::i16, true, false);
+// R10 = 1024;
+// Instr #8
+SDNode *vload8 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct8,
+                                    // glue (or chain) input edge
+                                    SDValue(vload7, 1)
+                                    );
+
+SDValue ct9 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R62 = 0;
+// Instr #9
+SDNode *vload9 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct9,
+                                    // glue (or chain) input edge
+                                    SDValue(vload8, 1)
+                                    );
+
+SDValue ct10 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R19 = 0;
+// Instr #10
+SDNode *vload10 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct10,
+                                    // glue (or chain) input edge
+                                    SDValue(vload9, 1)
+                                    );
+
+SDValue ct11 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R62 = 0;
+// Instr #11
+SDNode *vload11 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct11,
+                                    // glue (or chain) input edge
+                                    SDValue(vload10, 1)
+                                    );
+
+SDValue ct12 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R61 = 0;
+// Instr #12
+SDNode *vload12 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct12,
+                                    // glue (or chain) input edge
+                                    SDValue(vload11, 1)
+                                    );
+
+SDValue ct13 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R07 = 0;
+// Instr #13
+SDNode *vload13 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct13,
+                                    // glue (or chain) input edge
+                                    SDValue(vload12, 1)
+                                    );
+
+SDValue ct14 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R04 = 0;
+// Instr #14
+SDNode *vload14 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct14,
+                                    // glue (or chain) input edge
+                                    SDValue(vload13, 1)
+                                    );
+
+SDValue ct15 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R03 = 0;
+// Instr #15
+SDNode *vload15 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct15,
+                                    // glue (or chain) input edge
+                                    SDValue(vload14, 1)
+                                    );
+
+SDValue ct16 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R02 = 0;
+// Instr #16
+SDNode *vload16 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct16,
+                                    // glue (or chain) input edge
+                                    SDValue(vload15, 1)
+                                    );
+
+SDValue ct17 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R01 = 0;
+// Instr #17
+SDNode *vload17 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct17,
+                                    // glue (or chain) input edge
+                                    SDValue(vload16, 1)
+                                    );
+
+SDValue ct18 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R00 = 0;
+// Instr #18
+SDNode *vload18 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct18,
+                                    // glue (or chain) input edge
+                                    SDValue(vload17, 1)
+                                    );
+
+// R24 = R27 & R11;
+// Instr #19
+SDNode *and0 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload7, 0),
+                                    SDValue(nodeOpSrcCast1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload18, 1)
+                                    );
+
+// R25 = R27 & R12;
+// Instr #20
+SDNode *and1 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload6, 0),
+                                    SDValue(nodeOpSrcCast1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and0, 1)
+                                    );
+
+SDValue ct19 = CurDAG->getConstant(10, DL, MVT::i16, true, false);
+// R25 = R25 >> 10;
+// Instr #21
+SDNode *ishr0 = CurDAG->getMachineNode(
+                                    Connex::ISHRV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and1, 0),
+                                    ct19,
+                                    // glue (or chain) input edge
+                                    SDValue(and1, 1)
+                                    );
+
+// R26 = R27 & R13;
+// Instr #22
+SDNode *and2 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload5, 0),
+                                    SDValue(nodeOpSrcCast1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishr0, 1)
+                                    );
+
+// R18 = R31 < R26;
+// Instr #23
+SDNode *lt0 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(and2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and2, 1)
+                                    );
+
+// R17 = R25 == R31;
+// Instr #24
+SDNode *eq0 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishr0, 0),
+                                    SDValue(vload2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt0, 1)
+                                    );
+
+// R09 = R17 & R18;
+// Instr #25
+SDNode *and3 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(lt0, 0),
+                                    SDValue(eq0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq0, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #26
+SDNode *eq1 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and3, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and3, 1)
+                                    );
+
+SDValue ct20 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #27
+SDNode *nop0 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct20,
+                                    // glue (or chain) input edge
+                                    SDValue(eq1, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #28
+SDNode *whereeq0 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop0, 0)
+                                    );
+
+SDValue ct21 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R25 = 1;
+// Instr #29
+SDNode *vload19 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct21,
+                                    SDValue(ishr0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq0, 1)
+                                    );
+
+// END_WHERE;
+// Instr #30
+SDNode *endwhere0 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload19, 1)
+                                    );
+
+// R18 = R25 == R28;
+// Instr #31
+SDNode *eq2 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload19, 0),
+                                    SDValue(vload4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere0, 0)
+                                    );
+
+// R18 = R18 | R17;
+// Instr #32
+SDNode *or0 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq0, 0),
+                                    SDValue(eq2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq2, 1)
+                                    );
+
+// R18 = R18 == R31;
+// Instr #33
+SDNode *eq3 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or0, 0),
+                                    SDValue(vload2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or0, 1)
+                                    );
+
+SDValue ct22 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #34
+SDNode *nop1 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct22,
+                                    // glue (or chain) input edge
+                                    SDValue(eq3, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #35
+SDNode *whereeq1 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop1, 0)
+                                    );
+
+// R26 = R26 | R10;
+// Instr #36
+SDNode *or1 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload8, 0),
+                                    SDValue(and2, 0),
+                                    SDValue(and2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq1, 1)
+                                    );
+
+// END_WHERE;
+// Instr #37
+SDNode *endwhere1 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(or1, 1)
+                                    );
+
+// R20 = R23 & R11;
+// Instr #38
+SDNode *and4 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload7, 0),
+                                    SDValue(nodeOpSrcCast2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere1, 0)
+                                    );
+
+// R21 = R23 & R12;
+// Instr #39
+SDNode *and5 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload6, 0),
+                                    SDValue(nodeOpSrcCast2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and4, 1)
+                                    );
+
+SDValue ct23 = CurDAG->getConstant(10, DL, MVT::i16, true, false);
+// R21 = R21 >> 10;
+// Instr #40
+SDNode *ishr1 = CurDAG->getMachineNode(
+                                    Connex::ISHRV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and5, 0),
+                                    ct23,
+                                    // glue (or chain) input edge
+                                    SDValue(and5, 1)
+                                    );
+
+// R22 = R23 & R13;
+// Instr #41
+SDNode *and6 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload5, 0),
+                                    SDValue(nodeOpSrcCast2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishr1, 1)
+                                    );
+
+// R16 = R31 < R22;
+// Instr #42
+SDNode *lt1 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(and6, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and6, 1)
+                                    );
+
+// R15 = R21 == R31;
+// Instr #43
+SDNode *eq4 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishr1, 0),
+                                    SDValue(vload2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt1, 1)
+                                    );
+
+// R09 = R15 & R16;
+// Instr #44
+SDNode *and7 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(lt1, 0),
+                                    SDValue(eq4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq4, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #45
+SDNode *eq5 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and7, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and7, 1)
+                                    );
+
+SDValue ct24 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #46
+SDNode *nop2 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct24,
+                                    // glue (or chain) input edge
+                                    SDValue(eq5, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #47
+SDNode *whereeq2 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq5, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop2, 0)
+                                    );
+
+SDValue ct25 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R21 = 1;
+// Instr #48
+SDNode *vload20 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct25,
+                                    SDValue(ishr1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq2, 1)
+                                    );
+
+// END_WHERE;
+// Instr #49
+SDNode *endwhere2 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload20, 1)
+                                    );
+
+// R16 = R21 == R28;
+// Instr #50
+SDNode *eq6 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload20, 0),
+                                    SDValue(vload4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere2, 0)
+                                    );
+
+// R16 = R16 | R15;
+// Instr #51
+SDNode *or2 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq4, 0),
+                                    SDValue(eq6, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq6, 1)
+                                    );
+
+// R16 = R16 == R31;
+// Instr #52
+SDNode *eq7 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or2, 0),
+                                    SDValue(vload2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or2, 1)
+                                    );
+
+SDValue ct26 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #53
+SDNode *nop3 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct26,
+                                    // glue (or chain) input edge
+                                    SDValue(eq7, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #54
+SDNode *whereeq3 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop3, 0)
+                                    );
+
+// R22 = R22 | R10;
+// Instr #55
+SDNode *or3 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload8, 0),
+                                    SDValue(and6, 0),
+                                    SDValue(and6, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq3, 1)
+                                    );
+
+// END_WHERE;
+// Instr #56
+SDNode *endwhere3 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(or3, 1)
+                                    );
+
+// R50 = R24 == R11;
+// Instr #57
+SDNode *eq8 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and0, 0),
+                                    SDValue(vload7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere3, 0)
+                                    );
+
+// R49 = R25 == R28;
+// Instr #58
+SDNode *eq9 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload19, 0),
+                                    SDValue(vload4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq8, 1)
+                                    );
+
+// R48 = R26 == R31;
+// Instr #59
+SDNode *eq10 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or1, 0),
+                                    SDValue(vload2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq9, 1)
+                                    );
+
+// R47 = R20 == R11;
+// Instr #60
+SDNode *eq11 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and4, 0),
+                                    SDValue(vload7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq10, 1)
+                                    );
+
+// R46 = R21 == R28;
+// Instr #61
+SDNode *eq12 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload20, 0),
+                                    SDValue(vload4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq11, 1)
+                                    );
+
+// R45 = R22 == R31;
+// Instr #62
+SDNode *eq13 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or3, 0),
+                                    SDValue(vload2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq12, 1)
+                                    );
+
+// R07 = R49 & R46;
+// Instr #63
+SDNode *and8 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq12, 0),
+                                    SDValue(eq9, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq13, 1)
+                                    );
+
+// R08 = R07 & R50;
+// Instr #64
+SDNode *and9 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq8, 0),
+                                    SDValue(and8, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and8, 1)
+                                    );
+
+// R44 = ~R47;
+// Instr #65
+SDNode *not0 = CurDAG->getMachineNode(
+                                    Connex::NOT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq11, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and9, 1)
+                                    );
+
+// R08 = R08 & R44;
+// Instr #66
+SDNode *and10 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(not0, 0),
+                                    SDValue(and9, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(not0, 1)
+                                    );
+
+// R44 = ~R50;
+// Instr #67
+SDNode *not1 = CurDAG->getMachineNode(
+                                    Connex::NOT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq8, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and10, 1)
+                                    );
+
+// R44 = R44 & R07;
+// Instr #68
+SDNode *and11 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and8, 0),
+                                    SDValue(not1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(not1, 1)
+                                    );
+
+// R44 = R44 & R47;
+// Instr #69
+SDNode *and12 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq11, 0),
+                                    SDValue(and11, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and11, 1)
+                                    );
+
+// R08 = R08 | R44;
+// Instr #70
+SDNode *or4 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and12, 0),
+                                    SDValue(and10, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and12, 1)
+                                    );
+
+// R07 = ~R45;
+// Instr #71
+SDNode *not2 = CurDAG->getMachineNode(
+                                    Connex::NOT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq13, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or4, 1)
+                                    );
+
+// R07 = R07 & R46;
+// Instr #72
+SDNode *and13 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq12, 0),
+                                    SDValue(not2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(not2, 1)
+                                    );
+
+// R08 = R08 | R07;
+// Instr #73
+SDNode *or5 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and13, 0),
+                                    SDValue(or4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and13, 1)
+                                    );
+
+// R07 = ~R48;
+// Instr #74
+SDNode *not3 = CurDAG->getMachineNode(
+                                    Connex::NOT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq10, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or5, 1)
+                                    );
+
+// R07 = R07 & R49;
+// Instr #75
+SDNode *and14 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq9, 0),
+                                    SDValue(not3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(not3, 1)
+                                    );
+
+// R08 = R08 | R07;
+// Instr #76
+SDNode *or6 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and14, 0),
+                                    SDValue(or5, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and14, 1)
+                                    );
+
+// R09 = R08 == R30;
+// Instr #77
+SDNode *eq14 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or6, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or6, 1)
+                                    );
+
+SDValue ct27 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #78
+SDNode *nop4 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct27,
+                                    // glue (or chain) input edge
+                                    SDValue(eq14, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #79
+SDNode *whereeq4 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq14, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop4, 0)
+                                    );
+
+SDValue ct28 = CurDAG->getConstant(31745, DL, MVT::i16, true, false);
+// R19 = 31745;
+// Instr #80
+SDNode *vload21 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct28,
+                                    SDValue(vload10, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq4, 1)
+                                    );
+
+SDValue ct29 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R14 = 0;
+// Instr #81
+SDNode *vload22 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct29,
+                                    SDValue(vload0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload21, 1)
+                                    );
+
+// END_WHERE;
+// Instr #82
+SDNode *endwhere4 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload22, 1)
+                                    );
+
+// R08 = R49 | R46;
+// Instr #83
+SDNode *or7 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq12, 0),
+                                    SDValue(eq9, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere4, 0)
+                                    );
+
+// R09 = R08 & R14;
+// Instr #84
+SDNode *and15 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload22, 0),
+                                    SDValue(or7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or7, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #85
+SDNode *eq15 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and15, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and15, 1)
+                                    );
+
+SDValue ct30 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #86
+SDNode *nop5 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct30,
+                                    // glue (or chain) input edge
+                                    SDValue(eq15, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #87
+SDNode *whereeq5 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq15, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop5, 0)
+                                    );
+
+SDValue ct31 = CurDAG->getConstant(31744, DL, MVT::i16, true, false);
+// R19 = 31744;
+// Instr #88
+SDNode *vload23 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct31,
+                                    SDValue(vload21, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq5, 1)
+                                    );
+
+// R08 = R50 & R49;
+// Instr #89
+SDNode *and16 = CurDAG->getMachineNode(
+                                    Connex::ANDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq9, 0),
+                                    SDValue(eq8, 0),
+                                    SDValue(or7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload23, 1)
+                                    );
+
+// R07 = R47 & R46;
+// Instr #90
+SDNode *and17 = CurDAG->getMachineNode(
+                                    Connex::ANDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq12, 0),
+                                    SDValue(eq11, 0),
+                                    SDValue(and14, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and16, 1)
+                                    );
+
+// R08 = R08 | R07;
+// Instr #91
+SDNode *or8 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and17, 0),
+                                    SDValue(and16, 0),
+                                    SDValue(and16, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and17, 1)
+                                    );
+
+SDValue ct32 = CurDAG->getConstant(15, DL, MVT::i16, true, false);
+// R08 = R08 << 15;
+// Instr #92
+SDNode *ishl0 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or8, 0),
+                                    ct32,
+                                    SDValue(or8, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or8, 1)
+                                    );
+
+// R19 = R19 ^ R08;
+// Instr #93
+SDNode *xor0 = CurDAG->getMachineNode(
+                                    Connex::XORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishl0, 0),
+                                    SDValue(vload23, 0),
+                                    SDValue(vload23, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl0, 1)
+                                    );
+
+SDValue ct33 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R14 = 0;
+// Instr #94
+SDNode *vload24 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct33,
+                                    SDValue(vload22, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(xor0, 1)
+                                    );
+
+// END_WHERE;
+// Instr #95
+SDNode *endwhere5 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload24, 1)
+                                    );
+
+// R15 = R25 - R21;
+// Instr #96
+SDNode *sub0 = CurDAG->getMachineNode(
+                                    Connex::SUBV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload19, 0),
+                                    SDValue(vload20, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere5, 0)
+                                    );
+
+SDValue ct34 = CurDAG->getConstant(-15, DL, MVT::i16, true, false);
+// R08 = -15;
+// Instr #97
+SDNode *vload25 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct34,
+                                    // glue (or chain) input edge
+                                    SDValue(sub0, 1)
+                                    );
+
+// R09 = R15 < R08;
+// Instr #98
+SDNode *lt2 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub0, 0),
+                                    SDValue(vload25, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload25, 1)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #99
+SDNode *and18 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(lt2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt2, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #100
+SDNode *eq16 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and18, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and18, 1)
+                                    );
+
+SDValue ct35 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #101
+SDNode *nop6 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct35,
+                                    // glue (or chain) input edge
+                                    SDValue(eq16, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #102
+SDNode *whereeq6 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq16, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop6, 0)
+                                    );
+
+// R15 = R31 - R15;
+// Instr #103
+SDNode *sub1 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(sub0, 0),
+                                    SDValue(sub0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq6, 1)
+                                    );
+
+SDValue ct36 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R26 = 0;
+// Instr #104
+SDNode *vload26 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct36,
+                                    SDValue(or1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub1, 1)
+                                    );
+
+SDValue ct37 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R25 = R21 << 0;
+// Instr #105
+SDNode *ishl1 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload20, 0),
+                                    ct37,
+                                    SDValue(vload19, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload26, 1)
+                                    );
+
+SDValue ct38 = CurDAG->getConstant(32000, DL, MVT::i16, true, false);
+// R15 = 32000;
+// Instr #106
+SDNode *vload27 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct38,
+                                    SDValue(sub1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl1, 1)
+                                    );
+
+// END_WHERE;
+// Instr #107
+SDNode *endwhere6 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload27, 1)
+                                    );
+
+SDValue ct39 = CurDAG->getConstant(-3, DL, MVT::i16, true, false);
+// R08 = -3;
+// Instr #108
+SDNode *vload28 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct39,
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere6, 0)
+                                    );
+
+// R09 = R15 < R08;
+// Instr #109
+SDNode *lt3 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload27, 0),
+                                    SDValue(vload28, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload28, 1)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #110
+SDNode *and19 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(lt3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt3, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #111
+SDNode *eq17 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and19, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and19, 1)
+                                    );
+
+SDValue ct40 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #112
+SDNode *nop7 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct40,
+                                    // glue (or chain) input edge
+                                    SDValue(eq17, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #113
+SDNode *whereeq7 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq17, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop7, 0)
+                                    );
+
+// R15 = R31 - R15;
+// Instr #114
+SDNode *sub2 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(vload27, 0),
+                                    SDValue(vload27, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq7, 1)
+                                    );
+
+// R26 = R26 >> R15;
+// Instr #115
+SDNode *shr0 = CurDAG->getMachineNode(
+                                    Connex::SHRV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload26, 0),
+                                    SDValue(sub2, 0),
+                                    SDValue(vload26, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub2, 1)
+                                    );
+
+SDValue ct41 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R25 = R21 << 0;
+// Instr #116
+SDNode *ishl2 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload20, 0),
+                                    ct41,
+                                    SDValue(ishl1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shr0, 1)
+                                    );
+
+SDValue ct42 = CurDAG->getConstant(32000, DL, MVT::i16, true, false);
+// R15 = 32000;
+// Instr #117
+SDNode *vload29 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct42,
+                                    SDValue(sub2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl2, 1)
+                                    );
+
+// END_WHERE;
+// Instr #118
+SDNode *endwhere7 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload29, 1)
+                                    );
+
+// R09 = R15 < R31;
+// Instr #119
+SDNode *lt4 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload29, 0),
+                                    SDValue(vload2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere7, 0)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #120
+SDNode *and20 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(lt4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt4, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #121
+SDNode *eq18 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and20, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and20, 1)
+                                    );
+
+SDValue ct43 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #122
+SDNode *nop8 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct43,
+                                    // glue (or chain) input edge
+                                    SDValue(eq18, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #123
+SDNode *whereeq8 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq18, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop8, 0)
+                                    );
+
+// R15 = R31 - R15;
+// Instr #124
+SDNode *sub3 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(vload29, 0),
+                                    SDValue(vload29, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq8, 1)
+                                    );
+
+// R22 = R22 << R15;
+// Instr #125
+SDNode *shl0 = CurDAG->getMachineNode(
+                                    Connex::SHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or3, 0),
+                                    SDValue(sub3, 0),
+                                    SDValue(or3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub3, 1)
+                                    );
+
+SDValue ct44 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R21 = R25 << 0;
+// Instr #126
+SDNode *ishl3 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishl2, 0),
+                                    ct44,
+                                    SDValue(vload20, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shl0, 1)
+                                    );
+
+SDValue ct45 = CurDAG->getConstant(32000, DL, MVT::i16, true, false);
+// R15 = 32000;
+// Instr #127
+SDNode *vload30 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct45,
+                                    SDValue(sub3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl3, 1)
+                                    );
+
+// END_WHERE;
+// Instr #128
+SDNode *endwhere8 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload30, 1)
+                                    );
+
+SDValue ct46 = CurDAG->getConstant(4, DL, MVT::i16, true, false);
+// R08 = 4;
+// Instr #129
+SDNode *vload31 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct46,
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere8, 0)
+                                    );
+
+// R09 = R15 < R08;
+// Instr #130
+SDNode *lt5 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload30, 0),
+                                    SDValue(vload31, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload31, 1)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #131
+SDNode *and21 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(lt5, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt5, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #132
+SDNode *eq19 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and21, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and21, 1)
+                                    );
+
+SDValue ct47 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #133
+SDNode *nop9 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct47,
+                                    // glue (or chain) input edge
+                                    SDValue(eq19, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #134
+SDNode *whereeq9 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq19, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop9, 0)
+                                    );
+
+// R26 = R26 << R15;
+// Instr #135
+SDNode *shl1 = CurDAG->getMachineNode(
+                                    Connex::SHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shr0, 0),
+                                    SDValue(vload30, 0),
+                                    SDValue(shr0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq9, 1)
+                                    );
+
+SDValue ct48 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R25 = R21 << 0;
+// Instr #136
+SDNode *ishl4 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishl3, 0),
+                                    ct48,
+                                    SDValue(ishl2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shl1, 1)
+                                    );
+
+SDValue ct49 = CurDAG->getConstant(32000, DL, MVT::i16, true, false);
+// R15 = 32000;
+// Instr #137
+SDNode *vload32 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct49,
+                                    SDValue(vload30, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl4, 1)
+                                    );
+
+// END_WHERE;
+// Instr #138
+SDNode *endwhere9 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload32, 1)
+                                    );
+
+// R09 = R15 < R29;
+// Instr #139
+SDNode *lt6 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload32, 0),
+                                    SDValue(vload3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere9, 0)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #140
+SDNode *and22 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(lt6, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt6, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #141
+SDNode *eq20 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and22, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and22, 1)
+                                    );
+
+SDValue ct50 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #142
+SDNode *nop10 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct50,
+                                    // glue (or chain) input edge
+                                    SDValue(eq20, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #143
+SDNode *whereeq10 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq20, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop10, 0)
+                                    );
+
+// R22 = R22 >> R15;
+// Instr #144
+SDNode *shr1 = CurDAG->getMachineNode(
+                                    Connex::SHRV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl0, 0),
+                                    SDValue(vload32, 0),
+                                    SDValue(shl0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq10, 1)
+                                    );
+
+SDValue ct51 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R21 = R25 << 0;
+// Instr #145
+SDNode *ishl5 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishl4, 0),
+                                    ct51,
+                                    SDValue(ishl3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shr1, 1)
+                                    );
+
+SDValue ct52 = CurDAG->getConstant(32000, DL, MVT::i16, true, false);
+// R15 = 32000;
+// Instr #146
+SDNode *vload33 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct52,
+                                    SDValue(vload32, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl5, 1)
+                                    );
+
+// END_WHERE;
+// Instr #147
+SDNode *endwhere10 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload33, 1)
+                                    );
+
+SDValue ct53 = CurDAG->getConstant(32, DL, MVT::i16, true, false);
+// R08 = 32;
+// Instr #148
+SDNode *vload34 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct53,
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere10, 0)
+                                    );
+
+// R09 = R15 < R08;
+// Instr #149
+SDNode *lt7 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload33, 0),
+                                    SDValue(vload34, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload34, 1)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #150
+SDNode *and23 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(lt7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt7, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #151
+SDNode *eq21 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and23, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and23, 1)
+                                    );
+
+SDValue ct54 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #152
+SDNode *nop11 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct54,
+                                    // glue (or chain) input edge
+                                    SDValue(eq21, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #153
+SDNode *whereeq11 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq21, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop11, 0)
+                                    );
+
+SDValue ct55 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R22 = 0;
+// Instr #154
+SDNode *vload35 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct55,
+                                    SDValue(shr1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq11, 1)
+                                    );
+
+SDValue ct56 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R21 = R25 << 0;
+// Instr #155
+SDNode *ishl6 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishl4, 0),
+                                    ct56,
+                                    SDValue(ishl5, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload35, 1)
+                                    );
+
+// END_WHERE;
+// Instr #156
+SDNode *endwhere11 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(ishl6, 1)
+                                    );
+
+// R09 = R24 == R11;
+// Instr #157
+SDNode *eq22 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and0, 0),
+                                    SDValue(vload7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere11, 0)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #158
+SDNode *and24 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(eq22, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq22, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #159
+SDNode *eq23 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and24, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and24, 1)
+                                    );
+
+SDValue ct57 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #160
+SDNode *nop12 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct57,
+                                    // glue (or chain) input edge
+                                    SDValue(eq23, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #161
+SDNode *whereeq12 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq23, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop12, 0)
+                                    );
+
+// R26 = R31 - R26;
+// Instr #162
+SDNode *sub4 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(shl1, 0),
+                                    SDValue(shl1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq12, 1)
+                                    );
+
+// END_WHERE;
+// Instr #163
+SDNode *endwhere12 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(sub4, 1)
+                                    );
+
+// R09 = R20 == R11;
+// Instr #164
+SDNode *eq24 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and4, 0),
+                                    SDValue(vload7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere12, 0)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #165
+SDNode *and25 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(eq24, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq24, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #166
+SDNode *eq25 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and25, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and25, 1)
+                                    );
+
+SDValue ct58 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #167
+SDNode *nop13 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct58,
+                                    // glue (or chain) input edge
+                                    SDValue(eq25, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #168
+SDNode *whereeq13 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq25, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop13, 0)
+                                    );
+
+// R22 = R31 - R22;
+// Instr #169
+SDNode *sub5 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(vload35, 0),
+                                    SDValue(vload35, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq13, 1)
+                                    );
+
+// END_WHERE;
+// Instr #170
+SDNode *endwhere13 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(sub5, 1)
+                                    );
+
+// R09 = R14 == R30;
+// Instr #171
+SDNode *eq26 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere13, 0)
+                                    );
+
+SDValue ct59 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #172
+SDNode *nop14 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct59,
+                                    // glue (or chain) input edge
+                                    SDValue(eq26, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #173
+SDNode *whereeq14 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq26, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop14, 0)
+                                    );
+
+// R26 = R22 + R26;
+// Instr #174
+SDNode *add0 = CurDAG->getMachineNode(
+                                    Connex::ADDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub4, 0),
+                                    SDValue(sub5, 0),
+                                    SDValue(sub4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq14, 1)
+                                    );
+
+// END_WHERE;
+// Instr #175
+SDNode *endwhere14 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(add0, 1)
+                                    );
+
+// R24 = R26 & R11;
+// Instr #176
+SDNode *and26 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload7, 0),
+                                    SDValue(add0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere14, 0)
+                                    );
+
+// R09 = R24 == R11;
+// Instr #177
+SDNode *eq27 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and26, 0),
+                                    SDValue(vload7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and26, 1)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #178
+SDNode *and27 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(eq27, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq27, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #179
+SDNode *eq28 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and27, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and27, 1)
+                                    );
+
+SDValue ct60 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #180
+SDNode *nop15 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct60,
+                                    // glue (or chain) input edge
+                                    SDValue(eq28, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #181
+SDNode *whereeq15 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq28, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop15, 0)
+                                    );
+
+// R26 = R31 - R26;
+// Instr #182
+SDNode *sub6 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(add0, 0),
+                                    SDValue(add0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq15, 1)
+                                    );
+
+// END_WHERE;
+// Instr #183
+SDNode *endwhere15 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(sub6, 1)
+                                    );
+
+SDValue ct61 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R05 = R26 << 0;
+// Instr #184
+SDNode *ishl7 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub6, 0),
+                                    ct61,
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere15, 0)
+                                    );
+
+SDValue ct62 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R08 = R05 >> 1;
+// Instr #185
+SDNode *ishr2 = CurDAG->getMachineNode(
+                                    Connex::ISHRV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishl7, 0),
+                                    ct62,
+                                    // glue (or chain) input edge
+                                    SDValue(ishl7, 1)
+                                    );
+
+// R05 = R05 | R08;
+// Instr #186
+SDNode *or9 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishr2, 0),
+                                    SDValue(ishl7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishr2, 1)
+                                    );
+
+SDValue ct63 = CurDAG->getConstant(2, DL, MVT::i16, true, false);
+// R08 = R05 >> 2;
+// Instr #187
+SDNode *ishr3 = CurDAG->getMachineNode(
+                                    Connex::ISHRV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or9, 0),
+                                    ct63,
+                                    // glue (or chain) input edge
+                                    SDValue(or9, 1)
+                                    );
+
+// R05 = R05 | R08;
+// Instr #188
+SDNode *or10 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishr3, 0),
+                                    SDValue(or9, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishr3, 1)
+                                    );
+
+SDValue ct64 = CurDAG->getConstant(4, DL, MVT::i16, true, false);
+// R08 = R05 >> 4;
+// Instr #189
+SDNode *ishr4 = CurDAG->getMachineNode(
+                                    Connex::ISHRV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or10, 0),
+                                    ct64,
+                                    // glue (or chain) input edge
+                                    SDValue(or10, 1)
+                                    );
+
+// R05 = R05 | R08;
+// Instr #190
+SDNode *or11 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishr4, 0),
+                                    SDValue(or10, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishr4, 1)
+                                    );
+
+SDValue ct65 = CurDAG->getConstant(8, DL, MVT::i16, true, false);
+// R08 = R05 >> 8;
+// Instr #191
+SDNode *ishr5 = CurDAG->getMachineNode(
+                                    Connex::ISHRV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or11, 0),
+                                    ct65,
+                                    // glue (or chain) input edge
+                                    SDValue(or11, 1)
+                                    );
+
+// R05 = R05 | R08;
+// Instr #192
+SDNode *or12 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishr5, 0),
+                                    SDValue(or11, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishr5, 1)
+                                    );
+
+// R05 = ~R05;
+// Instr #193
+SDNode *not4 = CurDAG->getMachineNode(
+                                    Connex::NOT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or12, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or12, 1)
+                                    );
+
+// R06 = POPCNT(R05);
+// Instr #194
+SDNode *popcnt0 = CurDAG->getMachineNode(
+                                    Connex::POPCNT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(not4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(not4, 1)
+                                    );
+
+// R06 = R29 - R06;
+// Instr #195
+SDNode *sub7 = CurDAG->getMachineNode(
+                                    Connex::SUBV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload3, 0),
+                                    SDValue(popcnt0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(popcnt0, 1)
+                                    );
+
+SDValue ct66 = CurDAG->getConstant(11, DL, MVT::i16, true, false);
+// R08 = 11;
+// Instr #196
+SDNode *vload36 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct66,
+                                    // glue (or chain) input edge
+                                    SDValue(sub7, 1)
+                                    );
+
+// R08 = R06 - R08;
+// Instr #197
+SDNode *sub8 = CurDAG->getMachineNode(
+                                    Connex::SUBV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub7, 0),
+                                    SDValue(vload36, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload36, 1)
+                                    );
+
+// R09 = R31 < R08;
+// Instr #198
+SDNode *lt8 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(sub8, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub8, 1)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #199
+SDNode *and28 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(lt8, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt8, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #200
+SDNode *eq29 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and28, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and28, 1)
+                                    );
+
+SDValue ct67 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #201
+SDNode *nop16 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct67,
+                                    // glue (or chain) input edge
+                                    SDValue(eq29, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #202
+SDNode *whereeq16 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq29, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop16, 0)
+                                    );
+
+SDValue ct68 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R62 = R26 << 0;
+// Instr #203
+SDNode *ishl8 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub6, 0),
+                                    ct68,
+                                    SDValue(vload11, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq16, 1)
+                                    );
+
+// R09 = R29 - R08;
+// Instr #204
+SDNode *sub9 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload3, 0),
+                                    SDValue(sub8, 0),
+                                    SDValue(eq29, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl8, 1)
+                                    );
+
+// R62 = R62 << R09;
+// Instr #205
+SDNode *shl2 = CurDAG->getMachineNode(
+                                    Connex::SHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishl8, 0),
+                                    SDValue(sub9, 0),
+                                    SDValue(ishl8, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub9, 1)
+                                    );
+
+// R62 = R62 >> R09;
+// Instr #206
+SDNode *shr2 = CurDAG->getMachineNode(
+                                    Connex::SHRV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl2, 0),
+                                    SDValue(sub9, 0),
+                                    SDValue(shl2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shl2, 1)
+                                    );
+
+SDValue ct69 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R61 = R08 << 0;
+// Instr #207
+SDNode *ishl9 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub8, 0),
+                                    ct69,
+                                    SDValue(vload12, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shr2, 1)
+                                    );
+
+// R26 = R26 >> R08;
+// Instr #208
+SDNode *shr3 = CurDAG->getMachineNode(
+                                    Connex::SHRV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub6, 0),
+                                    SDValue(sub8, 0),
+                                    SDValue(sub6, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl9, 1)
+                                    );
+
+// R25 = R08 + R25;
+// Instr #209
+SDNode *add1 = CurDAG->getMachineNode(
+                                    Connex::ADDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishl4, 0),
+                                    SDValue(sub8, 0),
+                                    SDValue(ishl4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shr3, 1)
+                                    );
+
+// END_WHERE;
+// Instr #210
+SDNode *endwhere16 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(add1, 1)
+                                    );
+
+// R09 = R08 < R31;
+// Instr #211
+SDNode *lt9 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub8, 0),
+                                    SDValue(vload2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere16, 0)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #212
+SDNode *and29 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(lt9, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt9, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #213
+SDNode *eq30 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and29, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and29, 1)
+                                    );
+
+SDValue ct70 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #214
+SDNode *nop17 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct70,
+                                    // glue (or chain) input edge
+                                    SDValue(eq30, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #215
+SDNode *whereeq17 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq30, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop17, 0)
+                                    );
+
+// R08 = R31 - R08;
+// Instr #216
+SDNode *sub10 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(sub8, 0),
+                                    SDValue(sub8, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq17, 1)
+                                    );
+
+// R26 = R26 << R08;
+// Instr #217
+SDNode *shl3 = CurDAG->getMachineNode(
+                                    Connex::SHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shr3, 0),
+                                    SDValue(sub10, 0),
+                                    SDValue(shr3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub10, 1)
+                                    );
+
+// R25 = R25 - R08;
+// Instr #218
+SDNode *sub11 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(add1, 0),
+                                    SDValue(sub10, 0),
+                                    SDValue(add1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shl3, 1)
+                                    );
+
+// END_WHERE;
+// Instr #219
+SDNode *endwhere17 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(sub11, 1)
+                                    );
+
+// R09 = R25 < R30;
+// Instr #220
+SDNode *lt10 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub11, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere17, 0)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #221
+SDNode *and30 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(lt10, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt10, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #222
+SDNode *eq31 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and30, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and30, 1)
+                                    );
+
+SDValue ct71 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #223
+SDNode *nop18 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct71,
+                                    // glue (or chain) input edge
+                                    SDValue(eq31, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #224
+SDNode *whereeq18 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq31, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop18, 0)
+                                    );
+
+// R61 = R30 - R25;
+// Instr #225
+SDNode *sub12 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(sub11, 0),
+                                    SDValue(ishl9, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq18, 1)
+                                    );
+
+SDValue ct72 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R25 = 1;
+// Instr #226
+SDNode *vload37 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct72,
+                                    SDValue(sub11, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub12, 1)
+                                    );
+
+SDValue ct73 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R62 = R26 << 0;
+// Instr #227
+SDNode *ishl10 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl3, 0),
+                                    ct73,
+                                    SDValue(shr2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload37, 1)
+                                    );
+
+// R09 = R29 - R61;
+// Instr #228
+SDNode *sub13 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload3, 0),
+                                    SDValue(sub12, 0),
+                                    SDValue(eq31, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl10, 1)
+                                    );
+
+// R62 = R62 << R09;
+// Instr #229
+SDNode *shl4 = CurDAG->getMachineNode(
+                                    Connex::SHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishl10, 0),
+                                    SDValue(sub13, 0),
+                                    SDValue(ishl10, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub13, 1)
+                                    );
+
+// R62 = R62 >> R09;
+// Instr #230
+SDNode *shr4 = CurDAG->getMachineNode(
+                                    Connex::SHRV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl4, 0),
+                                    SDValue(sub13, 0),
+                                    SDValue(shl4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shl4, 1)
+                                    );
+
+// R26 = R26 >> R61;
+// Instr #231
+SDNode *shr5 = CurDAG->getMachineNode(
+                                    Connex::SHRV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl3, 0),
+                                    SDValue(sub12, 0),
+                                    SDValue(shl3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shr4, 1)
+                                    );
+
+// END_WHERE;
+// Instr #232
+SDNode *endwhere18 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(shr5, 1)
+                                    );
+
+SDValue ct74 = CurDAG->getConstant(1024, DL, MVT::i16, true, false);
+// R08 = 1024;
+// Instr #233
+SDNode *vload38 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct74,
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere18, 0)
+                                    );
+
+// R08 = R26 < R08;
+// Instr #234
+SDNode *lt11 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shr5, 0),
+                                    SDValue(vload38, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload38, 1)
+                                    );
+
+// R09 = R25 == R30;
+// Instr #235
+SDNode *eq32 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload37, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt11, 1)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #236
+SDNode *and31 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(eq32, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq32, 1)
+                                    );
+
+// R09 = R09 & R08;
+// Instr #237
+SDNode *and32 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(lt11, 0),
+                                    SDValue(and31, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and31, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #238
+SDNode *eq33 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and32, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and32, 1)
+                                    );
+
+SDValue ct75 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #239
+SDNode *nop19 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct75,
+                                    // glue (or chain) input edge
+                                    SDValue(eq33, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #240
+SDNode *whereeq19 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq33, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop19, 0)
+                                    );
+
+SDValue ct76 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R25 = 0;
+// Instr #241
+SDNode *vload39 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct76,
+                                    SDValue(vload37, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq19, 1)
+                                    );
+
+// END_WHERE;
+// Instr #242
+SDNode *endwhere19 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload39, 1)
+                                    );
+
+// R26 = R26 & R13;
+// Instr #243
+SDNode *and33 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload5, 0),
+                                    SDValue(shr5, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere19, 0)
+                                    );
+
+SDValue ct77 = CurDAG->getConstant(30, DL, MVT::i16, true, false);
+// R09 = 30;
+// Instr #244
+SDNode *vload40 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct77,
+                                    // glue (or chain) input edge
+                                    SDValue(and33, 1)
+                                    );
+
+// R09 = R09 < R25;
+// Instr #245
+SDNode *lt12 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload40, 0),
+                                    SDValue(vload39, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload40, 1)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #246
+SDNode *and34 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(lt12, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt12, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #247
+SDNode *eq34 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and34, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and34, 1)
+                                    );
+
+SDValue ct78 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #248
+SDNode *nop20 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct78,
+                                    // glue (or chain) input edge
+                                    SDValue(eq34, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #249
+SDNode *whereeq20 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq34, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop20, 0)
+                                    );
+
+SDValue ct79 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R14 = 0;
+// Instr #250
+SDNode *vload41 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct79,
+                                    SDValue(vload24, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq20, 1)
+                                    );
+
+SDValue ct80 = CurDAG->getConstant(31744, DL, MVT::i16, true, false);
+// R19 = 31744;
+// Instr #251
+SDNode *vload42 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct80,
+                                    SDValue(xor0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload41, 1)
+                                    );
+
+// R19 = R19 | R24;
+// Instr #252
+SDNode *or13 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and26, 0),
+                                    SDValue(vload42, 0),
+                                    SDValue(vload42, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload42, 1)
+                                    );
+
+// END_WHERE;
+// Instr #253
+SDNode *endwhere20 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(or13, 1)
+                                    );
+
+// R08 = R14 == R30;
+// Instr #254
+SDNode *eq35 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload41, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere20, 0)
+                                    );
+
+SDValue ct81 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #255
+SDNode *nop21 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct81,
+                                    // glue (or chain) input edge
+                                    SDValue(eq35, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #256
+SDNode *whereeq21 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq35, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop21, 0)
+                                    );
+
+SDValue ct82 = CurDAG->getConstant(10, DL, MVT::i16, true, false);
+// R19 = R25 << 10;
+// Instr #257
+SDNode *ishl11 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload39, 0),
+                                    ct82,
+                                    SDValue(or13, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq21, 1)
+                                    );
+
+// R19 = R19 | R26;
+// Instr #258
+SDNode *or14 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and33, 0),
+                                    SDValue(ishl11, 0),
+                                    SDValue(ishl11, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl11, 1)
+                                    );
+
+// R04 = R26 & R30;
+// Instr #259
+SDNode *and35 = CurDAG->getMachineNode(
+                                    Connex::ANDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(and33, 0),
+                                    SDValue(vload14, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or14, 1)
+                                    );
+
+// R07 = R61 - R30;
+// Instr #260
+SDNode *sub14 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub12, 0),
+                                    SDValue(vload1, 0),
+                                    SDValue(and17, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and35, 1)
+                                    );
+
+// R08 = R30 << R08;
+// Instr #261
+SDNode *shl5 = CurDAG->getMachineNode(
+                                    Connex::SHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(eq35, 0),
+                                    SDValue(eq35, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub14, 1)
+                                    );
+
+// R03 = R62 & R08;
+// Instr #262
+SDNode *and36 = CurDAG->getMachineNode(
+                                    Connex::ANDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl5, 0),
+                                    SDValue(shr4, 0),
+                                    SDValue(vload15, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shl5, 1)
+                                    );
+
+// R62 = R62 ^ R03;
+// Instr #263
+SDNode *xor1 = CurDAG->getMachineNode(
+                                    Connex::XORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and36, 0),
+                                    SDValue(shr4, 0),
+                                    SDValue(shr4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and36, 1)
+                                    );
+
+// R03 = R03 == R31;
+// Instr #264
+SDNode *eq36 = CurDAG->getMachineNode(
+                                    Connex::EQ_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and36, 0),
+                                    SDValue(vload2, 0),
+                                    SDValue(and36, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(xor1, 1)
+                                    );
+
+// R03 = R30 - R03;
+// Instr #265
+SDNode *sub15 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(eq36, 0),
+                                    SDValue(eq36, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq36, 1)
+                                    );
+
+SDValue ct83 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R08 = R08 >> 1;
+// Instr #266
+SDNode *ishr6 = CurDAG->getMachineNode(
+                                    Connex::ISHRV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl5, 0),
+                                    ct83,
+                                    SDValue(shl5, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub15, 1)
+                                    );
+
+// R02 = R62 & R08;
+// Instr #267
+SDNode *and37 = CurDAG->getMachineNode(
+                                    Connex::ANDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishr6, 0),
+                                    SDValue(xor1, 0),
+                                    SDValue(vload16, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishr6, 1)
+                                    );
+
+// R62 = R62 ^ R02;
+// Instr #268
+SDNode *xor2 = CurDAG->getMachineNode(
+                                    Connex::XORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and37, 0),
+                                    SDValue(xor1, 0),
+                                    SDValue(xor1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and37, 1)
+                                    );
+
+// R02 = R02 == R31;
+// Instr #269
+SDNode *eq37 = CurDAG->getMachineNode(
+                                    Connex::EQ_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and37, 0),
+                                    SDValue(vload2, 0),
+                                    SDValue(and37, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(xor2, 1)
+                                    );
+
+// R02 = R30 - R02;
+// Instr #270
+SDNode *sub16 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(eq37, 0),
+                                    SDValue(eq37, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq37, 1)
+                                    );
+
+// R01 = R62 == R31;
+// Instr #271
+SDNode *eq38 = CurDAG->getMachineNode(
+                                    Connex::EQ_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(xor2, 0),
+                                    SDValue(vload2, 0),
+                                    SDValue(vload17, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub16, 1)
+                                    );
+
+// R01 = R30 - R01;
+// Instr #272
+SDNode *sub17 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(eq38, 0),
+                                    SDValue(eq38, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq38, 1)
+                                    );
+
+// R00 = R04 | R02;
+// Instr #273
+SDNode *or15 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub16, 0),
+                                    SDValue(and35, 0),
+                                    SDValue(vload18, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub17, 1)
+                                    );
+
+// R00 = R00 | R01;
+// Instr #274
+SDNode *or16 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub17, 0),
+                                    SDValue(or15, 0),
+                                    SDValue(or15, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or15, 1)
+                                    );
+
+// R00 = R00 & R03;
+// Instr #275
+SDNode *and38 = CurDAG->getMachineNode(
+                                    Connex::ANDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub15, 0),
+                                    SDValue(or16, 0),
+                                    SDValue(or16, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or16, 1)
+                                    );
+
+// R19 = R00 + R19;
+// Instr #276
+SDNode *add2 = CurDAG->getMachineNode(
+                                    Connex::ADDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or14, 0),
+                                    SDValue(and38, 0),
+                                    SDValue(or14, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and38, 1)
+                                    );
+
+// R19 = R19 | R24;
+// Instr #277
+SDNode *resF16 /*or17*/ = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and26, 0),
+                                    SDValue(add2, 0),
+                                    SDValue(add2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(add2, 1)
+                                    );
+
+// END_WHERE;
+// Instr #278
+SDNode *lastNode /*endwhere21*/ = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+// Alex:                                    MVT::Glue,
+                                    MVT::Other,
+                                    // glue (or chain) input edge
+// Alex:                                    SDValue(or17, 1)
+                                    SDValue(resF16, 1)
+                                    );
+

lib/Target/Connex/Select_ADDi32_OpincaaCodeGen.cpp

+// From /home/asusu/LLVM/llvm38Nov2016/llvm/build40/bin/Tests/NEW_v128i16/opincaa_standalone_apps/Emulate_i32/ADD_i32_manual/DumpISel_OpincaaCodeGen_old05_011.cpp
+
+// R27 is REG_SRC1. It is represented by result of nodeOpSrcCast1.
+// R28 is REG_SRC2. It is represented by result of nodeOpSrcCast2.
+
+
+
+// Code auto-generated by method Kernel::genLLVMISelManualCode() 
+//   from Opincaa lib from kernel: simpleIoTest_allowOverwrite123456.
+// It is important to put this code in the Select() method of the
+//   SelectionDAGISel class of your back end, after the ISelLowering pass,
+//   which contains the DAG Combiner, because the DAG Combiner can remove
+//   the getCopyToReg() we create, which can lead to the following error:
+//   <<Register use before def!>> assertion failed.
+// Number of instructions generated: 15.
+
+
+
+
+SDValue ct0 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R31 = 0;
+// Instr #0
+SDNode *vload0 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct0,
+                                    // glue (or chain) input edge
+                                    SDValue(nodeOpSrcCast2, 1)
+                                    );
+
+SDValue ct1 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R30 = 1;
+// Instr #1
+SDNode *vload1 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct1,
+                                    // glue (or chain) input edge
+                                    SDValue(vload0, 1)
+                                    );
+
+// R29 = R27 + R28;
+// Instr #2
+SDNode *add0 = CurDAG->getMachineNode(
+                                    Connex::ADDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(nodeOpSrcCast2, 0),
+                                    SDValue(nodeOpSrcCast1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload1, 1)
+                                    );
+
+// R23 = ADDC(R31, R31);
+// Instr #3
+SDNode *addc0 = CurDAG->getMachineNode(
+                                    Connex::ADDCV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload0, 0),
+                                    SDValue(vload0, 0),
+                                    SDValue(add0, 0)
+                                    // no need for glue or chain input (since it normally consumes the output of the predecessor)
+                                    );
+
+// R26 = INDEX;
+// Instr #4
+SDNode *ldix0 = CurDAG->getMachineNode(
+                                    Connex::LDIX_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(addc0, 1)
+                                    );
+
+// R25 = R26 & R30;
+// Instr #5
+SDNode *and0 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(ldix0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ldix0, 1)
+                                    );
+
+// R24 = R25 == R30;
+// Instr #6
+SDNode *eq0 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and0, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and0, 1)
+                                    );
+
+SDValue ct2 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #7
+SDNode *nop0 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct2,
+                                    // glue (or chain) input edge
+                                    SDValue(eq0, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #8
+SDNode *whereeq0 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop0, 0)
+                                    );
+
+SDValue ct3 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R23 = 0;
+// Instr #9
+SDNode *vload2 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct3,
+                                    SDValue(addc0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq0, 1)
+                                    );
+
+// END_WHERE;
+// Instr #10
+SDNode *endwhere0 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload2, 1)
+                                    );
+
+// CELL_SHR(R23, R30);
+// Instr #11
+SDNode *cellshr0 = CurDAG->getMachineNode(
+                                    Connex::CELLSHR_H,
+                                    DL,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere0, 0)
+                                    );
+
+SDValue ct4 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #12
+SDNode *nop1 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct4,
+                                    // glue (or chain) input edge
+                                    SDValue(cellshr0, 0)
+                                    );
+
+// R21 = SHIFT_REG;
+// Instr #13
+SDNode *ldsh0 = CurDAG->getMachineNode(
+                                    Connex::LDSH_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(nop1, 0)
+                                    );
+
+// R22 = R21 + R29;
+// Instr #14
+SDNode *resH /*add1*/ = CurDAG->getMachineNode(
+                                    Connex::ADDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(add0, 0),
+                                    SDValue(ldsh0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ldsh0, 1)
+                                    );
+
+SDNode *lastNode = resH;

lib/Target/Connex/Select_MULTf16_OpincaaCodeGen.cpp

+// From /home/asusu/LLVM/Tests/opincaa_standalone_apps/Emulate_f16/MULTf16_manual/DumpISel_OpincaaCodeGen.cpp
+
+// Code auto-generated by method Kernel::genLLVMISelManualCode() 
+//   from Opincaa lib from kernel: mul.f16.
+// It is important to put this code in the Select() method of the
+//   SelectionDAGISel class of your back end, after the ISelLowering pass,
+//   which contains the DAG Combiner, because the DAG Combiner can remove
+//   the getCopyToReg() we create, which can lead to the following error:
+//   <<Register use before def!>> assertion failed.
+// Number of instructions generated: 249.
+
+
+
+
+SDValue ct0 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R31 = 0;
+// Instr #0
+SDNode *vload0 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct0,
+                                    // glue (or chain) input edge
+                                    SDValue(nodeOpSrcCast1, 1)
+                                    );
+
+SDValue ct1 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R30 = 1;
+// Instr #1
+SDNode *vload1 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct1,
+                                    // glue (or chain) input edge
+                                    SDValue(vload0, 1)
+                                    );
+
+SDValue ct2 = CurDAG->getConstant(16, DL, MVT::i16, true, false);
+// R29 = 16;
+// Instr #2
+SDNode *vload2 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct2,
+                                    // glue (or chain) input edge
+                                    SDValue(vload1, 1)
+                                    );
+
+SDValue ct3 = CurDAG->getConstant(31, DL, MVT::i16, true, false);
+// R28 = 31;
+// Instr #3
+SDNode *vload3 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct3,
+                                    // glue (or chain) input edge
+                                    SDValue(vload2, 1)
+                                    );
+
+SDValue ct4 = CurDAG->getConstant(1023, DL, MVT::i16, true, false);
+// R10 = 1023;
+// Instr #4
+SDNode *vload4 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct4,
+                                    // glue (or chain) input edge
+                                    SDValue(vload3, 1)
+                                    );
+
+SDValue ct5 = CurDAG->getConstant(31744, DL, MVT::i16, true, false);
+// R09 = 31744;
+// Instr #5
+SDNode *vload5 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct5,
+                                    // glue (or chain) input edge
+                                    SDValue(vload4, 1)
+                                    );
+
+SDValue ct6 = CurDAG->getConstant(-32768, DL, MVT::i16, true, false);
+// R08 = -32768;
+// Instr #6
+SDNode *vload6 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct6,
+                                    // glue (or chain) input edge
+                                    SDValue(vload5, 1)
+                                    );
+
+SDValue ct7 = CurDAG->getConstant(1024, DL, MVT::i16, true, false);
+// R07 = 1024;
+// Instr #7
+SDNode *vload7 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct7,
+                                    // glue (or chain) input edge
+                                    SDValue(vload6, 1)
+                                    );
+
+SDValue ct8 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R55 = 0;
+// Instr #8
+SDNode *vload8 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct8,
+                                    // glue (or chain) input edge
+                                    SDValue(vload7, 1)
+                                    );
+
+SDValue ct9 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R00 = 1;
+// Instr #9
+SDNode *vload9 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct9,
+                                    // glue (or chain) input edge
+                                    SDValue(vload8, 1)
+                                    );
+
+// R24 = R27 & R08;
+// Instr #10
+SDNode *and0 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload6, 0),
+                                    SDValue(nodeOpSrcCast1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload9, 1)
+                                    );
+
+// R25 = R27 & R09;
+// Instr #11
+SDNode *and1 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload5, 0),
+                                    SDValue(nodeOpSrcCast1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and0, 1)
+                                    );
+
+SDValue ct10 = CurDAG->getConstant(10, DL, MVT::i16, true, false);
+// R25 = R25 >> 10;
+// Instr #12
+SDNode *ishr0 = CurDAG->getMachineNode(
+                                    Connex::ISHRV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and1, 0),
+                                    ct10,
+                                    // glue (or chain) input edge
+                                    SDValue(and1, 1)
+                                    );
+
+// R26 = R27 & R10;
+// Instr #13
+SDNode *and2 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload4, 0),
+                                    SDValue(nodeOpSrcCast1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishr0, 1)
+                                    );
+
+// R14 = R31 < R26;
+// Instr #14
+SDNode *lt0 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload0, 0),
+                                    SDValue(and2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and2, 1)
+                                    );
+
+// R13 = R25 == R31;
+// Instr #15
+SDNode *eq0 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishr0, 0),
+                                    SDValue(vload0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt0, 1)
+                                    );
+
+// R12 = R13 & R14;
+// Instr #16
+SDNode *and3 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(lt0, 0),
+                                    SDValue(eq0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq0, 1)
+                                    );
+
+// R12 = R12 == R30;
+// Instr #17
+SDNode *eq1 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and3, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and3, 1)
+                                    );
+
+SDValue ct11 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #18
+SDNode *nop0 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct11,
+                                    // glue (or chain) input edge
+                                    SDValue(eq1, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #19
+SDNode *whereeq0 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop0, 0)
+                                    );
+
+SDValue ct12 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R25 = 1;
+// Instr #20
+SDNode *vload10 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct12,
+                                    SDValue(ishr0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq0, 1)
+                                    );
+
+// END_WHERE;
+// Instr #21
+SDNode *endwhere0 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload10, 1)
+                                    );
+
+// R14 = R25 == R28;
+// Instr #22
+SDNode *eq2 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload10, 0),
+                                    SDValue(vload3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere0, 0)
+                                    );
+
+// R14 = R14 | R13;
+// Instr #23
+SDNode *or0 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq0, 0),
+                                    SDValue(eq2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq2, 1)
+                                    );
+
+// R14 = R14 == R31;
+// Instr #24
+SDNode *eq3 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or0, 0),
+                                    SDValue(vload0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or0, 1)
+                                    );
+
+SDValue ct13 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #25
+SDNode *nop1 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct13,
+                                    // glue (or chain) input edge
+                                    SDValue(eq3, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #26
+SDNode *whereeq1 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop1, 0)
+                                    );
+
+// R26 = R26 | R07;
+// Instr #27
+SDNode *or1 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload7, 0),
+                                    SDValue(and2, 0),
+                                    SDValue(and2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq1, 1)
+                                    );
+
+// END_WHERE;
+// Instr #28
+SDNode *endwhere1 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(or1, 1)
+                                    );
+
+// R20 = R23 & R08;
+// Instr #29
+SDNode *and4 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload6, 0),
+                                    SDValue(nodeOpSrcCast2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere1, 0)
+                                    );
+
+// R21 = R23 & R09;
+// Instr #30
+SDNode *and5 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload5, 0),
+                                    SDValue(nodeOpSrcCast2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and4, 1)
+                                    );
+
+SDValue ct14 = CurDAG->getConstant(10, DL, MVT::i16, true, false);
+// R21 = R21 >> 10;
+// Instr #31
+SDNode *ishr1 = CurDAG->getMachineNode(
+                                    Connex::ISHRV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and5, 0),
+                                    ct14,
+                                    // glue (or chain) input edge
+                                    SDValue(and5, 1)
+                                    );
+
+// R22 = R23 & R10;
+// Instr #32
+SDNode *and6 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload4, 0),
+                                    SDValue(nodeOpSrcCast2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishr1, 1)
+                                    );
+
+// R14 = R31 < R22;
+// Instr #33
+SDNode *lt1 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload0, 0),
+                                    SDValue(and6, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and6, 1)
+                                    );
+
+// R13 = R21 == R31;
+// Instr #34
+SDNode *eq4 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishr1, 0),
+                                    SDValue(vload0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt1, 1)
+                                    );
+
+// R12 = R13 & R14;
+// Instr #35
+SDNode *and7 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(lt1, 0),
+                                    SDValue(eq4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq4, 1)
+                                    );
+
+// R12 = R12 == R30;
+// Instr #36
+SDNode *eq5 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and7, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and7, 1)
+                                    );
+
+SDValue ct15 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #37
+SDNode *nop2 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct15,
+                                    // glue (or chain) input edge
+                                    SDValue(eq5, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #38
+SDNode *whereeq2 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq5, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop2, 0)
+                                    );
+
+SDValue ct16 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R21 = 1;
+// Instr #39
+SDNode *vload11 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct16,
+                                    SDValue(ishr1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq2, 1)
+                                    );
+
+// END_WHERE;
+// Instr #40
+SDNode *endwhere2 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload11, 1)
+                                    );
+
+// R14 = R21 == R28;
+// Instr #41
+SDNode *eq6 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload11, 0),
+                                    SDValue(vload3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere2, 0)
+                                    );
+
+// R14 = R14 | R13;
+// Instr #42
+SDNode *or2 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq4, 0),
+                                    SDValue(eq6, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq6, 1)
+                                    );
+
+// R14 = R14 == R31;
+// Instr #43
+SDNode *eq7 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or2, 0),
+                                    SDValue(vload0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or2, 1)
+                                    );
+
+SDValue ct17 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #44
+SDNode *nop3 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct17,
+                                    // glue (or chain) input edge
+                                    SDValue(eq7, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #45
+SDNode *whereeq3 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop3, 0)
+                                    );
+
+// R22 = R22 | R07;
+// Instr #46
+SDNode *or3 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload7, 0),
+                                    SDValue(and6, 0),
+                                    SDValue(and6, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq3, 1)
+                                    );
+
+// END_WHERE;
+// Instr #47
+SDNode *endwhere3 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(or3, 1)
+                                    );
+
+SDValue ct18 = CurDAG->getConstant(31744, DL, MVT::i16, true, false);
+// R19 = 31744;
+// Instr #48
+SDNode *vload12 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct18,
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere3, 0)
+                                    );
+
+// R15 = R24 ^ R20;
+// Instr #49
+SDNode *xor0 = CurDAG->getMachineNode(
+                                    Connex::XORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and4, 0),
+                                    SDValue(and0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload12, 1)
+                                    );
+
+SDValue ct19 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R16 = 0;
+// Instr #50
+SDNode *vload13 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct19,
+                                    // glue (or chain) input edge
+                                    SDValue(xor0, 1)
+                                    );
+
+SDValue ct20 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R18 = 0;
+// Instr #51
+SDNode *vload14 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct20,
+                                    // glue (or chain) input edge
+                                    SDValue(vload13, 1)
+                                    );
+
+SDValue ct21 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R17 = 0;
+// Instr #52
+SDNode *vload15 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct21,
+                                    // glue (or chain) input edge
+                                    SDValue(vload14, 1)
+                                    );
+
+SDValue ct22 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R54 = 0;
+// Instr #53
+SDNode *vload16 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct22,
+                                    // glue (or chain) input edge
+                                    SDValue(vload15, 1)
+                                    );
+
+SDValue ct23 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R60 = 0;
+// Instr #54
+SDNode *vload17 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct23,
+                                    // glue (or chain) input edge
+                                    SDValue(vload16, 1)
+                                    );
+
+SDValue ct24 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R59 = 0;
+// Instr #55
+SDNode *vload18 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct24,
+                                    // glue (or chain) input edge
+                                    SDValue(vload17, 1)
+                                    );
+
+SDValue ct25 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R58 = 0;
+// Instr #56
+SDNode *vload19 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct25,
+                                    // glue (or chain) input edge
+                                    SDValue(vload18, 1)
+                                    );
+
+SDValue ct26 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R57 = 0;
+// Instr #57
+SDNode *vload20 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct26,
+                                    // glue (or chain) input edge
+                                    SDValue(vload19, 1)
+                                    );
+
+// R02 = R27 == R24;
+// Instr #58
+SDNode *eq8 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(nodeOpSrcCast1, 0),
+                                    SDValue(and0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload20, 1)
+                                    );
+
+// R01 = R23 == R20;
+// Instr #59
+SDNode *eq9 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(nodeOpSrcCast2, 0),
+                                    SDValue(and4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq8, 1)
+                                    );
+
+// R36 = R25 == R28;
+// Instr #60
+SDNode *eq10 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload10, 0),
+                                    SDValue(vload3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq9, 1)
+                                    );
+
+// R38 = R31 < R26;
+// Instr #61
+SDNode *lt2 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload0, 0),
+                                    SDValue(or1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq10, 1)
+                                    );
+
+// R35 = R21 == R28;
+// Instr #62
+SDNode *eq11 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload11, 0),
+                                    SDValue(vload3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt2, 1)
+                                    );
+
+// R37 = R31 < R22;
+// Instr #63
+SDNode *lt3 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload0, 0),
+                                    SDValue(or3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq11, 1)
+                                    );
+
+// R62 = R36 & R38;
+// Instr #64
+SDNode *and8 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(lt2, 0),
+                                    SDValue(eq10, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt3, 1)
+                                    );
+
+// R63 = R35 & R37;
+// Instr #65
+SDNode *and9 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(lt3, 0),
+                                    SDValue(eq11, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and8, 1)
+                                    );
+
+// R61 = R62 | R63;
+// Instr #66
+SDNode *or4 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and9, 0),
+                                    SDValue(and8, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and9, 1)
+                                    );
+
+// R62 = R36 & R01;
+// Instr #67
+SDNode *and10 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq9, 0),
+                                    SDValue(eq10, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or4, 1)
+                                    );
+
+// R63 = R35 & R02;
+// Instr #68
+SDNode *and11 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq8, 0),
+                                    SDValue(eq11, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and10, 1)
+                                    );
+
+// R61 = R61 | R62;
+// Instr #69
+SDNode *or5 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and10, 0),
+                                    SDValue(or4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and11, 1)
+                                    );
+
+// R61 = R61 | R63;
+// Instr #70
+SDNode *or6 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and11, 0),
+                                    SDValue(or5, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or5, 1)
+                                    );
+
+// R03 = R61 == R30;
+// Instr #71
+SDNode *eq12 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or6, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or6, 1)
+                                    );
+
+SDValue ct27 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #72
+SDNode *nop4 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct27,
+                                    // glue (or chain) input edge
+                                    SDValue(eq12, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #73
+SDNode *whereeq4 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq12, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop4, 0)
+                                    );
+
+SDValue ct28 = CurDAG->getConstant(31745, DL, MVT::i16, true, false);
+// R19 = 31745;
+// Instr #74
+SDNode *vload21 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct28,
+                                    SDValue(vload12, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq4, 1)
+                                    );
+
+SDValue ct29 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R00 = 0;
+// Instr #75
+SDNode *vload22 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct29,
+                                    SDValue(vload9, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload21, 1)
+                                    );
+
+// END_WHERE;
+// Instr #76
+SDNode *endwhere4 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload22, 1)
+                                    );
+
+// R39 = R36 | R35;
+// Instr #77
+SDNode *or7 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq11, 0),
+                                    SDValue(eq10, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere4, 0)
+                                    );
+
+// R04 = R61 == R31;
+// Instr #78
+SDNode *eq13 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or6, 0),
+                                    SDValue(vload0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or7, 1)
+                                    );
+
+// R03 = R39 == R30;
+// Instr #79
+SDNode *eq14 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or7, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq13, 1)
+                                    );
+
+// R03 = R03 & R04;
+// Instr #80
+SDNode *and12 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq13, 0),
+                                    SDValue(eq14, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq14, 1)
+                                    );
+
+// R03 = R03 == R30;
+// Instr #81
+SDNode *eq15 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and12, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and12, 1)
+                                    );
+
+SDValue ct30 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #82
+SDNode *nop5 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct30,
+                                    // glue (or chain) input edge
+                                    SDValue(eq15, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #83
+SDNode *whereeq5 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq15, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop5, 0)
+                                    );
+
+// R19 = R19 | R15;
+// Instr #84
+SDNode *or8 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(xor0, 0),
+                                    SDValue(vload21, 0),
+                                    SDValue(vload21, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq5, 1)
+                                    );
+
+SDValue ct31 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R00 = 0;
+// Instr #85
+SDNode *vload23 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct31,
+                                    SDValue(vload22, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or8, 1)
+                                    );
+
+// END_WHERE;
+// Instr #86
+SDNode *endwhere5 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload23, 1)
+                                    );
+
+// R52 = R00 == R30;
+// Instr #87
+SDNode *eq16 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload23, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere5, 0)
+                                    );
+
+SDValue ct32 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #88
+SDNode *nop6 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct32,
+                                    // glue (or chain) input edge
+                                    SDValue(eq16, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #89
+SDNode *whereeq6 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq16, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop6, 0)
+                                    );
+
+// R16 = R21 + R25;
+// Instr #90
+SDNode *add0 = CurDAG->getMachineNode(
+                                    Connex::ADDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload10, 0),
+                                    SDValue(vload11, 0),
+                                    SDValue(vload13, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq6, 1)
+                                    );
+
+SDValue ct33 = CurDAG->getConstant(15, DL, MVT::i16, true, false);
+// R04 = 15;
+// Instr #91
+SDNode *vload24 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct33,
+                                    SDValue(eq13, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(add0, 1)
+                                    );
+
+// R16 = R16 - R04;
+// Instr #92
+SDNode *sub0 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(add0, 0),
+                                    SDValue(vload24, 0),
+                                    SDValue(add0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload24, 1)
+                                    );
+
+// R26 * R22;
+// Instr #93
+SDNode *mult0 = CurDAG->getMachineNode(
+                                    Connex::MULT_H,
+                                    DL,
+                                    MVT::Glue,
+                                    SDValue(or1, 0),
+                                    SDValue(or3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub0, 1)
+                                    );
+
+// R18 = MULT_LOW();
+// Instr #94
+SDNode *multlo0 = CurDAG->getMachineNode(
+                                    Connex::MULTLO_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload14, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(mult0, 0)
+                                    );
+
+// R17 = MULT_HIGH();
+// Instr #95
+SDNode *multhi0 = CurDAG->getMachineNode(
+                                    Connex::MULTHI_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload15, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(multlo0, 1)
+                                    );
+
+// END_WHERE;
+// Instr #96
+SDNode *endwhere6 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(multhi0, 1)
+                                    );
+
+SDValue ct34 = CurDAG->getConstant(16, DL, MVT::i16, true, false);
+// R03 = 16;
+// Instr #97
+SDNode *vload25 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct34,
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere6, 0)
+                                    );
+
+SDValue ct35 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R06 = R18 << 0;
+// Instr #98
+SDNode *ishl0 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(multlo0, 0),
+                                    ct35,
+                                    // glue (or chain) input edge
+                                    SDValue(vload25, 1)
+                                    );
+
+// R04 = R31 < R17;
+// Instr #99
+SDNode *lt4 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload0, 0),
+                                    SDValue(multhi0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl0, 1)
+                                    );
+
+// R52 = R04 & R00;
+// Instr #100
+SDNode *and13 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload23, 0),
+                                    SDValue(lt4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt4, 1)
+                                    );
+
+// R52 = R52 == R30;
+// Instr #101
+SDNode *eq17 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and13, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and13, 1)
+                                    );
+
+SDValue ct36 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #102
+SDNode *nop7 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct36,
+                                    // glue (or chain) input edge
+                                    SDValue(eq17, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #103
+SDNode *whereeq7 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq17, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop7, 0)
+                                    );
+
+SDValue ct37 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R06 = R17 << 0;
+// Instr #104
+SDNode *ishl1 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(multhi0, 0),
+                                    ct37,
+                                    SDValue(ishl0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq7, 1)
+                                    );
+
+SDValue ct38 = CurDAG->getConstant(32, DL, MVT::i16, true, false);
+// R03 = 32;
+// Instr #105
+SDNode *vload26 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct38,
+                                    SDValue(vload25, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl1, 1)
+                                    );
+
+// END_WHERE;
+// Instr #106
+SDNode *endwhere7 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload26, 1)
+                                    );
+
+SDValue ct39 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R04 = R06 >> 1;
+// Instr #107
+SDNode *ishr2 = CurDAG->getMachineNode(
+                                    Connex::ISHRV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishl1, 0),
+                                    ct39,
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere7, 0)
+                                    );
+
+// R06 = R06 | R04;
+// Instr #108
+SDNode *or9 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishr2, 0),
+                                    SDValue(ishl1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishr2, 1)
+                                    );
+
+SDValue ct40 = CurDAG->getConstant(2, DL, MVT::i16, true, false);
+// R04 = R06 >> 2;
+// Instr #109
+SDNode *ishr3 = CurDAG->getMachineNode(
+                                    Connex::ISHRV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or9, 0),
+                                    ct40,
+                                    // glue (or chain) input edge
+                                    SDValue(or9, 1)
+                                    );
+
+// R06 = R06 | R04;
+// Instr #110
+SDNode *or10 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishr3, 0),
+                                    SDValue(or9, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishr3, 1)
+                                    );
+
+SDValue ct41 = CurDAG->getConstant(4, DL, MVT::i16, true, false);
+// R04 = R06 >> 4;
+// Instr #111
+SDNode *ishr4 = CurDAG->getMachineNode(
+                                    Connex::ISHRV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or10, 0),
+                                    ct41,
+                                    // glue (or chain) input edge
+                                    SDValue(or10, 1)
+                                    );
+
+// R06 = R06 | R04;
+// Instr #112
+SDNode *or11 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishr4, 0),
+                                    SDValue(or10, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishr4, 1)
+                                    );
+
+SDValue ct42 = CurDAG->getConstant(8, DL, MVT::i16, true, false);
+// R04 = R06 >> 8;
+// Instr #113
+SDNode *ishr5 = CurDAG->getMachineNode(
+                                    Connex::ISHRV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or11, 0),
+                                    ct42,
+                                    // glue (or chain) input edge
+                                    SDValue(or11, 1)
+                                    );
+
+// R06 = R06 | R04;
+// Instr #114
+SDNode *or12 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishr5, 0),
+                                    SDValue(or11, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishr5, 1)
+                                    );
+
+// R06 = ~R06;
+// Instr #115
+SDNode *not0 = CurDAG->getMachineNode(
+                                    Connex::NOT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or12, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or12, 1)
+                                    );
+
+// R05 = POPCNT(R06);
+// Instr #116
+SDNode *popcnt0 = CurDAG->getMachineNode(
+                                    Connex::POPCNT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(not0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(not0, 1)
+                                    );
+
+// R05 = R03 - R05;
+// Instr #117
+SDNode *sub1 = CurDAG->getMachineNode(
+                                    Connex::SUBV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload26, 0),
+                                    SDValue(popcnt0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(popcnt0, 1)
+                                    );
+
+SDValue ct43 = CurDAG->getConstant(11, DL, MVT::i16, true, false);
+// R04 = 11;
+// Instr #118
+SDNode *vload27 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct43,
+                                    // glue (or chain) input edge
+                                    SDValue(sub1, 1)
+                                    );
+
+// R04 = R05 - R04;
+// Instr #119
+SDNode *sub2 = CurDAG->getMachineNode(
+                                    Connex::SUBV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub1, 0),
+                                    SDValue(vload27, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload27, 1)
+                                    );
+
+// R12 = R04 < R31;
+// Instr #120
+SDNode *lt5 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub2, 0),
+                                    SDValue(vload0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub2, 1)
+                                    );
+
+// R52 = R12 & R00;
+// Instr #121
+SDNode *and14 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload23, 0),
+                                    SDValue(lt5, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt5, 1)
+                                    );
+
+// R52 = R52 == R30;
+// Instr #122
+SDNode *eq18 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and14, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and14, 1)
+                                    );
+
+SDValue ct44 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #123
+SDNode *nop8 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct44,
+                                    // glue (or chain) input edge
+                                    SDValue(eq18, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #124
+SDNode *whereeq8 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq18, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop8, 0)
+                                    );
+
+// R03 = R31 - R04;
+// Instr #125
+SDNode *sub3 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload0, 0),
+                                    SDValue(sub2, 0),
+                                    SDValue(vload26, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq8, 1)
+                                    );
+
+// R18 = R18 << R03;
+// Instr #126
+SDNode *shl0 = CurDAG->getMachineNode(
+                                    Connex::SHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(multlo0, 0),
+                                    SDValue(sub3, 0),
+                                    SDValue(multlo0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub3, 1)
+                                    );
+
+// END_WHERE;
+// Instr #127
+SDNode *endwhere8 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(shl0, 1)
+                                    );
+
+// R12 = R31 < R04;
+// Instr #128
+SDNode *lt6 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload0, 0),
+                                    SDValue(sub2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere8, 0)
+                                    );
+
+// R52 = R12 & R00;
+// Instr #129
+SDNode *and15 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload23, 0),
+                                    SDValue(lt6, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt6, 1)
+                                    );
+
+// R52 = R52 == R30;
+// Instr #130
+SDNode *eq19 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and15, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and15, 1)
+                                    );
+
+SDValue ct45 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #131
+SDNode *nop9 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct45,
+                                    // glue (or chain) input edge
+                                    SDValue(eq19, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #132
+SDNode *whereeq9 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq19, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop9, 0)
+                                    );
+
+SDValue ct46 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R03 = R17 << 0;
+// Instr #133
+SDNode *ishl2 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(multhi0, 0),
+                                    ct46,
+                                    SDValue(sub3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq9, 1)
+                                    );
+
+// R17 = R17 >> R04;
+// Instr #134
+SDNode *shr0 = CurDAG->getMachineNode(
+                                    Connex::SHRV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(multhi0, 0),
+                                    SDValue(sub2, 0),
+                                    SDValue(multhi0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl2, 1)
+                                    );
+
+SDValue ct47 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R12 = R04 << 0;
+// Instr #135
+SDNode *ishl3 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub2, 0),
+                                    ct47,
+                                    SDValue(lt6, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shr0, 1)
+                                    );
+
+// R04 = R29 - R04;
+// Instr #136
+SDNode *sub4 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(sub2, 0),
+                                    SDValue(sub2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl3, 1)
+                                    );
+
+SDValue ct48 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R55 = R18 << 0;
+// Instr #137
+SDNode *ishl4 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl0, 0),
+                                    ct48,
+                                    SDValue(vload8, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub4, 1)
+                                    );
+
+// R55 = R55 << R04;
+// Instr #138
+SDNode *shl1 = CurDAG->getMachineNode(
+                                    Connex::SHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishl4, 0),
+                                    SDValue(sub4, 0),
+                                    SDValue(ishl4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl4, 1)
+                                    );
+
+// R55 = R55 >> R04;
+// Instr #139
+SDNode *shr1 = CurDAG->getMachineNode(
+                                    Connex::SHRV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl1, 0),
+                                    SDValue(sub4, 0),
+                                    SDValue(shl1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shl1, 1)
+                                    );
+
+SDValue ct49 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R54 = R12 << 0;
+// Instr #140
+SDNode *ishl5 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishl3, 0),
+                                    ct49,
+                                    SDValue(vload16, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shr1, 1)
+                                    );
+
+// R18 = R18 >> R12;
+// Instr #141
+SDNode *shr2 = CurDAG->getMachineNode(
+                                    Connex::SHRV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl0, 0),
+                                    SDValue(ishl3, 0),
+                                    SDValue(shl0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl5, 1)
+                                    );
+
+// R03 = R03 << R04;
+// Instr #142
+SDNode *shl2 = CurDAG->getMachineNode(
+                                    Connex::SHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishl2, 0),
+                                    SDValue(sub4, 0),
+                                    SDValue(ishl2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shr2, 1)
+                                    );
+
+// R18 = R18 | R03;
+// Instr #143
+SDNode *or13 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl2, 0),
+                                    SDValue(shr2, 0),
+                                    SDValue(shr2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shl2, 1)
+                                    );
+
+// END_WHERE;
+// Instr #144
+SDNode *endwhere9 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(or13, 1)
+                                    );
+
+// R52 = R00 == R30;
+// Instr #145
+SDNode *eq20 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload23, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere9, 0)
+                                    );
+
+SDValue ct50 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #146
+SDNode *nop10 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct50,
+                                    // glue (or chain) input edge
+                                    SDValue(eq20, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #147
+SDNode *whereeq10 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq20, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop10, 0)
+                                    );
+
+SDValue ct51 = CurDAG->getConstant(21, DL, MVT::i16, true, false);
+// R04 = 21;
+// Instr #148
+SDNode *vload28 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct51,
+                                    SDValue(sub4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq10, 1)
+                                    );
+
+// R04 = R04 - R05;
+// Instr #149
+SDNode *sub5 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload28, 0),
+                                    SDValue(sub1, 0),
+                                    SDValue(vload28, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload28, 1)
+                                    );
+
+// R16 = R16 - R04;
+// Instr #150
+SDNode *sub6 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub0, 0),
+                                    SDValue(sub5, 0),
+                                    SDValue(sub0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub5, 1)
+                                    );
+
+// END_WHERE;
+// Instr #151
+SDNode *endwhere10 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(sub6, 1)
+                                    );
+
+SDValue ct52 = CurDAG->getConstant(15, DL, MVT::i16, true, false);
+// R03 = 15;
+// Instr #152
+SDNode *vload29 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct52,
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere10, 0)
+                                    );
+
+// R04 = R30 - R16;
+// Instr #153
+SDNode *sub7 = CurDAG->getMachineNode(
+                                    Connex::SUBV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(sub6, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload29, 1)
+                                    );
+
+// R12 = R03 < R04;
+// Instr #154
+SDNode *lt7 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload29, 0),
+                                    SDValue(sub7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub7, 1)
+                                    );
+
+// R52 = R12 & R00;
+// Instr #155
+SDNode *and16 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload23, 0),
+                                    SDValue(lt7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt7, 1)
+                                    );
+
+// R52 = R52 == R30;
+// Instr #156
+SDNode *eq21 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and16, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and16, 1)
+                                    );
+
+SDValue ct53 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #157
+SDNode *nop11 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct53,
+                                    // glue (or chain) input edge
+                                    SDValue(eq21, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #158
+SDNode *whereeq11 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq21, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop11, 0)
+                                    );
+
+// R54 = R55 == R31;
+// Instr #159
+SDNode *eq22 = CurDAG->getMachineNode(
+                                    Connex::EQ_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shr1, 0),
+                                    SDValue(vload0, 0),
+                                    SDValue(ishl5, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq11, 1)
+                                    );
+
+// R54 = R30 - R54;
+// Instr #160
+SDNode *sub8 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(eq22, 0),
+                                    SDValue(eq22, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq22, 1)
+                                    );
+
+SDValue ct54 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R55 = R18 << 0;
+// Instr #161
+SDNode *ishl6 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or13, 0),
+                                    ct54,
+                                    SDValue(shr1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub8, 1)
+                                    );
+
+// R55 = R55 | R54;
+// Instr #162
+SDNode *or14 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub8, 0),
+                                    SDValue(ishl6, 0),
+                                    SDValue(ishl6, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl6, 1)
+                                    );
+
+SDValue ct55 = CurDAG->getConstant(16, DL, MVT::i16, true, false);
+// R54 = 16;
+// Instr #163
+SDNode *vload30 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct55,
+                                    SDValue(sub8, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or14, 1)
+                                    );
+
+SDValue ct56 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R18 = R17 << 0;
+// Instr #164
+SDNode *ishl7 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shr0, 0),
+                                    ct56,
+                                    SDValue(or13, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload30, 1)
+                                    );
+
+SDValue ct57 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R17 = 0;
+// Instr #165
+SDNode *vload31 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct57,
+                                    SDValue(shr0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl7, 1)
+                                    );
+
+// R04 = R04 - R29;
+// Instr #166
+SDNode *sub9 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub7, 0),
+                                    SDValue(vload2, 0),
+                                    SDValue(sub7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload31, 1)
+                                    );
+
+// R16 = R29 + R16;
+// Instr #167
+SDNode *add1 = CurDAG->getMachineNode(
+                                    Connex::ADDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub6, 0),
+                                    SDValue(vload2, 0),
+                                    SDValue(sub6, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub9, 1)
+                                    );
+
+// END_WHERE;
+// Instr #168
+SDNode *endwhere11 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(add1, 1)
+                                    );
+
+// R12 = R03 < R04;
+// Instr #169
+SDNode *lt8 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload29, 0),
+                                    SDValue(sub9, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere11, 0)
+                                    );
+
+// R52 = R12 & R00;
+// Instr #170
+SDNode *and17 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload23, 0),
+                                    SDValue(lt8, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt8, 1)
+                                    );
+
+// R52 = R52 == R30;
+// Instr #171
+SDNode *eq23 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and17, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and17, 1)
+                                    );
+
+SDValue ct58 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #172
+SDNode *nop12 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct58,
+                                    // glue (or chain) input edge
+                                    SDValue(eq23, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #173
+SDNode *whereeq12 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq23, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop12, 0)
+                                    );
+
+// R54 = R55 == R31;
+// Instr #174
+SDNode *eq24 = CurDAG->getMachineNode(
+                                    Connex::EQ_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or14, 0),
+                                    SDValue(vload0, 0),
+                                    SDValue(vload30, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq12, 1)
+                                    );
+
+// R54 = R30 - R54;
+// Instr #175
+SDNode *sub10 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(eq24, 0),
+                                    SDValue(eq24, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq24, 1)
+                                    );
+
+SDValue ct59 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R55 = R18 << 0;
+// Instr #176
+SDNode *ishl8 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishl7, 0),
+                                    ct59,
+                                    SDValue(or14, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub10, 1)
+                                    );
+
+// R55 = R55 | R54;
+// Instr #177
+SDNode *or15 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub10, 0),
+                                    SDValue(ishl8, 0),
+                                    SDValue(ishl8, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl8, 1)
+                                    );
+
+SDValue ct60 = CurDAG->getConstant(16, DL, MVT::i16, true, false);
+// R54 = 16;
+// Instr #178
+SDNode *vload32 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct60,
+                                    SDValue(sub10, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or15, 1)
+                                    );
+
+SDValue ct61 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R18 = 0;
+// Instr #179
+SDNode *vload33 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct61,
+                                    SDValue(ishl7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload32, 1)
+                                    );
+
+// R04 = R04 - R29;
+// Instr #180
+SDNode *sub11 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub9, 0),
+                                    SDValue(vload2, 0),
+                                    SDValue(sub9, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload33, 1)
+                                    );
+
+// R16 = R29 + R16;
+// Instr #181
+SDNode *add2 = CurDAG->getMachineNode(
+                                    Connex::ADDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(add1, 0),
+                                    SDValue(vload2, 0),
+                                    SDValue(add1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub11, 1)
+                                    );
+
+// END_WHERE;
+// Instr #182
+SDNode *endwhere12 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(add2, 1)
+                                    );
+
+// R12 = R16 < R30;
+// Instr #183
+SDNode *lt9 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(add2, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere12, 0)
+                                    );
+
+// R52 = R12 & R00;
+// Instr #184
+SDNode *and18 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload23, 0),
+                                    SDValue(lt9, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt9, 1)
+                                    );
+
+// R52 = R52 == R30;
+// Instr #185
+SDNode *eq25 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and18, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and18, 1)
+                                    );
+
+SDValue ct62 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #186
+SDNode *nop13 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct62,
+                                    // glue (or chain) input edge
+                                    SDValue(eq25, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #187
+SDNode *whereeq13 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq25, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop13, 0)
+                                    );
+
+// R04 = R30 - R16;
+// Instr #188
+SDNode *sub12 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(add2, 0),
+                                    SDValue(sub11, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq13, 1)
+                                    );
+
+// R54 = R55 == R31;
+// Instr #189
+SDNode *eq26 = CurDAG->getMachineNode(
+                                    Connex::EQ_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or15, 0),
+                                    SDValue(vload0, 0),
+                                    SDValue(vload32, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub12, 1)
+                                    );
+
+// R54 = R30 - R54;
+// Instr #190
+SDNode *sub13 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(eq26, 0),
+                                    SDValue(eq26, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq26, 1)
+                                    );
+
+SDValue ct63 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R55 = R18 << 0;
+// Instr #191
+SDNode *ishl9 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload33, 0),
+                                    ct63,
+                                    SDValue(or15, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub13, 1)
+                                    );
+
+// R55 = R55 | R54;
+// Instr #192
+SDNode *or16 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub13, 0),
+                                    SDValue(ishl9, 0),
+                                    SDValue(ishl9, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl9, 1)
+                                    );
+
+// R03 = R29 - R04;
+// Instr #193
+SDNode *sub14 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(sub12, 0),
+                                    SDValue(vload29, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or16, 1)
+                                    );
+
+// R55 = R55 << R03;
+// Instr #194
+SDNode *shl3 = CurDAG->getMachineNode(
+                                    Connex::SHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or16, 0),
+                                    SDValue(sub14, 0),
+                                    SDValue(or16, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub14, 1)
+                                    );
+
+// R55 = R55 >> R03;
+// Instr #195
+SDNode *shr3 = CurDAG->getMachineNode(
+                                    Connex::SHRV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl3, 0),
+                                    SDValue(sub14, 0),
+                                    SDValue(shl3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shl3, 1)
+                                    );
+
+SDValue ct64 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R54 = R04 << 0;
+// Instr #196
+SDNode *ishl10 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub12, 0),
+                                    ct64,
+                                    SDValue(sub13, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shr3, 1)
+                                    );
+
+// R18 = R18 >> R04;
+// Instr #197
+SDNode *shr4 = CurDAG->getMachineNode(
+                                    Connex::SHRV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload33, 0),
+                                    SDValue(sub12, 0),
+                                    SDValue(vload33, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl10, 1)
+                                    );
+
+SDValue ct65 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R03 = R17 << 0;
+// Instr #198
+SDNode *ishl11 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload31, 0),
+                                    ct65,
+                                    SDValue(sub14, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shr4, 1)
+                                    );
+
+// R17 = R17 >> R04;
+// Instr #199
+SDNode *shr5 = CurDAG->getMachineNode(
+                                    Connex::SHRV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload31, 0),
+                                    SDValue(sub12, 0),
+                                    SDValue(vload31, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl11, 1)
+                                    );
+
+// R04 = R29 - R04;
+// Instr #200
+SDNode *sub15 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(sub12, 0),
+                                    SDValue(sub12, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shr5, 1)
+                                    );
+
+// R03 = R03 << R04;
+// Instr #201
+SDNode *shl4 = CurDAG->getMachineNode(
+                                    Connex::SHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishl11, 0),
+                                    SDValue(sub15, 0),
+                                    SDValue(ishl11, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub15, 1)
+                                    );
+
+// R18 = R18 | R03;
+// Instr #202
+SDNode *or17 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl4, 0),
+                                    SDValue(shr4, 0),
+                                    SDValue(shr4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shl4, 1)
+                                    );
+
+SDValue ct66 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R16 = 1;
+// Instr #203
+SDNode *vload34 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct66,
+                                    SDValue(add2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or17, 1)
+                                    );
+
+// END_WHERE;
+// Instr #204
+SDNode *endwhere13 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload34, 1)
+                                    );
+
+SDValue ct67 = CurDAG->getConstant(30, DL, MVT::i16, true, false);
+// R12 = 30;
+// Instr #205
+SDNode *vload35 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct67,
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere13, 0)
+                                    );
+
+// R12 = R12 < R16;
+// Instr #206
+SDNode *lt10 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload35, 0),
+                                    SDValue(vload34, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload35, 1)
+                                    );
+
+// R52 = R12 & R00;
+// Instr #207
+SDNode *and19 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload23, 0),
+                                    SDValue(lt10, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt10, 1)
+                                    );
+
+// R52 = R52 == R30;
+// Instr #208
+SDNode *eq27 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and19, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and19, 1)
+                                    );
+
+SDValue ct68 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #209
+SDNode *nop14 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct68,
+                                    // glue (or chain) input edge
+                                    SDValue(eq27, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #210
+SDNode *whereeq14 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq27, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop14, 0)
+                                    );
+
+// R19 = R19 | R15;
+// Instr #211
+SDNode *or18 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(xor0, 0),
+                                    SDValue(or8, 0),
+                                    SDValue(or8, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq14, 1)
+                                    );
+
+SDValue ct69 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R00 = 0;
+// Instr #212
+SDNode *vload36 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct69,
+                                    SDValue(vload23, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or18, 1)
+                                    );
+
+// END_WHERE;
+// Instr #213
+SDNode *endwhere14 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload36, 1)
+                                    );
+
+SDValue ct70 = CurDAG->getConstant(1024, DL, MVT::i16, true, false);
+// R04 = 1024;
+// Instr #214
+SDNode *vload37 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct70,
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere14, 0)
+                                    );
+
+// R04 = R18 < R04;
+// Instr #215
+SDNode *lt11 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or17, 0),
+                                    SDValue(vload37, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload37, 1)
+                                    );
+
+// R12 = R16 == R30;
+// Instr #216
+SDNode *eq28 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload34, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt11, 1)
+                                    );
+
+// R12 = R12 & R04;
+// Instr #217
+SDNode *and20 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(lt11, 0),
+                                    SDValue(eq28, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq28, 1)
+                                    );
+
+// R12 = R12 == R30;
+// Instr #218
+SDNode *eq29 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and20, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and20, 1)
+                                    );
+
+// R52 = R12 & R00;
+// Instr #219
+SDNode *and21 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload36, 0),
+                                    SDValue(eq29, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq29, 1)
+                                    );
+
+// R52 = R52 == R30;
+// Instr #220
+SDNode *eq30 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and21, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and21, 1)
+                                    );
+
+SDValue ct71 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #221
+SDNode *nop15 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct71,
+                                    // glue (or chain) input edge
+                                    SDValue(eq30, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #222
+SDNode *whereeq15 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq30, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop15, 0)
+                                    );
+
+SDValue ct72 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R16 = 0;
+// Instr #223
+SDNode *vload38 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct72,
+                                    SDValue(vload34, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq15, 1)
+                                    );
+
+// END_WHERE;
+// Instr #224
+SDNode *endwhere15 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload38, 1)
+                                    );
+
+// R52 = R00 == R30;
+// Instr #225
+SDNode *eq31 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload36, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere15, 0)
+                                    );
+
+SDValue ct73 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #226
+SDNode *nop16 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct73,
+                                    // glue (or chain) input edge
+                                    SDValue(eq31, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #227
+SDNode *whereeq16 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq31, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop16, 0)
+                                    );
+
+// R60 = R18 & R30;
+// Instr #228
+SDNode *and22 = CurDAG->getMachineNode(
+                                    Connex::ANDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(or17, 0),
+                                    SDValue(vload17, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq16, 1)
+                                    );
+
+// R54 = R54 - R30;
+// Instr #229
+SDNode *sub16 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishl10, 0),
+                                    SDValue(vload1, 0),
+                                    SDValue(ishl10, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and22, 1)
+                                    );
+
+// R54 = R30 << R54;
+// Instr #230
+SDNode *shl5 = CurDAG->getMachineNode(
+                                    Connex::SHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(sub16, 0),
+                                    SDValue(sub16, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub16, 1)
+                                    );
+
+// R59 = R55 & R54;
+// Instr #231
+SDNode *and23 = CurDAG->getMachineNode(
+                                    Connex::ANDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl5, 0),
+                                    SDValue(shr3, 0),
+                                    SDValue(vload18, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shl5, 1)
+                                    );
+
+// R55 = R55 ^ R59;
+// Instr #232
+SDNode *xor1 = CurDAG->getMachineNode(
+                                    Connex::XORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and23, 0),
+                                    SDValue(shr3, 0),
+                                    SDValue(shr3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and23, 1)
+                                    );
+
+// R59 = R59 == R31;
+// Instr #233
+SDNode *eq32 = CurDAG->getMachineNode(
+                                    Connex::EQ_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and23, 0),
+                                    SDValue(vload0, 0),
+                                    SDValue(and23, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(xor1, 1)
+                                    );
+
+// R59 = R30 - R59;
+// Instr #234
+SDNode *sub17 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(eq32, 0),
+                                    SDValue(eq32, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq32, 1)
+                                    );
+
+// R58 = R55 == R31;
+// Instr #235
+SDNode *eq33 = CurDAG->getMachineNode(
+                                    Connex::EQ_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(xor1, 0),
+                                    SDValue(vload0, 0),
+                                    SDValue(vload19, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub17, 1)
+                                    );
+
+// R58 = R30 - R58;
+// Instr #236
+SDNode *sub18 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(eq33, 0),
+                                    SDValue(eq33, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq33, 1)
+                                    );
+
+// R57 = R58 | R60;
+// Instr #237
+SDNode *or19 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and22, 0),
+                                    SDValue(sub18, 0),
+                                    SDValue(vload20, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub18, 1)
+                                    );
+
+// R57 = R57 & R59;
+// Instr #238
+SDNode *and24 = CurDAG->getMachineNode(
+                                    Connex::ANDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub17, 0),
+                                    SDValue(or19, 0),
+                                    SDValue(or19, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or19, 1)
+                                    );
+
+// END_WHERE;
+// Instr #239
+SDNode *endwhere16 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(and24, 1)
+                                    );
+
+// R52 = R00 == R30;
+// Instr #240
+SDNode *eq34 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload36, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere16, 0)
+                                    );
+
+SDValue ct74 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #241
+SDNode *nop17 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct74,
+                                    // glue (or chain) input edge
+                                    SDValue(eq34, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #242
+SDNode *whereeq17 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq34, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop17, 0)
+                                    );
+
+SDValue ct75 = CurDAG->getConstant(10, DL, MVT::i16, true, false);
+// R19 = R16 << 10;
+// Instr #243
+SDNode *ishl12 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload38, 0),
+                                    ct75,
+                                    SDValue(or18, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq17, 1)
+                                    );
+
+// R18 = R18 & R10;
+// Instr #244
+SDNode *and25 = CurDAG->getMachineNode(
+                                    Connex::ANDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload4, 0),
+                                    SDValue(or17, 0),
+                                    SDValue(or17, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl12, 1)
+                                    );
+
+// R19 = R19 | R18;
+// Instr #245
+SDNode *or20 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and25, 0),
+                                    SDValue(ishl12, 0),
+                                    SDValue(ishl12, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and25, 1)
+                                    );
+
+// R19 = R57 + R19;
+// Instr #246
+SDNode *add3 = CurDAG->getMachineNode(
+                                    Connex::ADDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or20, 0),
+                                    SDValue(and24, 0),
+                                    SDValue(or20, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or20, 1)
+                                    );
+
+// R19 = R19 | R15;
+// Instr #247
+SDNode *resF16 /*or21*/ = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(xor0, 0),
+                                    SDValue(add3, 0),
+                                    SDValue(add3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(add3, 1)
+                                    );
+
+// END_WHERE;
+// Instr #248
+SDNode *lastNode /*endwhere17*/ = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+// Alex:                                    MVT::Glue,
+                                    MVT::Other,
+                                    // glue (or chain) input edge
+// Alex:                                    SDValue(or21, 1)
+                                    SDValue(resF16, 1)
+                                    );
+

lib/Target/Connex/Select_MULTi32_ComplementedRepresentation_OpincaaCodeGen.cpp

+// Copied from /home/asusu/LLVM/llvm38Nov2016/llvm/build40/bin/Tests/NEW_v128i16/opincaa_standalone_apps/Emulate_i32/MULTi32_manual_Complemented_radix_216_representation/DumpISel_OpincaaCodeGen_old27_220.cpp
+
+
+// R27 is REG_SRC1. It is represented by result of nodeOpSrcCast1.
+// R28 is REG_SRC2. It is represented by result of nodeOpSrcCast2.
+
+
+// Code auto-generated by method Kernel::genLLVMISelManualCode() 
+//   from Opincaa lib from kernel: simpleIoTest_allowOverwrite123456.
+// It is important to put this code in the Select() method of the
+//   SelectionDAGISel class of your back end, after the ISelLowering pass,
+//   which contains the DAG Combiner, because the DAG Combiner can remove
+//   the getCopyToReg() we create, which can lead to the following error:
+//   <<Register use before def!>> assertion failed.
+// Number of instructions generated: 27.
+
+
+
+
+SDValue ct0 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R31 = 0;
+// Instr #0
+SDNode *vload0 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Other,
+                                    ct0,
+                                    // glue (or chain) input edge
+                                    SDValue(nodeOpSrcCast2, 1)
+                                    );
+
+SDValue ct1 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R30 = 1;
+// Instr #1
+SDNode *vload1 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Other,
+                                    ct1,
+                                    // glue (or chain) input edge
+                                    SDValue(vload0, 1)
+                                    );
+
+// MULT_U(R28, R27);
+// Instr #2
+SDNode *mult_u0 = CurDAG->getMachineNode(
+                                    Connex::MULT_U_H,
+                                    DL,
+                                    MVT::Other,
+                                    SDValue(nodeOpSrcCast2, 0),
+                                    SDValue(nodeOpSrcCast1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload1, 1)
+                                    );
+
+// R26 = MULT_LOW();
+// Instr #3
+SDNode *multlo0 = CurDAG->getMachineNode(
+                                    Connex::MULTLO_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Other,
+                                    // glue (or chain) input edge
+                                    SDValue(mult_u0, 0)
+                                    );
+
+// R25 = MULT_HIGH();
+// Instr #4
+SDNode *multhi0 = CurDAG->getMachineNode(
+                                    Connex::MULTHI_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Other,
+                                    // glue (or chain) input edge
+                                    SDValue(multlo0, 1)
+                                    );
+
+// CELL_SHR(R27, R30);
+// Instr #5
+SDNode *cellshr0 = CurDAG->getMachineNode(
+                                    Connex::CELLSHR_H,
+                                    DL,
+                                    MVT::Other,
+                                    SDValue(nodeOpSrcCast1, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(multhi0, 1)
+                                    );
+
+SDValue ct2 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #6
+SDNode *nop0 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Other,
+                                    ct2,
+                                    // glue (or chain) input edge
+                                    SDValue(cellshr0, 0)
+                                    );
+
+// R24 = SHIFT_REG;
+// Instr #7
+SDNode *ldsh0 = CurDAG->getMachineNode(
+                                    Connex::LDSH_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Other,
+                                    // glue (or chain) input edge
+                                    SDValue(nop0, 0)
+                                    );
+
+// MULT_U(R24, R28);
+// Instr #8
+SDNode *mult_u1 = CurDAG->getMachineNode(
+                                    Connex::MULT_U_H,
+                                    DL,
+                                    MVT::Other,
+                                    SDValue(ldsh0, 0),
+                                    SDValue(nodeOpSrcCast2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ldsh0, 1)
+                                    );
+
+// R24 = MULT_LOW();
+// Instr #9
+SDNode *multlo1 = CurDAG->getMachineNode(
+                                    Connex::MULTLO_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Other,
+                                    // glue (or chain) input edge
+                                    SDValue(mult_u1, 0)
+                                    );
+
+// CELL_SHR(R28, R30);
+// Instr #10
+SDNode *cellshr1 = CurDAG->getMachineNode(
+                                    Connex::CELLSHR_H,
+                                    DL,
+                                    MVT::Other,
+                                    SDValue(nodeOpSrcCast2, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(multlo1, 1)
+                                    );
+
+SDValue ct3 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #11
+SDNode *nop1 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Other,
+                                    ct3,
+                                    // glue (or chain) input edge
+                                    SDValue(cellshr1, 0)
+                                    );
+
+// R23 = SHIFT_REG;
+// Instr #12
+SDNode *ldsh1 = CurDAG->getMachineNode(
+                                    Connex::LDSH_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Other,
+                                    // glue (or chain) input edge
+                                    SDValue(nop1, 0)
+                                    );
+
+// MULT_U(R23, R27);
+// Instr #13
+SDNode *mult_u2 = CurDAG->getMachineNode(
+                                    Connex::MULT_U_H,
+                                    DL,
+                                    MVT::Other,
+                                    SDValue(ldsh1, 0),
+                                    SDValue(nodeOpSrcCast1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ldsh1, 1)
+                                    );
+
+// R23 = MULT_LOW();
+// Instr #14
+SDNode *multlo2 = CurDAG->getMachineNode(
+                                    Connex::MULTLO_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Other,
+                                    // glue (or chain) input edge
+                                    SDValue(mult_u2, 0)
+                                    );
+
+// CELL_SHR(R25, R30);
+// Instr #15
+SDNode *cellshr2 = CurDAG->getMachineNode(
+                                    Connex::CELLSHR_H,
+                                    DL,
+                                    MVT::Other,
+                                    SDValue(multhi0, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(multlo2, 1)
+                                    );
+
+SDValue ct4 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #16
+SDNode *nop2 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Other,
+                                    ct4,
+                                    // glue (or chain) input edge
+                                    SDValue(cellshr2, 0)
+                                    );
+
+// R21 = SHIFT_REG;
+// Instr #17
+SDNode *ldsh2 = CurDAG->getMachineNode(
+                                    Connex::LDSH_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Other,
+                                    // glue (or chain) input edge
+                                    SDValue(nop2, 0)
+                                    );
+
+// R14 = INDEX;
+// Instr #18
+SDNode *ldix0 = CurDAG->getMachineNode(
+                                    Connex::LDIX_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Other,
+                                    // glue (or chain) input edge
+                                    SDValue(ldsh2, 1)
+                                    );
+
+// R13 = R14 & R30;
+// Instr #19
+SDNode *and0 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Other,
+                                    SDValue(vload1, 0),
+                                    SDValue(ldix0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ldix0, 1)
+                                    );
+
+// R12 = R13 == R30;
+// Instr #20
+SDNode *eq0 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Other,
+                                    SDValue(and0, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and0, 1)
+                                    );
+
+SDValue ct5 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #21
+SDNode *nop3 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Other,
+                                    ct5,
+                                    // glue (or chain) input edge
+                                    SDValue(eq0, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #22
+SDNode *whereeq0 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Other,
+                                    SDValue(eq0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop3, 0)
+                                    );
+
+// R26 = R21 | R21;
+// Instr #23
+SDNode *or0 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Other,
+                                    SDValue(ldsh2, 0),
+                                    SDValue(ldsh2, 0),
+                                    SDValue(multlo0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq0, 1)
+                                    );
+
+// R26 = R24 + R26;
+// Instr #24
+SDNode *add0 = CurDAG->getMachineNode(
+                                    Connex::ADDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Other,
+                                    SDValue(or0, 0),
+                                    SDValue(multlo1, 0),
+                                    SDValue(or0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or0, 1)
+                                    );
+
+// R26 = R23 + R26;
+// Instr #25
+SDNode *resH /*add1*/ = CurDAG->getMachineNode(
+                                    Connex::ADDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Other,
+                                    SDValue(add0, 0),
+                                    SDValue(multlo2, 0),
+                                    SDValue(add0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(add0, 1)
+                                    );
+
+// END_WHERE;
+// Instr #26
+SDNode *lastNode /*endwhere0*/ = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Other,
+                                    // glue (or chain) input edge
+                                    SDValue(resH /*add1*/, 1)
+                                    );
+
+
+//SDNode *lastNode = resF16;

lib/Target/Connex/Select_REDf16_OpincaaCodeGen.cpp

+// From /home/asusu/LLVM/Tests/opincaa_standalone_apps/Emulate_f16/REDf16_manual/DumpISel_OpincaaCodeGen.cpp
+
+// Code auto-generated by method Kernel::genLLVMISelManualCode() 
+//   from Opincaa lib from kernel: red.f16.
+// It is important to put this code in the Select() method of the
+//   SelectionDAGISel class of your back end, after the ISelLowering pass,
+//   which contains the DAG Combiner, because the DAG Combiner can remove
+//   the getCopyToReg() we create, which can lead to the following error:
+//   <<Register use before def!>> assertion failed.
+// Number of instructions generated: 122.
+
+
+
+SDValue ct0 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R31 = 1;
+// Instr #0
+SDNode *vload0 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct0,
+                                    // glue (or chain) input edge
+                                    SDValue(nodeOpSrcCast, 1)
+                                    );
+
+SDValue ct1 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R30 = 0;
+// Instr #1
+SDNode *vload1 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct1,
+                                    // glue (or chain) input edge
+                                    SDValue(vload0, 1)
+                                    );
+
+SDValue ct2 = CurDAG->getConstant(31, DL, MVT::i16, true, false);
+// R29 = 31;
+// Instr #2
+SDNode *vload2 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct2,
+                                    // glue (or chain) input edge
+                                    SDValue(vload1, 1)
+                                    );
+
+SDValue ct3 = CurDAG->getConstant(1023, DL, MVT::i16, true, false);
+// R13 = 1023;
+// Instr #3
+SDNode *vload3 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct3,
+                                    // glue (or chain) input edge
+                                    SDValue(vload2, 1)
+                                    );
+
+SDValue ct4 = CurDAG->getConstant(31744, DL, MVT::i16, true, false);
+// R12 = 31744;
+// Instr #4
+SDNode *vload4 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct4,
+                                    // glue (or chain) input edge
+                                    SDValue(vload3, 1)
+                                    );
+
+SDValue ct5 = CurDAG->getConstant(-32768, DL, MVT::i16, true, false);
+// R11 = -32768;
+// Instr #5
+SDNode *vload5 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct5,
+                                    // glue (or chain) input edge
+                                    SDValue(vload4, 1)
+                                    );
+
+SDValue ct6 = CurDAG->getConstant(1024, DL, MVT::i16, true, false);
+// R10 = 1024;
+// Instr #6
+SDNode *vload6 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct6,
+                                    // glue (or chain) input edge
+                                    SDValue(vload5, 1)
+                                    );
+
+// R25 = R28 & R11;
+// Instr #7
+SDNode *and0 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload5, 0),
+                                    SDValue(nodeOpSrcCast, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload6, 1)
+                                    );
+
+// R26 = R28 & R12;
+// Instr #8
+SDNode *and1 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload4, 0),
+                                    SDValue(nodeOpSrcCast, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and0, 1)
+                                    );
+
+SDValue ct7 = CurDAG->getConstant(10, DL, MVT::i16, true, false);
+// R26 = R26 >> 10;
+// Instr #9
+SDNode *ishr0 = CurDAG->getMachineNode(
+                                    Connex::ISHRV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and1, 0),
+                                    ct7,
+                                    // glue (or chain) input edge
+                                    SDValue(and1, 1)
+                                    );
+
+// R27 = R28 & R13;
+// Instr #10
+SDNode *and2 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload3, 0),
+                                    SDValue(nodeOpSrcCast, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishr0, 1)
+                                    );
+
+// R17 = R30 < R27;
+// Instr #11
+SDNode *lt0 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(and2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and2, 1)
+                                    );
+
+// R16 = R26 == R30;
+// Instr #12
+SDNode *eq0 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishr0, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt0, 1)
+                                    );
+
+// R09 = R16 & R17;
+// Instr #13
+SDNode *and3 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(lt0, 0),
+                                    SDValue(eq0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq0, 1)
+                                    );
+
+// R09 = R09 == R31;
+// Instr #14
+SDNode *eq1 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and3, 0),
+                                    SDValue(vload0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and3, 1)
+                                    );
+
+SDValue ct8 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #15
+SDNode *nop0 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct8,
+                                    // glue (or chain) input edge
+                                    SDValue(eq1, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #16
+SDNode *whereeq0 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop0, 0)
+                                    );
+
+SDValue ct9 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R26 = 1;
+// Instr #17
+SDNode *vload7 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct9,
+                                    SDValue(ishr0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq0, 1)
+                                    );
+
+// END_WHERE;
+// Instr #18
+SDNode *endwhere0 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload7, 1)
+                                    );
+
+// R17 = R26 == R29;
+// Instr #19
+SDNode *eq2 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload7, 0),
+                                    SDValue(vload2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere0, 0)
+                                    );
+
+// R17 = R17 | R16;
+// Instr #20
+SDNode *or0 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq0, 0),
+                                    SDValue(eq2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq2, 1)
+                                    );
+
+// R17 = R17 == R30;
+// Instr #21
+SDNode *eq3 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or0, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or0, 1)
+                                    );
+
+SDValue ct10 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #22
+SDNode *nop1 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct10,
+                                    // glue (or chain) input edge
+                                    SDValue(eq3, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #23
+SDNode *whereeq1 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop1, 0)
+                                    );
+
+// R27 = R27 | R10;
+// Instr #24
+SDNode *or1 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload6, 0),
+                                    SDValue(and2, 0),
+                                    SDValue(and2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq1, 1)
+                                    );
+
+// END_WHERE;
+// Instr #25
+SDNode *endwhere1 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(or1, 1)
+                                    );
+
+// R18 = R26 == R29;
+// Instr #26
+SDNode *eq4 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload7, 0),
+                                    SDValue(vload2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere1, 0)
+                                    );
+
+// R17 = R27 == R30;
+// Instr #27
+SDNode *eq5 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or1, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq4, 1)
+                                    );
+
+// R09 = R31 - R17;
+// Instr #28
+SDNode *sub0 = CurDAG->getMachineNode(
+                                    Connex::SUBV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload0, 0),
+                                    SDValue(eq5, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq5, 1)
+                                    );
+
+// R09 = R09 & R18;
+// Instr #29
+SDNode *and4 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq4, 0),
+                                    SDValue(sub0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub0, 1)
+                                    );
+
+// REDUCE(R09);
+// Instr #30
+SDNode *sumRed0 = CurDAG->getMachineNode(
+                                    Connex::RED_H,
+                                    DL,
+                                    MVT::Glue,
+                                    SDValue(and4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and4, 1)
+                                    );
+
+// R24 = R18 & R17;
+// Instr #31
+SDNode *and5 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq5, 0),
+                                    SDValue(eq4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sumRed0, 0)
+                                    );
+
+// R09 = R25 == R30;
+// Instr #32
+SDNode *eq6 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and0, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and5, 1)
+                                    );
+
+// R16 = R24 & R09;
+// Instr #33
+SDNode *and6 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq6, 0),
+                                    SDValue(and5, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq6, 1)
+                                    );
+
+// REDUCE(R16);
+// Instr #34
+SDNode *sumRed1 = CurDAG->getMachineNode(
+                                    Connex::RED_H,
+                                    DL,
+                                    MVT::Glue,
+                                    SDValue(and6, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and6, 1)
+                                    );
+
+// R09 = R31 - R09;
+// Instr #35
+SDNode *sub1 = CurDAG->getMachineNode(
+                                    Connex::SUBV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload0, 0),
+                                    SDValue(eq6, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sumRed1, 0)
+                                    );
+
+// R16 = R24 & R09;
+// Instr #36
+SDNode *and7 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub1, 0),
+                                    SDValue(and5, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub1, 1)
+                                    );
+
+// REDUCE(R16);
+// Instr #37
+SDNode *sumRed2 = CurDAG->getMachineNode(
+                                    Connex::RED_H,
+                                    DL,
+                                    MVT::Glue,
+                                    SDValue(and7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and7, 1)
+                                    );
+
+// R09 = R25 == R11;
+// Instr #38
+SDNode *eq7 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and0, 0),
+                                    SDValue(vload5, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sumRed2, 0)
+                                    );
+
+SDValue ct11 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #39
+SDNode *nop2 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct11,
+                                    // glue (or chain) input edge
+                                    SDValue(eq7, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #40
+SDNode *whereeq2 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop2, 0)
+                                    );
+
+// R27 = R30 - R27;
+// Instr #41
+SDNode *sub2 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(or1, 0),
+                                    SDValue(or1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq2, 1)
+                                    );
+
+// END_WHERE;
+// Instr #42
+SDNode *endwhere2 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(sub2, 1)
+                                    );
+
+SDValue ct12 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R02 = R26 << 0;
+// Instr #43
+SDNode *ishl0 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload7, 0),
+                                    ct12,
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere2, 0)
+                                    );
+
+SDValue ct13 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R02 = 0;
+// Instr #44
+SDNode *vload8 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct13,
+                                    // glue (or chain) input edge
+                                    SDValue(ishl0, 1)
+                                    );
+
+SDValue ct14 = CurDAG->getConstant(6, DL, MVT::i16, true, false);
+// R24 = 6;
+// Instr #45
+SDNode *vload9 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct14,
+                                    // glue (or chain) input edge
+                                    SDValue(vload8, 1)
+                                    );
+
+// R19 = R26 < R24;
+// Instr #46
+SDNode *lt1 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload7, 0),
+                                    SDValue(vload9, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload9, 1)
+                                    );
+
+// R17 = R02 < R26;
+// Instr #47
+SDNode *lt2 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload8, 0),
+                                    SDValue(vload7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt1, 1)
+                                    );
+
+// R02 = R31 + R02;
+// Instr #48
+SDNode *add0 = CurDAG->getMachineNode(
+                                    Connex::ADDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload8, 0),
+                                    SDValue(vload0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt2, 1)
+                                    );
+
+// R09 = R19 & R17;
+// Instr #49
+SDNode *and8 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(lt2, 0),
+                                    SDValue(lt1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(add0, 1)
+                                    );
+
+// R09 = R09 == R31;
+// Instr #50
+SDNode *eq8 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and8, 0),
+                                    SDValue(vload0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and8, 1)
+                                    );
+
+SDValue ct15 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #51
+SDNode *nop3 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct15,
+                                    // glue (or chain) input edge
+                                    SDValue(eq8, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #52
+SDNode *whereeq3 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq8, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop3, 0)
+                                    );
+
+// R19 = R26 - R02;
+// Instr #53
+SDNode *sub3 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload7, 0),
+                                    SDValue(add0, 0),
+                                    SDValue(lt1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq3, 1)
+                                    );
+
+// R27 = R27 << R19;
+// Instr #54
+SDNode *shl0 = CurDAG->getMachineNode(
+                                    Connex::SHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub2, 0),
+                                    SDValue(sub3, 0),
+                                    SDValue(sub2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub3, 1)
+                                    );
+
+// REDUCE(R27);
+// Instr #55
+SDNode *sumRed3 = CurDAG->getMachineNode(
+                                    Connex::RED_H,
+                                    DL,
+                                    MVT::Glue,
+                                    SDValue(shl0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shl0, 1)
+                                    );
+
+// END_WHERE;
+// Instr #56
+SDNode *endwhere3 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(sumRed3, 0)
+                                    );
+
+SDValue ct16 = CurDAG->getConstant(5, DL, MVT::i16, true, false);
+// R02 = 5;
+// Instr #57
+SDNode *vload10 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct16,
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere3, 0)
+                                    );
+
+SDValue ct17 = CurDAG->getConstant(11, DL, MVT::i16, true, false);
+// R24 = 11;
+// Instr #58
+SDNode *vload11 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct17,
+                                    // glue (or chain) input edge
+                                    SDValue(vload10, 1)
+                                    );
+
+// R19 = R26 < R24;
+// Instr #59
+SDNode *lt3 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload7, 0),
+                                    SDValue(vload11, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload11, 1)
+                                    );
+
+// R17 = R02 < R26;
+// Instr #60
+SDNode *lt4 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload10, 0),
+                                    SDValue(vload7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt3, 1)
+                                    );
+
+// R02 = R31 + R02;
+// Instr #61
+SDNode *add1 = CurDAG->getMachineNode(
+                                    Connex::ADDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload10, 0),
+                                    SDValue(vload0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt4, 1)
+                                    );
+
+// R09 = R19 & R17;
+// Instr #62
+SDNode *and9 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(lt4, 0),
+                                    SDValue(lt3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(add1, 1)
+                                    );
+
+// R09 = R09 == R31;
+// Instr #63
+SDNode *eq9 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and9, 0),
+                                    SDValue(vload0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and9, 1)
+                                    );
+
+SDValue ct18 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #64
+SDNode *nop4 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct18,
+                                    // glue (or chain) input edge
+                                    SDValue(eq9, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #65
+SDNode *whereeq4 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq9, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop4, 0)
+                                    );
+
+// R19 = R26 - R02;
+// Instr #66
+SDNode *sub4 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload7, 0),
+                                    SDValue(add1, 0),
+                                    SDValue(lt3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq4, 1)
+                                    );
+
+// R27 = R27 << R19;
+// Instr #67
+SDNode *shl1 = CurDAG->getMachineNode(
+                                    Connex::SHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl0, 0),
+                                    SDValue(sub4, 0),
+                                    SDValue(shl0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub4, 1)
+                                    );
+
+// REDUCE(R27);
+// Instr #68
+SDNode *sumRed4 = CurDAG->getMachineNode(
+                                    Connex::RED_H,
+                                    DL,
+                                    MVT::Glue,
+                                    SDValue(shl1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shl1, 1)
+                                    );
+
+// END_WHERE;
+// Instr #69
+SDNode *endwhere4 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(sumRed4, 0)
+                                    );
+
+SDValue ct19 = CurDAG->getConstant(10, DL, MVT::i16, true, false);
+// R02 = 10;
+// Instr #70
+SDNode *vload12 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct19,
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere4, 0)
+                                    );
+
+SDValue ct20 = CurDAG->getConstant(16, DL, MVT::i16, true, false);
+// R24 = 16;
+// Instr #71
+SDNode *vload13 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct20,
+                                    // glue (or chain) input edge
+                                    SDValue(vload12, 1)
+                                    );
+
+// R19 = R26 < R24;
+// Instr #72
+SDNode *lt5 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload7, 0),
+                                    SDValue(vload13, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload13, 1)
+                                    );
+
+// R17 = R02 < R26;
+// Instr #73
+SDNode *lt6 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload12, 0),
+                                    SDValue(vload7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt5, 1)
+                                    );
+
+// R02 = R31 + R02;
+// Instr #74
+SDNode *add2 = CurDAG->getMachineNode(
+                                    Connex::ADDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload12, 0),
+                                    SDValue(vload0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt6, 1)
+                                    );
+
+// R09 = R19 & R17;
+// Instr #75
+SDNode *and10 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(lt6, 0),
+                                    SDValue(lt5, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(add2, 1)
+                                    );
+
+// R09 = R09 == R31;
+// Instr #76
+SDNode *eq10 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and10, 0),
+                                    SDValue(vload0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and10, 1)
+                                    );
+
+SDValue ct21 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #77
+SDNode *nop5 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct21,
+                                    // glue (or chain) input edge
+                                    SDValue(eq10, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #78
+SDNode *whereeq5 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq10, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop5, 0)
+                                    );
+
+// R19 = R26 - R02;
+// Instr #79
+SDNode *sub5 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload7, 0),
+                                    SDValue(add2, 0),
+                                    SDValue(lt5, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq5, 1)
+                                    );
+
+// R27 = R27 << R19;
+// Instr #80
+SDNode *shl2 = CurDAG->getMachineNode(
+                                    Connex::SHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl1, 0),
+                                    SDValue(sub5, 0),
+                                    SDValue(shl1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub5, 1)
+                                    );
+
+// REDUCE(R27);
+// Instr #81
+SDNode *sumRed5 = CurDAG->getMachineNode(
+                                    Connex::RED_H,
+                                    DL,
+                                    MVT::Glue,
+                                    SDValue(shl2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shl2, 1)
+                                    );
+
+// END_WHERE;
+// Instr #82
+SDNode *endwhere5 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(sumRed5, 0)
+                                    );
+
+SDValue ct22 = CurDAG->getConstant(15, DL, MVT::i16, true, false);
+// R02 = 15;
+// Instr #83
+SDNode *vload14 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct22,
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere5, 0)
+                                    );
+
+SDValue ct23 = CurDAG->getConstant(21, DL, MVT::i16, true, false);
+// R24 = 21;
+// Instr #84
+SDNode *vload15 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct23,
+                                    // glue (or chain) input edge
+                                    SDValue(vload14, 1)
+                                    );
+
+// R19 = R26 < R24;
+// Instr #85
+SDNode *lt7 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload7, 0),
+                                    SDValue(vload15, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload15, 1)
+                                    );
+
+// R17 = R02 < R26;
+// Instr #86
+SDNode *lt8 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload14, 0),
+                                    SDValue(vload7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt7, 1)
+                                    );
+
+// R02 = R31 + R02;
+// Instr #87
+SDNode *add3 = CurDAG->getMachineNode(
+                                    Connex::ADDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload14, 0),
+                                    SDValue(vload0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt8, 1)
+                                    );
+
+// R09 = R19 & R17;
+// Instr #88
+SDNode *and11 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(lt8, 0),
+                                    SDValue(lt7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(add3, 1)
+                                    );
+
+// R09 = R09 == R31;
+// Instr #89
+SDNode *eq11 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and11, 0),
+                                    SDValue(vload0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and11, 1)
+                                    );
+
+SDValue ct24 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #90
+SDNode *nop6 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct24,
+                                    // glue (or chain) input edge
+                                    SDValue(eq11, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #91
+SDNode *whereeq6 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq11, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop6, 0)
+                                    );
+
+// R19 = R26 - R02;
+// Instr #92
+SDNode *sub6 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload7, 0),
+                                    SDValue(add3, 0),
+                                    SDValue(lt7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq6, 1)
+                                    );
+
+// R27 = R27 << R19;
+// Instr #93
+SDNode *shl3 = CurDAG->getMachineNode(
+                                    Connex::SHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl2, 0),
+                                    SDValue(sub6, 0),
+                                    SDValue(shl2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub6, 1)
+                                    );
+
+// REDUCE(R27);
+// Instr #94
+SDNode *sumRed6 = CurDAG->getMachineNode(
+                                    Connex::RED_H,
+                                    DL,
+                                    MVT::Glue,
+                                    SDValue(shl3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shl3, 1)
+                                    );
+
+// END_WHERE;
+// Instr #95
+SDNode *endwhere6 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(sumRed6, 0)
+                                    );
+
+SDValue ct25 = CurDAG->getConstant(20, DL, MVT::i16, true, false);
+// R02 = 20;
+// Instr #96
+SDNode *vload16 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct25,
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere6, 0)
+                                    );
+
+SDValue ct26 = CurDAG->getConstant(26, DL, MVT::i16, true, false);
+// R24 = 26;
+// Instr #97
+SDNode *vload17 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct26,
+                                    // glue (or chain) input edge
+                                    SDValue(vload16, 1)
+                                    );
+
+// R19 = R26 < R24;
+// Instr #98
+SDNode *lt9 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload7, 0),
+                                    SDValue(vload17, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload17, 1)
+                                    );
+
+// R17 = R02 < R26;
+// Instr #99
+SDNode *lt10 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload16, 0),
+                                    SDValue(vload7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt9, 1)
+                                    );
+
+// R02 = R31 + R02;
+// Instr #100
+SDNode *add4 = CurDAG->getMachineNode(
+                                    Connex::ADDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload16, 0),
+                                    SDValue(vload0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt10, 1)
+                                    );
+
+// R09 = R19 & R17;
+// Instr #101
+SDNode *and12 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(lt10, 0),
+                                    SDValue(lt9, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(add4, 1)
+                                    );
+
+// R09 = R09 == R31;
+// Instr #102
+SDNode *eq12 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and12, 0),
+                                    SDValue(vload0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and12, 1)
+                                    );
+
+SDValue ct27 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #103
+SDNode *nop7 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct27,
+                                    // glue (or chain) input edge
+                                    SDValue(eq12, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #104
+SDNode *whereeq7 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq12, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop7, 0)
+                                    );
+
+// R19 = R26 - R02;
+// Instr #105
+SDNode *sub7 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload7, 0),
+                                    SDValue(add4, 0),
+                                    SDValue(lt9, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq7, 1)
+                                    );
+
+// R27 = R27 << R19;
+// Instr #106
+SDNode *shl4 = CurDAG->getMachineNode(
+                                    Connex::SHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl3, 0),
+                                    SDValue(sub7, 0),
+                                    SDValue(shl3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub7, 1)
+                                    );
+
+// REDUCE(R27);
+// Instr #107
+SDNode *sumRed7 = CurDAG->getMachineNode(
+                                    Connex::RED_H,
+                                    DL,
+                                    MVT::Glue,
+                                    SDValue(shl4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shl4, 1)
+                                    );
+
+// END_WHERE;
+// Instr #108
+SDNode *endwhere7 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(sumRed7, 0)
+                                    );
+
+SDValue ct28 = CurDAG->getConstant(25, DL, MVT::i16, true, false);
+// R02 = 25;
+// Instr #109
+SDNode *vload18 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct28,
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere7, 0)
+                                    );
+
+SDValue ct29 = CurDAG->getConstant(31, DL, MVT::i16, true, false);
+// R24 = 31;
+// Instr #110
+SDNode *vload19 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct29,
+                                    // glue (or chain) input edge
+                                    SDValue(vload18, 1)
+                                    );
+
+// R19 = R26 < R24;
+// Instr #111
+SDNode *lt11 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload7, 0),
+                                    SDValue(vload19, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload19, 1)
+                                    );
+
+// R17 = R02 < R26;
+// Instr #112
+SDNode *lt12 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload18, 0),
+                                    SDValue(vload7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt11, 1)
+                                    );
+
+// R02 = R31 + R02;
+// Instr #113
+SDNode *add5 = CurDAG->getMachineNode(
+                                    Connex::ADDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload18, 0),
+                                    SDValue(vload0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt12, 1)
+                                    );
+
+// R09 = R19 & R17;
+// Instr #114
+SDNode *and13 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(lt12, 0),
+                                    SDValue(lt11, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(add5, 1)
+                                    );
+
+// R09 = R09 == R31;
+// Instr #115
+SDNode *eq13 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and13, 0),
+                                    SDValue(vload0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and13, 1)
+                                    );
+
+SDValue ct30 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #116
+SDNode *nop8 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct30,
+                                    // glue (or chain) input edge
+                                    SDValue(eq13, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #117
+SDNode *whereeq8 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq13, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop8, 0)
+                                    );
+
+// R19 = R26 - R02;
+// Instr #118
+SDNode *sub8 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload7, 0),
+                                    SDValue(add5, 0),
+                                    SDValue(lt11, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq8, 1)
+                                    );
+
+// R27 = R27 << R19;
+// Instr #119
+SDNode *shl5 = CurDAG->getMachineNode(
+                                    Connex::SHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl4, 0),
+                                    SDValue(sub8, 0),
+                                    SDValue(shl4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub8, 1)
+                                    );
+
+// REDUCE(R27);
+// Instr #120
+SDNode *sumRed8 = CurDAG->getMachineNode(
+                                    Connex::RED_H,
+                                    DL,
+                                    MVT::Glue,
+                                    SDValue(shl5, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shl5, 1)
+                                    );
+
+// END_WHERE;
+// Instr #121
+SDNode *reduceH /* endwhere8 */ = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+// Alex:                                    MVT::Glue, // Error: <<Assertion `N->getNodeId() == -1 && "Node already inserted!"' failed.>>
+                                    MVT::Other,
+                                    // glue (or chain) input edge
+                                    SDValue(sumRed8, 0)
+                                    );
+

lib/Target/Connex/Select_REDi32_OpincaaCodeGen.cpp

+// From /home/asusu/LLVM/llvm38Nov2016/llvm/build40/bin/Tests/NEW_v128i16/opincaa_standalone_apps/Emulate_i32/RED_i32_manual/DumpISel_OpincaaCodeGen_old04_300.cpp
+
+
+// Code auto-generated by method Kernel::genLLVMISelManualCode() 
+//   from Opincaa lib from kernel: simpleIoTest_allowOverwrite123456.
+// It is important to put this code in the Select() method of the
+//   SelectionDAGISel class of your back end, after the ISelLowering pass,
+//   which contains the DAG Combiner, because the DAG Combiner can remove
+//   the getCopyToReg() we create, which can lead to the following error:
+//   <<Register use before def!>> assertion failed.
+// Number of instructions generated: 14.
+
+
+
+SDValue ct0 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R29 = 1;
+// Instr #0
+SDNode *vload0 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct0,
+                                    // glue (or chain) input edge
+                                    SDValue(nodeOpSrcCast, 1)
+                                    );
+
+// CELL_SHR(R28, R29);
+// Instr #1
+SDNode *cellshr0 = CurDAG->getMachineNode(
+                                    Connex::CELLSHR_H,
+                                    DL,
+                                    MVT::Glue,
+                                    SDValue(nodeOpSrcCast, 0),
+                                    SDValue(vload0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload0, 1)
+                                    );
+
+SDValue ct1 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #2
+SDNode *nop0 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct1,
+                                    // glue (or chain) input edge
+                                    SDValue(cellshr0, 0)
+                                    );
+
+// R27 = SHIFT_REG;
+// Instr #3
+SDNode *ldsh0 = CurDAG->getMachineNode(
+                                    Connex::LDSH_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(nop0, 0)
+                                    );
+
+// R26 = INDEX;
+// Instr #4
+SDNode *ldix0 = CurDAG->getMachineNode(
+                                    Connex::LDIX_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(ldsh0, 1)
+                                    );
+
+// R25 = R26 & R29;
+// Instr #5
+SDNode *and0 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload0, 0),
+                                    SDValue(ldix0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ldix0, 1)
+                                    );
+
+// R24 = R25 == R29;
+// Instr #6
+SDNode *eq0 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and0, 0),
+                                    SDValue(vload0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and0, 1)
+                                    );
+
+SDValue ct2 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #7
+SDNode *nop1 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct2,
+                                    // glue (or chain) input edge
+                                    SDValue(eq0, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #8
+SDNode *whereeq0 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop1, 0)
+                                    );
+
+SDValue ct3 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R28 = 0;
+// Instr #9
+SDNode *vload1 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct3,
+                                    SDValue(nodeOpSrcCast, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq0, 1)
+                                    );
+
+SDValue ct4 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R27 = 0;
+// Instr #10
+SDNode *vload2 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct4,
+                                    SDValue(ldsh0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload1, 1)
+                                    );
+
+// END_WHERE;
+// Instr #11
+SDNode *endwhere0 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload2, 1)
+                                    );
+
+// REDUCE_U(R28);
+// Instr #12
+SDNode *sumRedU0 = CurDAG->getMachineNode(
+                                    Connex::RED_U_H,
+                                    DL,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere0, 0)
+                                    );
+
+// REDUCE_U(R27);
+// Instr #13
+SDNode *reduceHigh16 /*sumRedU1*/ = CurDAG->getMachineNode(
+                                    Connex::RED_U_H,
+                                    DL,
+// Alex:                                    MVT::Glue,
+                                    MVT::Other,
+                                    SDValue(vload2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sumRedU0, 0)
+                                    );
+

lib/Target/Connex/Select_SHRAi32_OpincaaCodeGen.cpp

+// From /home/asusu/LLVM/llvm38Nov2016/llvm/build40/bin/Tests/NEW_v128i16/opincaa_standalone_apps/Emulate_i32/SHRA_i32_manual/DumpISel_OpincaaCodeGen_old13_927.cpp
+
+// Code auto-generated by method Kernel::genLLVMISelManualCode() 
+//   from Opincaa lib from kernel: simpleIoTest_allowOverwrite123456.
+// It is important to put this code in the Select() method of the
+//   SelectionDAGISel class of your back end, after the ISelLowering pass,
+//   which contains the DAG Combiner, because the DAG Combiner can remove
+//   the getCopyToReg() we create, which can lead to the following error:
+//   <<Register use before def!>> assertion failed.
+// Number of instructions generated: 33.
+
+
+
+/* Alex: added manually to have predicated instructions refer to tied-to
+   constraints to these nodes (destination registers of predicated instr)
+   without initializing the respective dest registers, since it's not necessary.
+*/
+SDValue ct21Node = CurDAG->getConstant(21, DL, MVT::i16, true, false);
+SDNode *r21Node = CurDAG->getMachineNode(
+                                    Connex::VLOAD_BOGUS_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct21Node,
+                                    // glue (or chain) input edge
+                                    SDValue(nodeOpSrcCast1, 1)
+                                    );
+
+SDValue ct22Node = CurDAG->getConstant(22, DL, MVT::i16, true, false);
+SDNode *r22Node = CurDAG->getMachineNode(
+                                    Connex::VLOAD_BOGUS_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct22Node,
+                                    // glue (or chain) input edge
+                                    SDValue(r21Node, 1)
+                                    );
+
+
+SDValue ct0 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R31 = 0;
+// Instr #0
+SDNode *vload0 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct0,
+                                    // glue (or chain) input edge
+                                    SDValue(r22Node, 1)
+                                    );
+
+SDValue ct1 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R30 = 1;
+// Instr #1
+SDNode *vload1 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct1,
+                                    // glue (or chain) input edge
+                                    SDValue(vload0, 1)
+                                    );
+
+SDValue ct2 = CurDAG->getConstant(16, DL, MVT::i16, true, false);
+// R10 = 16;
+// Instr #2
+SDNode *vload2 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct2,
+                                    // glue (or chain) input edge
+                                    SDValue(vload1, 1)
+                                    );
+
+SDValue ct3 = CurDAG->getConstant(31, DL, MVT::i16, true, false);
+// R08 = 31;
+// Instr #3
+SDNode *vload3 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct3,
+                                    // glue (or chain) input edge
+                                    SDValue(vload2, 1)
+                                    );
+
+// R27 = R27 & R08;
+// Instr #4
+SDNode *and0 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload3, 0),
+                                    SDValue(nodeOpSrcCast2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload3, 1)
+                                    );
+
+// R25 = INDEX;
+// Instr #5
+SDNode *ldix0 = CurDAG->getMachineNode(
+                                    Connex::LDIX_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(and0, 1)
+                                    );
+
+// R25 = R25 & R30;
+// Instr #6
+SDNode *and1 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(ldix0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ldix0, 1)
+                                    );
+
+// CELL_SHR(R27, R25);
+// Instr #7
+SDNode *cellshr0 = CurDAG->getMachineNode(
+                                    Connex::CELLSHR_H,
+                                    DL,
+                                    MVT::Glue,
+                                    SDValue(and0, 0),
+                                    SDValue(and1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and1, 1)
+                                    );
+
+SDValue ct4 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #8
+SDNode *nop0 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct4,
+                                    // glue (or chain) input edge
+                                    SDValue(cellshr0, 0)
+                                    );
+
+// R27 = SHIFT_REG;
+// Instr #9
+SDNode *ldsh0 = CurDAG->getMachineNode(
+                                    Connex::LDSH_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(nop0, 0)
+                                    );
+
+// R20 = R10 < R27;
+// Instr #10
+SDNode *lt0 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(ldsh0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ldsh0, 1)
+                                    );
+
+// R29 = SHRA(R28, R27);
+// Instr #11
+SDNode *shra0 = CurDAG->getMachineNode(
+                                    Connex::SHRAV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(nodeOpSrcCast1, 0),
+                                    SDValue(ldsh0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt0, 1)
+                                    );
+
+// CELL_SHL(R28, R30);
+// Instr #12
+SDNode *cellshl0 = CurDAG->getMachineNode(
+                                    Connex::CELLSHL_H,
+                                    DL,
+                                    MVT::Glue,
+                                    SDValue(nodeOpSrcCast1, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shra0, 1)
+                                    );
+
+SDValue ct5 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #13
+SDNode *nop1 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct5,
+                                    // glue (or chain) input edge
+                                    SDValue(cellshl0, 0)
+                                    );
+
+// R23 = SHIFT_REG;
+// Instr #14
+SDNode *ldsh1 = CurDAG->getMachineNode(
+                                    Connex::LDSH_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(nop1, 0)
+                                    );
+
+// R25 = R25 == R31;
+// Instr #15
+SDNode *eq0 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and1, 0),
+                                    SDValue(vload0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ldsh1, 1)
+                                    );
+
+// R24 = R20 & R25;
+// Instr #16
+SDNode *and2 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq0, 0),
+                                    SDValue(lt0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq0, 1)
+                                    );
+
+// R19 = R24 == R30;
+// Instr #17
+SDNode *eq1 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and2, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and2, 1)
+                                    );
+
+SDValue ct6 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #18
+SDNode *nop2 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct6,
+                                    // glue (or chain) input edge
+                                    SDValue(eq1, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #19
+SDNode *whereeq0 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop2, 0)
+                                    );
+
+// R21 = R27 - R10;
+// Instr #20
+SDNode *sub0 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ldsh0, 0),
+                                    SDValue(vload2, 0),
+                                    SDValue(r21Node, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq0, 1)
+                                    );
+
+// R29 = SHRA(R23, R21);
+// Instr #21
+SDNode *shra1 = CurDAG->getMachineNode(
+                                    Connex::SHRAV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ldsh1, 0),
+                                    SDValue(sub0, 0),
+                                    SDValue(shra0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub0, 1)
+                                    );
+
+// END_WHERE;
+// Instr #22
+SDNode *endwhere0 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(shra1, 1)
+                                    );
+
+// R20 = R30 - R20;
+// Instr #23
+SDNode *sub1 = CurDAG->getMachineNode(
+                                    Connex::SUBV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(lt0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere0, 0)
+                                    );
+
+// R24 = R20 & R25;
+// Instr #24
+SDNode *and3 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq0, 0),
+                                    SDValue(sub1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub1, 1)
+                                    );
+
+// R19 = R24 == R30;
+// Instr #25
+SDNode *eq2 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and3, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and3, 1)
+                                    );
+
+SDValue ct7 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #26
+SDNode *nop3 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct7,
+                                    // glue (or chain) input edge
+                                    SDValue(eq2, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #27
+SDNode *whereeq1 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop3, 0)
+                                    );
+
+// R21 = R10 - R27;
+// Instr #28
+SDNode *sub2 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(ldsh0, 0),
+                                    SDValue(sub0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq1, 1)
+                                    );
+
+// R22 = R23 << R21;
+// Instr #29
+SDNode *shl0 = CurDAG->getMachineNode(
+                                    Connex::SHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ldsh1, 0),
+                                    SDValue(sub2, 0),
+                                    SDValue(r22Node, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub2, 1)
+                                    );
+
+// R29 = R28 >> R27;
+// Instr #30
+SDNode *shr0 = CurDAG->getMachineNode(
+                                    Connex::SHRV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(nodeOpSrcCast1, 0),
+                                    SDValue(ldsh0, 0),
+                                    SDValue(shra1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shl0, 1)
+                                    );
+
+// R29 = R29 | R22;
+// Instr #31
+SDNode *resH /*or0*/ = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl0, 0),
+                                    SDValue(shr0, 0),
+                                    SDValue(shr0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shr0, 1)
+                                    );
+
+// END_WHERE;
+// Instr #32
+SDNode *lastNode /*endwhere1*/ = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+//                                    MVT::Glue,
+                                    MVT::Other,
+                                    // glue (or chain) input edge
+                                    SDValue(resH /*or0*/, 1)
+                                    );
+

lib/Target/Connex/Select_SUBf16_OpincaaCodeGen.cpp

+// From /home/asusu/LLVM/Tests/opincaa_standalone_apps/Emulate_f16/ADD_SUB_f16_manual/DumpISel_OpincaaCodeGen_old37_C10_SUBf16.cpp
+
+// Code auto-generated by method Kernel::genLLVMISelManualCode() 
+//   from Opincaa lib from kernel: add_or_sub.f16.
+// It is important to put this code in the Select() method of the
+//   SelectionDAGISel class of your back end, after the ISelLowering pass,
+//   which contains the DAG Combiner, because the DAG Combiner can remove
+//   the getCopyToReg() we create, which can lead to the following error:
+//   <<Register use before def!>> assertion failed.
+// Number of instructions generated: 280.
+
+
+
+
+SDValue ct0 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R14 = 1;
+// Instr #0
+SDNode *vload0 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct0,
+                                    // glue (or chain) input edge
+                                    SDValue(nodeOpSrcCast1, 1)
+                                    );
+
+SDValue ct1 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R30 = 1;
+// Instr #1
+SDNode *vload1 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct1,
+                                    // glue (or chain) input edge
+                                    SDValue(vload0, 1)
+                                    );
+
+SDValue ct2 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R31 = 0;
+// Instr #2
+SDNode *vload2 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct2,
+                                    // glue (or chain) input edge
+                                    SDValue(vload1, 1)
+                                    );
+
+SDValue ct3 = CurDAG->getConstant(16, DL, MVT::i16, true, false);
+// R29 = 16;
+// Instr #3
+SDNode *vload3 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct3,
+                                    // glue (or chain) input edge
+                                    SDValue(vload2, 1)
+                                    );
+
+SDValue ct4 = CurDAG->getConstant(31, DL, MVT::i16, true, false);
+// R28 = 31;
+// Instr #4
+SDNode *vload4 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct4,
+                                    // glue (or chain) input edge
+                                    SDValue(vload3, 1)
+                                    );
+
+SDValue ct5 = CurDAG->getConstant(1023, DL, MVT::i16, true, false);
+// R13 = 1023;
+// Instr #5
+SDNode *vload5 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct5,
+                                    // glue (or chain) input edge
+                                    SDValue(vload4, 1)
+                                    );
+
+SDValue ct6 = CurDAG->getConstant(31744, DL, MVT::i16, true, false);
+// R12 = 31744;
+// Instr #6
+SDNode *vload6 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct6,
+                                    // glue (or chain) input edge
+                                    SDValue(vload5, 1)
+                                    );
+
+SDValue ct7 = CurDAG->getConstant(-32768, DL, MVT::i16, true, false);
+// R11 = -32768;
+// Instr #7
+SDNode *vload7 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct7,
+                                    // glue (or chain) input edge
+                                    SDValue(vload6, 1)
+                                    );
+
+SDValue ct8 = CurDAG->getConstant(1024, DL, MVT::i16, true, false);
+// R10 = 1024;
+// Instr #8
+SDNode *vload8 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct8,
+                                    // glue (or chain) input edge
+                                    SDValue(vload7, 1)
+                                    );
+
+SDValue ct9 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R62 = 0;
+// Instr #9
+SDNode *vload9 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct9,
+                                    // glue (or chain) input edge
+                                    SDValue(vload8, 1)
+                                    );
+
+SDValue ct10 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R19 = 0;
+// Instr #10
+SDNode *vload10 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct10,
+                                    // glue (or chain) input edge
+                                    SDValue(vload9, 1)
+                                    );
+
+SDValue ct11 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R62 = 0;
+// Instr #11
+SDNode *vload11 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct11,
+                                    // glue (or chain) input edge
+                                    SDValue(vload10, 1)
+                                    );
+
+SDValue ct12 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R61 = 0;
+// Instr #12
+SDNode *vload12 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct12,
+                                    // glue (or chain) input edge
+                                    SDValue(vload11, 1)
+                                    );
+
+SDValue ct13 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R07 = 0;
+// Instr #13
+SDNode *vload13 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct13,
+                                    // glue (or chain) input edge
+                                    SDValue(vload12, 1)
+                                    );
+
+SDValue ct14 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R04 = 0;
+// Instr #14
+SDNode *vload14 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct14,
+                                    // glue (or chain) input edge
+                                    SDValue(vload13, 1)
+                                    );
+
+SDValue ct15 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R03 = 0;
+// Instr #15
+SDNode *vload15 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct15,
+                                    // glue (or chain) input edge
+                                    SDValue(vload14, 1)
+                                    );
+
+SDValue ct16 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R02 = 0;
+// Instr #16
+SDNode *vload16 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct16,
+                                    // glue (or chain) input edge
+                                    SDValue(vload15, 1)
+                                    );
+
+SDValue ct17 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R01 = 0;
+// Instr #17
+SDNode *vload17 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct17,
+                                    // glue (or chain) input edge
+                                    SDValue(vload16, 1)
+                                    );
+
+SDValue ct18 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R00 = 0;
+// Instr #18
+SDNode *vload18 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct18,
+                                    // glue (or chain) input edge
+                                    SDValue(vload17, 1)
+                                    );
+
+// R24 = R27 & R11;
+// Instr #19
+SDNode *and0 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload7, 0),
+                                    SDValue(nodeOpSrcCast1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload18, 1)
+                                    );
+
+// R25 = R27 & R12;
+// Instr #20
+SDNode *and1 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload6, 0),
+                                    SDValue(nodeOpSrcCast1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and0, 1)
+                                    );
+
+SDValue ct19 = CurDAG->getConstant(10, DL, MVT::i16, true, false);
+// R25 = R25 >> 10;
+// Instr #21
+SDNode *ishr0 = CurDAG->getMachineNode(
+                                    Connex::ISHRV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and1, 0),
+                                    ct19,
+                                    // glue (or chain) input edge
+                                    SDValue(and1, 1)
+                                    );
+
+// R26 = R27 & R13;
+// Instr #22
+SDNode *and2 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload5, 0),
+                                    SDValue(nodeOpSrcCast1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishr0, 1)
+                                    );
+
+// R18 = R31 < R26;
+// Instr #23
+SDNode *lt0 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(and2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and2, 1)
+                                    );
+
+// R17 = R25 == R31;
+// Instr #24
+SDNode *eq0 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishr0, 0),
+                                    SDValue(vload2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt0, 1)
+                                    );
+
+// R09 = R17 & R18;
+// Instr #25
+SDNode *and3 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(lt0, 0),
+                                    SDValue(eq0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq0, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #26
+SDNode *eq1 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and3, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and3, 1)
+                                    );
+
+SDValue ct20 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #27
+SDNode *nop0 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct20,
+                                    // glue (or chain) input edge
+                                    SDValue(eq1, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #28
+SDNode *whereeq0 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop0, 0)
+                                    );
+
+SDValue ct21 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R25 = 1;
+// Instr #29
+SDNode *vload19 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct21,
+                                    SDValue(ishr0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq0, 1)
+                                    );
+
+// END_WHERE;
+// Instr #30
+SDNode *endwhere0 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload19, 1)
+                                    );
+
+// R18 = R25 == R28;
+// Instr #31
+SDNode *eq2 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload19, 0),
+                                    SDValue(vload4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere0, 0)
+                                    );
+
+// R18 = R18 | R17;
+// Instr #32
+SDNode *or0 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq0, 0),
+                                    SDValue(eq2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq2, 1)
+                                    );
+
+// R18 = R18 == R31;
+// Instr #33
+SDNode *eq3 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or0, 0),
+                                    SDValue(vload2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or0, 1)
+                                    );
+
+SDValue ct22 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #34
+SDNode *nop1 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct22,
+                                    // glue (or chain) input edge
+                                    SDValue(eq3, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #35
+SDNode *whereeq1 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop1, 0)
+                                    );
+
+// R26 = R26 | R10;
+// Instr #36
+SDNode *or1 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload8, 0),
+                                    SDValue(and2, 0),
+                                    SDValue(and2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq1, 1)
+                                    );
+
+// END_WHERE;
+// Instr #37
+SDNode *endwhere1 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(or1, 1)
+                                    );
+
+// R20 = R23 & R11;
+// Instr #38
+SDNode *and4 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload7, 0),
+                                    SDValue(nodeOpSrcCast2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere1, 0)
+                                    );
+
+// R21 = R23 & R12;
+// Instr #39
+SDNode *and5 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload6, 0),
+                                    SDValue(nodeOpSrcCast2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and4, 1)
+                                    );
+
+SDValue ct23 = CurDAG->getConstant(10, DL, MVT::i16, true, false);
+// R21 = R21 >> 10;
+// Instr #40
+SDNode *ishr1 = CurDAG->getMachineNode(
+                                    Connex::ISHRV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and5, 0),
+                                    ct23,
+                                    // glue (or chain) input edge
+                                    SDValue(and5, 1)
+                                    );
+
+// R22 = R23 & R13;
+// Instr #41
+SDNode *and6 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload5, 0),
+                                    SDValue(nodeOpSrcCast2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishr1, 1)
+                                    );
+
+// R16 = R31 < R22;
+// Instr #42
+SDNode *lt1 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(and6, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and6, 1)
+                                    );
+
+// R15 = R21 == R31;
+// Instr #43
+SDNode *eq4 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishr1, 0),
+                                    SDValue(vload2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt1, 1)
+                                    );
+
+// R09 = R15 & R16;
+// Instr #44
+SDNode *and7 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(lt1, 0),
+                                    SDValue(eq4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq4, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #45
+SDNode *eq5 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and7, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and7, 1)
+                                    );
+
+SDValue ct24 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #46
+SDNode *nop2 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct24,
+                                    // glue (or chain) input edge
+                                    SDValue(eq5, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #47
+SDNode *whereeq2 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq5, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop2, 0)
+                                    );
+
+SDValue ct25 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R21 = 1;
+// Instr #48
+SDNode *vload20 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct25,
+                                    SDValue(ishr1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq2, 1)
+                                    );
+
+// END_WHERE;
+// Instr #49
+SDNode *endwhere2 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload20, 1)
+                                    );
+
+// R16 = R21 == R28;
+// Instr #50
+SDNode *eq6 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload20, 0),
+                                    SDValue(vload4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere2, 0)
+                                    );
+
+// R16 = R16 | R15;
+// Instr #51
+SDNode *or2 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq4, 0),
+                                    SDValue(eq6, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq6, 1)
+                                    );
+
+// R16 = R16 == R31;
+// Instr #52
+SDNode *eq7 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or2, 0),
+                                    SDValue(vload2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or2, 1)
+                                    );
+
+SDValue ct26 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #53
+SDNode *nop3 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct26,
+                                    // glue (or chain) input edge
+                                    SDValue(eq7, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #54
+SDNode *whereeq3 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop3, 0)
+                                    );
+
+// R22 = R22 | R10;
+// Instr #55
+SDNode *or3 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload8, 0),
+                                    SDValue(and6, 0),
+                                    SDValue(and6, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq3, 1)
+                                    );
+
+// END_WHERE;
+// Instr #56
+SDNode *endwhere3 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(or3, 1)
+                                    );
+
+// R50 = R24 == R11;
+// Instr #57
+SDNode *eq8 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and0, 0),
+                                    SDValue(vload7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere3, 0)
+                                    );
+
+// R49 = R25 == R28;
+// Instr #58
+SDNode *eq9 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload19, 0),
+                                    SDValue(vload4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq8, 1)
+                                    );
+
+// R48 = R26 == R31;
+// Instr #59
+SDNode *eq10 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or1, 0),
+                                    SDValue(vload2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq9, 1)
+                                    );
+
+// R47 = R20 == R11;
+// Instr #60
+SDNode *eq11 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and4, 0),
+                                    SDValue(vload7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq10, 1)
+                                    );
+
+// R47 = R47 == R31;
+// Instr #61
+SDNode *eq12 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq11, 0),
+                                    SDValue(vload2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq11, 1)
+                                    );
+
+// R46 = R21 == R28;
+// Instr #62
+SDNode *eq13 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload20, 0),
+                                    SDValue(vload4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq12, 1)
+                                    );
+
+// R45 = R22 == R31;
+// Instr #63
+SDNode *eq14 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or3, 0),
+                                    SDValue(vload2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq13, 1)
+                                    );
+
+// R07 = R49 & R46;
+// Instr #64
+SDNode *and8 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq13, 0),
+                                    SDValue(eq9, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq14, 1)
+                                    );
+
+// R08 = R07 & R50;
+// Instr #65
+SDNode *and9 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq8, 0),
+                                    SDValue(and8, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and8, 1)
+                                    );
+
+// R44 = ~R47;
+// Instr #66
+SDNode *not0 = CurDAG->getMachineNode(
+                                    Connex::NOT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq12, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and9, 1)
+                                    );
+
+// R08 = R08 & R44;
+// Instr #67
+SDNode *and10 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(not0, 0),
+                                    SDValue(and9, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(not0, 1)
+                                    );
+
+// R44 = ~R50;
+// Instr #68
+SDNode *not1 = CurDAG->getMachineNode(
+                                    Connex::NOT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq8, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and10, 1)
+                                    );
+
+// R44 = R44 & R07;
+// Instr #69
+SDNode *and11 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and8, 0),
+                                    SDValue(not1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(not1, 1)
+                                    );
+
+// R44 = R44 & R47;
+// Instr #70
+SDNode *and12 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq12, 0),
+                                    SDValue(and11, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and11, 1)
+                                    );
+
+// R08 = R08 | R44;
+// Instr #71
+SDNode *or4 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and12, 0),
+                                    SDValue(and10, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and12, 1)
+                                    );
+
+// R07 = ~R45;
+// Instr #72
+SDNode *not2 = CurDAG->getMachineNode(
+                                    Connex::NOT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq14, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or4, 1)
+                                    );
+
+// R07 = R07 & R46;
+// Instr #73
+SDNode *and13 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq13, 0),
+                                    SDValue(not2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(not2, 1)
+                                    );
+
+// R08 = R08 | R07;
+// Instr #74
+SDNode *or5 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and13, 0),
+                                    SDValue(or4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and13, 1)
+                                    );
+
+// R07 = ~R48;
+// Instr #75
+SDNode *not3 = CurDAG->getMachineNode(
+                                    Connex::NOT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq10, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or5, 1)
+                                    );
+
+// R07 = R07 & R49;
+// Instr #76
+SDNode *and14 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq9, 0),
+                                    SDValue(not3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(not3, 1)
+                                    );
+
+// R08 = R08 | R07;
+// Instr #77
+SDNode *or6 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and14, 0),
+                                    SDValue(or5, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and14, 1)
+                                    );
+
+// R09 = R08 == R30;
+// Instr #78
+SDNode *eq15 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or6, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or6, 1)
+                                    );
+
+SDValue ct27 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #79
+SDNode *nop4 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct27,
+                                    // glue (or chain) input edge
+                                    SDValue(eq15, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #80
+SDNode *whereeq4 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq15, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop4, 0)
+                                    );
+
+SDValue ct28 = CurDAG->getConstant(31745, DL, MVT::i16, true, false);
+// R19 = 31745;
+// Instr #81
+SDNode *vload21 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct28,
+                                    SDValue(vload10, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq4, 1)
+                                    );
+
+SDValue ct29 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R14 = 0;
+// Instr #82
+SDNode *vload22 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct29,
+                                    SDValue(vload0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload21, 1)
+                                    );
+
+// END_WHERE;
+// Instr #83
+SDNode *endwhere4 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload22, 1)
+                                    );
+
+// R08 = R49 | R46;
+// Instr #84
+SDNode *or7 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq13, 0),
+                                    SDValue(eq9, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere4, 0)
+                                    );
+
+// R09 = R08 & R14;
+// Instr #85
+SDNode *and15 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload22, 0),
+                                    SDValue(or7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or7, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #86
+SDNode *eq16 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and15, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and15, 1)
+                                    );
+
+SDValue ct30 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #87
+SDNode *nop5 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct30,
+                                    // glue (or chain) input edge
+                                    SDValue(eq16, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #88
+SDNode *whereeq5 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq16, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop5, 0)
+                                    );
+
+SDValue ct31 = CurDAG->getConstant(31744, DL, MVT::i16, true, false);
+// R19 = 31744;
+// Instr #89
+SDNode *vload23 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct31,
+                                    SDValue(vload21, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq5, 1)
+                                    );
+
+// R08 = R50 & R49;
+// Instr #90
+SDNode *and16 = CurDAG->getMachineNode(
+                                    Connex::ANDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq9, 0),
+                                    SDValue(eq8, 0),
+                                    SDValue(or7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload23, 1)
+                                    );
+
+// R07 = R47 & R46;
+// Instr #91
+SDNode *and17 = CurDAG->getMachineNode(
+                                    Connex::ANDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq13, 0),
+                                    SDValue(eq12, 0),
+                                    SDValue(and14, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and16, 1)
+                                    );
+
+// R08 = R08 | R07;
+// Instr #92
+SDNode *or8 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and17, 0),
+                                    SDValue(and16, 0),
+                                    SDValue(and16, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and17, 1)
+                                    );
+
+SDValue ct32 = CurDAG->getConstant(15, DL, MVT::i16, true, false);
+// R08 = R08 << 15;
+// Instr #93
+SDNode *ishl0 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or8, 0),
+                                    ct32,
+                                    SDValue(or8, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or8, 1)
+                                    );
+
+// R19 = R19 ^ R08;
+// Instr #94
+SDNode *xor0 = CurDAG->getMachineNode(
+                                    Connex::XORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishl0, 0),
+                                    SDValue(vload23, 0),
+                                    SDValue(vload23, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl0, 1)
+                                    );
+
+SDValue ct33 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R14 = 0;
+// Instr #95
+SDNode *vload24 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct33,
+                                    SDValue(vload22, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(xor0, 1)
+                                    );
+
+// END_WHERE;
+// Instr #96
+SDNode *endwhere5 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload24, 1)
+                                    );
+
+// R15 = R25 - R21;
+// Instr #97
+SDNode *sub0 = CurDAG->getMachineNode(
+                                    Connex::SUBV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload19, 0),
+                                    SDValue(vload20, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere5, 0)
+                                    );
+
+SDValue ct34 = CurDAG->getConstant(-15, DL, MVT::i16, true, false);
+// R08 = -15;
+// Instr #98
+SDNode *vload25 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct34,
+                                    // glue (or chain) input edge
+                                    SDValue(sub0, 1)
+                                    );
+
+// R09 = R15 < R08;
+// Instr #99
+SDNode *lt2 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub0, 0),
+                                    SDValue(vload25, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload25, 1)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #100
+SDNode *and18 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(lt2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt2, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #101
+SDNode *eq17 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and18, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and18, 1)
+                                    );
+
+SDValue ct35 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #102
+SDNode *nop6 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct35,
+                                    // glue (or chain) input edge
+                                    SDValue(eq17, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #103
+SDNode *whereeq6 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq17, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop6, 0)
+                                    );
+
+// R15 = R31 - R15;
+// Instr #104
+SDNode *sub1 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(sub0, 0),
+                                    SDValue(sub0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq6, 1)
+                                    );
+
+SDValue ct36 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R26 = 0;
+// Instr #105
+SDNode *vload26 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct36,
+                                    SDValue(or1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub1, 1)
+                                    );
+
+SDValue ct37 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R25 = R21 << 0;
+// Instr #106
+SDNode *ishl1 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload20, 0),
+                                    ct37,
+                                    SDValue(vload19, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload26, 1)
+                                    );
+
+SDValue ct38 = CurDAG->getConstant(32000, DL, MVT::i16, true, false);
+// R15 = 32000;
+// Instr #107
+SDNode *vload27 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct38,
+                                    SDValue(sub1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl1, 1)
+                                    );
+
+// END_WHERE;
+// Instr #108
+SDNode *endwhere6 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload27, 1)
+                                    );
+
+SDValue ct39 = CurDAG->getConstant(-3, DL, MVT::i16, true, false);
+// R08 = -3;
+// Instr #109
+SDNode *vload28 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct39,
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere6, 0)
+                                    );
+
+// R09 = R15 < R08;
+// Instr #110
+SDNode *lt3 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload27, 0),
+                                    SDValue(vload28, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload28, 1)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #111
+SDNode *and19 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(lt3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt3, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #112
+SDNode *eq18 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and19, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and19, 1)
+                                    );
+
+SDValue ct40 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #113
+SDNode *nop7 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct40,
+                                    // glue (or chain) input edge
+                                    SDValue(eq18, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #114
+SDNode *whereeq7 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq18, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop7, 0)
+                                    );
+
+// R15 = R31 - R15;
+// Instr #115
+SDNode *sub2 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(vload27, 0),
+                                    SDValue(vload27, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq7, 1)
+                                    );
+
+// R26 = R26 >> R15;
+// Instr #116
+SDNode *shr0 = CurDAG->getMachineNode(
+                                    Connex::SHRV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload26, 0),
+                                    SDValue(sub2, 0),
+                                    SDValue(vload26, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub2, 1)
+                                    );
+
+SDValue ct41 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R25 = R21 << 0;
+// Instr #117
+SDNode *ishl2 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload20, 0),
+                                    ct41,
+                                    SDValue(ishl1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shr0, 1)
+                                    );
+
+SDValue ct42 = CurDAG->getConstant(32000, DL, MVT::i16, true, false);
+// R15 = 32000;
+// Instr #118
+SDNode *vload29 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct42,
+                                    SDValue(sub2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl2, 1)
+                                    );
+
+// END_WHERE;
+// Instr #119
+SDNode *endwhere7 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload29, 1)
+                                    );
+
+// R09 = R15 < R31;
+// Instr #120
+SDNode *lt4 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload29, 0),
+                                    SDValue(vload2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere7, 0)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #121
+SDNode *and20 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(lt4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt4, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #122
+SDNode *eq19 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and20, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and20, 1)
+                                    );
+
+SDValue ct43 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #123
+SDNode *nop8 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct43,
+                                    // glue (or chain) input edge
+                                    SDValue(eq19, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #124
+SDNode *whereeq8 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq19, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop8, 0)
+                                    );
+
+// R15 = R31 - R15;
+// Instr #125
+SDNode *sub3 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(vload29, 0),
+                                    SDValue(vload29, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq8, 1)
+                                    );
+
+// R22 = R22 << R15;
+// Instr #126
+SDNode *shl0 = CurDAG->getMachineNode(
+                                    Connex::SHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or3, 0),
+                                    SDValue(sub3, 0),
+                                    SDValue(or3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub3, 1)
+                                    );
+
+SDValue ct44 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R21 = R25 << 0;
+// Instr #127
+SDNode *ishl3 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishl2, 0),
+                                    ct44,
+                                    SDValue(vload20, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shl0, 1)
+                                    );
+
+SDValue ct45 = CurDAG->getConstant(32000, DL, MVT::i16, true, false);
+// R15 = 32000;
+// Instr #128
+SDNode *vload30 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct45,
+                                    SDValue(sub3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl3, 1)
+                                    );
+
+// END_WHERE;
+// Instr #129
+SDNode *endwhere8 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload30, 1)
+                                    );
+
+SDValue ct46 = CurDAG->getConstant(4, DL, MVT::i16, true, false);
+// R08 = 4;
+// Instr #130
+SDNode *vload31 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct46,
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere8, 0)
+                                    );
+
+// R09 = R15 < R08;
+// Instr #131
+SDNode *lt5 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload30, 0),
+                                    SDValue(vload31, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload31, 1)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #132
+SDNode *and21 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(lt5, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt5, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #133
+SDNode *eq20 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and21, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and21, 1)
+                                    );
+
+SDValue ct47 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #134
+SDNode *nop9 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct47,
+                                    // glue (or chain) input edge
+                                    SDValue(eq20, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #135
+SDNode *whereeq9 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq20, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop9, 0)
+                                    );
+
+// R26 = R26 << R15;
+// Instr #136
+SDNode *shl1 = CurDAG->getMachineNode(
+                                    Connex::SHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shr0, 0),
+                                    SDValue(vload30, 0),
+                                    SDValue(shr0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq9, 1)
+                                    );
+
+SDValue ct48 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R25 = R21 << 0;
+// Instr #137
+SDNode *ishl4 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishl3, 0),
+                                    ct48,
+                                    SDValue(ishl2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shl1, 1)
+                                    );
+
+SDValue ct49 = CurDAG->getConstant(32000, DL, MVT::i16, true, false);
+// R15 = 32000;
+// Instr #138
+SDNode *vload32 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct49,
+                                    SDValue(vload30, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl4, 1)
+                                    );
+
+// END_WHERE;
+// Instr #139
+SDNode *endwhere9 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload32, 1)
+                                    );
+
+// R09 = R15 < R29;
+// Instr #140
+SDNode *lt6 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload32, 0),
+                                    SDValue(vload3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere9, 0)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #141
+SDNode *and22 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(lt6, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt6, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #142
+SDNode *eq21 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and22, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and22, 1)
+                                    );
+
+SDValue ct50 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #143
+SDNode *nop10 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct50,
+                                    // glue (or chain) input edge
+                                    SDValue(eq21, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #144
+SDNode *whereeq10 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq21, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop10, 0)
+                                    );
+
+// R22 = R22 >> R15;
+// Instr #145
+SDNode *shr1 = CurDAG->getMachineNode(
+                                    Connex::SHRV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl0, 0),
+                                    SDValue(vload32, 0),
+                                    SDValue(shl0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq10, 1)
+                                    );
+
+SDValue ct51 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R21 = R25 << 0;
+// Instr #146
+SDNode *ishl5 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishl4, 0),
+                                    ct51,
+                                    SDValue(ishl3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shr1, 1)
+                                    );
+
+SDValue ct52 = CurDAG->getConstant(32000, DL, MVT::i16, true, false);
+// R15 = 32000;
+// Instr #147
+SDNode *vload33 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct52,
+                                    SDValue(vload32, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl5, 1)
+                                    );
+
+// END_WHERE;
+// Instr #148
+SDNode *endwhere10 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload33, 1)
+                                    );
+
+SDValue ct53 = CurDAG->getConstant(32, DL, MVT::i16, true, false);
+// R08 = 32;
+// Instr #149
+SDNode *vload34 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct53,
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere10, 0)
+                                    );
+
+// R09 = R15 < R08;
+// Instr #150
+SDNode *lt7 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload33, 0),
+                                    SDValue(vload34, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload34, 1)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #151
+SDNode *and23 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(lt7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt7, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #152
+SDNode *eq22 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and23, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and23, 1)
+                                    );
+
+SDValue ct54 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #153
+SDNode *nop11 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct54,
+                                    // glue (or chain) input edge
+                                    SDValue(eq22, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #154
+SDNode *whereeq11 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq22, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop11, 0)
+                                    );
+
+SDValue ct55 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R22 = 0;
+// Instr #155
+SDNode *vload35 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct55,
+                                    SDValue(shr1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq11, 1)
+                                    );
+
+SDValue ct56 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R21 = R25 << 0;
+// Instr #156
+SDNode *ishl6 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishl4, 0),
+                                    ct56,
+                                    SDValue(ishl5, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload35, 1)
+                                    );
+
+// END_WHERE;
+// Instr #157
+SDNode *endwhere11 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(ishl6, 1)
+                                    );
+
+// R09 = R24 == R11;
+// Instr #158
+SDNode *eq23 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and0, 0),
+                                    SDValue(vload7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere11, 0)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #159
+SDNode *and24 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(eq23, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq23, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #160
+SDNode *eq24 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and24, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and24, 1)
+                                    );
+
+SDValue ct57 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #161
+SDNode *nop12 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct57,
+                                    // glue (or chain) input edge
+                                    SDValue(eq24, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #162
+SDNode *whereeq12 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq24, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop12, 0)
+                                    );
+
+// R26 = R31 - R26;
+// Instr #163
+SDNode *sub4 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(shl1, 0),
+                                    SDValue(shl1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq12, 1)
+                                    );
+
+// END_WHERE;
+// Instr #164
+SDNode *endwhere12 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(sub4, 1)
+                                    );
+
+// R09 = R20 == R31;
+// Instr #165
+SDNode *eq25 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and4, 0),
+                                    SDValue(vload2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere12, 0)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #166
+SDNode *and25 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(eq25, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq25, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #167
+SDNode *eq26 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and25, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and25, 1)
+                                    );
+
+SDValue ct58 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #168
+SDNode *nop13 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct58,
+                                    // glue (or chain) input edge
+                                    SDValue(eq26, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #169
+SDNode *whereeq13 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq26, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop13, 0)
+                                    );
+
+// R22 = R31 - R22;
+// Instr #170
+SDNode *sub5 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(vload35, 0),
+                                    SDValue(vload35, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq13, 1)
+                                    );
+
+// END_WHERE;
+// Instr #171
+SDNode *endwhere13 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(sub5, 1)
+                                    );
+
+// R09 = R14 == R30;
+// Instr #172
+SDNode *eq27 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere13, 0)
+                                    );
+
+SDValue ct59 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #173
+SDNode *nop14 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct59,
+                                    // glue (or chain) input edge
+                                    SDValue(eq27, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #174
+SDNode *whereeq14 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq27, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop14, 0)
+                                    );
+
+// R26 = R22 + R26;
+// Instr #175
+SDNode *add0 = CurDAG->getMachineNode(
+                                    Connex::ADDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub4, 0),
+                                    SDValue(sub5, 0),
+                                    SDValue(sub4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq14, 1)
+                                    );
+
+// END_WHERE;
+// Instr #176
+SDNode *endwhere14 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(add0, 1)
+                                    );
+
+// R24 = R26 & R11;
+// Instr #177
+SDNode *and26 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload7, 0),
+                                    SDValue(add0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere14, 0)
+                                    );
+
+// R09 = R24 == R11;
+// Instr #178
+SDNode *eq28 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and26, 0),
+                                    SDValue(vload7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and26, 1)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #179
+SDNode *and27 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(eq28, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq28, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #180
+SDNode *eq29 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and27, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and27, 1)
+                                    );
+
+SDValue ct60 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #181
+SDNode *nop15 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct60,
+                                    // glue (or chain) input edge
+                                    SDValue(eq29, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #182
+SDNode *whereeq15 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq29, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop15, 0)
+                                    );
+
+// R26 = R31 - R26;
+// Instr #183
+SDNode *sub6 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(add0, 0),
+                                    SDValue(add0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq15, 1)
+                                    );
+
+// END_WHERE;
+// Instr #184
+SDNode *endwhere15 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(sub6, 1)
+                                    );
+
+SDValue ct61 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R05 = R26 << 0;
+// Instr #185
+SDNode *ishl7 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub6, 0),
+                                    ct61,
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere15, 0)
+                                    );
+
+SDValue ct62 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R08 = R05 >> 1;
+// Instr #186
+SDNode *ishr2 = CurDAG->getMachineNode(
+                                    Connex::ISHRV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishl7, 0),
+                                    ct62,
+                                    // glue (or chain) input edge
+                                    SDValue(ishl7, 1)
+                                    );
+
+// R05 = R05 | R08;
+// Instr #187
+SDNode *or9 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishr2, 0),
+                                    SDValue(ishl7, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishr2, 1)
+                                    );
+
+SDValue ct63 = CurDAG->getConstant(2, DL, MVT::i16, true, false);
+// R08 = R05 >> 2;
+// Instr #188
+SDNode *ishr3 = CurDAG->getMachineNode(
+                                    Connex::ISHRV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or9, 0),
+                                    ct63,
+                                    // glue (or chain) input edge
+                                    SDValue(or9, 1)
+                                    );
+
+// R05 = R05 | R08;
+// Instr #189
+SDNode *or10 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishr3, 0),
+                                    SDValue(or9, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishr3, 1)
+                                    );
+
+SDValue ct64 = CurDAG->getConstant(4, DL, MVT::i16, true, false);
+// R08 = R05 >> 4;
+// Instr #190
+SDNode *ishr4 = CurDAG->getMachineNode(
+                                    Connex::ISHRV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or10, 0),
+                                    ct64,
+                                    // glue (or chain) input edge
+                                    SDValue(or10, 1)
+                                    );
+
+// R05 = R05 | R08;
+// Instr #191
+SDNode *or11 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishr4, 0),
+                                    SDValue(or10, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishr4, 1)
+                                    );
+
+SDValue ct65 = CurDAG->getConstant(8, DL, MVT::i16, true, false);
+// R08 = R05 >> 8;
+// Instr #192
+SDNode *ishr5 = CurDAG->getMachineNode(
+                                    Connex::ISHRV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or11, 0),
+                                    ct65,
+                                    // glue (or chain) input edge
+                                    SDValue(or11, 1)
+                                    );
+
+// R05 = R05 | R08;
+// Instr #193
+SDNode *or12 = CurDAG->getMachineNode(
+                                    Connex::ORV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishr5, 0),
+                                    SDValue(or11, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishr5, 1)
+                                    );
+
+// R05 = ~R05;
+// Instr #194
+SDNode *not4 = CurDAG->getMachineNode(
+                                    Connex::NOT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or12, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or12, 1)
+                                    );
+
+// R06 = POPCNT(R05);
+// Instr #195
+SDNode *popcnt0 = CurDAG->getMachineNode(
+                                    Connex::POPCNT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(not4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(not4, 1)
+                                    );
+
+// R06 = R29 - R06;
+// Instr #196
+SDNode *sub7 = CurDAG->getMachineNode(
+                                    Connex::SUBV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload3, 0),
+                                    SDValue(popcnt0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(popcnt0, 1)
+                                    );
+
+SDValue ct66 = CurDAG->getConstant(11, DL, MVT::i16, true, false);
+// R08 = 11;
+// Instr #197
+SDNode *vload36 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct66,
+                                    // glue (or chain) input edge
+                                    SDValue(sub7, 1)
+                                    );
+
+// R08 = R06 - R08;
+// Instr #198
+SDNode *sub8 = CurDAG->getMachineNode(
+                                    Connex::SUBV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub7, 0),
+                                    SDValue(vload36, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload36, 1)
+                                    );
+
+// R09 = R31 < R08;
+// Instr #199
+SDNode *lt8 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(sub8, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub8, 1)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #200
+SDNode *and28 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(lt8, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt8, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #201
+SDNode *eq30 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and28, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and28, 1)
+                                    );
+
+SDValue ct67 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #202
+SDNode *nop16 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct67,
+                                    // glue (or chain) input edge
+                                    SDValue(eq30, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #203
+SDNode *whereeq16 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq30, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop16, 0)
+                                    );
+
+SDValue ct68 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R62 = R26 << 0;
+// Instr #204
+SDNode *ishl8 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub6, 0),
+                                    ct68,
+                                    SDValue(vload11, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq16, 1)
+                                    );
+
+// R09 = R29 - R08;
+// Instr #205
+SDNode *sub9 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload3, 0),
+                                    SDValue(sub8, 0),
+                                    SDValue(eq30, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl8, 1)
+                                    );
+
+// R62 = R62 << R09;
+// Instr #206
+SDNode *shl2 = CurDAG->getMachineNode(
+                                    Connex::SHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishl8, 0),
+                                    SDValue(sub9, 0),
+                                    SDValue(ishl8, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub9, 1)
+                                    );
+
+// R62 = R62 >> R09;
+// Instr #207
+SDNode *shr2 = CurDAG->getMachineNode(
+                                    Connex::SHRV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl2, 0),
+                                    SDValue(sub9, 0),
+                                    SDValue(shl2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shl2, 1)
+                                    );
+
+SDValue ct69 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R61 = R08 << 0;
+// Instr #208
+SDNode *ishl9 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub8, 0),
+                                    ct69,
+                                    SDValue(vload12, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shr2, 1)
+                                    );
+
+// R26 = R26 >> R08;
+// Instr #209
+SDNode *shr3 = CurDAG->getMachineNode(
+                                    Connex::SHRV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub6, 0),
+                                    SDValue(sub8, 0),
+                                    SDValue(sub6, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl9, 1)
+                                    );
+
+// R25 = R08 + R25;
+// Instr #210
+SDNode *add1 = CurDAG->getMachineNode(
+                                    Connex::ADDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishl4, 0),
+                                    SDValue(sub8, 0),
+                                    SDValue(ishl4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shr3, 1)
+                                    );
+
+// END_WHERE;
+// Instr #211
+SDNode *endwhere16 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(add1, 1)
+                                    );
+
+// R09 = R08 < R31;
+// Instr #212
+SDNode *lt9 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub8, 0),
+                                    SDValue(vload2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere16, 0)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #213
+SDNode *and29 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(lt9, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt9, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #214
+SDNode *eq31 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and29, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and29, 1)
+                                    );
+
+SDValue ct70 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #215
+SDNode *nop17 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct70,
+                                    // glue (or chain) input edge
+                                    SDValue(eq31, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #216
+SDNode *whereeq17 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq31, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop17, 0)
+                                    );
+
+// R08 = R31 - R08;
+// Instr #217
+SDNode *sub10 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(sub8, 0),
+                                    SDValue(sub8, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq17, 1)
+                                    );
+
+// R26 = R26 << R08;
+// Instr #218
+SDNode *shl3 = CurDAG->getMachineNode(
+                                    Connex::SHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shr3, 0),
+                                    SDValue(sub10, 0),
+                                    SDValue(shr3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub10, 1)
+                                    );
+
+// R25 = R25 - R08;
+// Instr #219
+SDNode *sub11 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(add1, 0),
+                                    SDValue(sub10, 0),
+                                    SDValue(add1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shl3, 1)
+                                    );
+
+// END_WHERE;
+// Instr #220
+SDNode *endwhere17 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(sub11, 1)
+                                    );
+
+// R09 = R25 < R30;
+// Instr #221
+SDNode *lt10 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub11, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere17, 0)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #222
+SDNode *and30 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(lt10, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt10, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #223
+SDNode *eq32 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and30, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and30, 1)
+                                    );
+
+SDValue ct71 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #224
+SDNode *nop18 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct71,
+                                    // glue (or chain) input edge
+                                    SDValue(eq32, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #225
+SDNode *whereeq18 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq32, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop18, 0)
+                                    );
+
+// R61 = R30 - R25;
+// Instr #226
+SDNode *sub12 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(sub11, 0),
+                                    SDValue(ishl9, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq18, 1)
+                                    );
+
+SDValue ct72 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R25 = 1;
+// Instr #227
+SDNode *vload37 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct72,
+                                    SDValue(sub11, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub12, 1)
+                                    );
+
+SDValue ct73 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R62 = R26 << 0;
+// Instr #228
+SDNode *ishl10 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl3, 0),
+                                    ct73,
+                                    SDValue(shr2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload37, 1)
+                                    );
+
+// R09 = R29 - R61;
+// Instr #229
+SDNode *sub13 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload3, 0),
+                                    SDValue(sub12, 0),
+                                    SDValue(eq32, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl10, 1)
+                                    );
+
+// R62 = R62 << R09;
+// Instr #230
+SDNode *shl4 = CurDAG->getMachineNode(
+                                    Connex::SHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishl10, 0),
+                                    SDValue(sub13, 0),
+                                    SDValue(ishl10, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub13, 1)
+                                    );
+
+// R62 = R62 >> R09;
+// Instr #231
+SDNode *shr4 = CurDAG->getMachineNode(
+                                    Connex::SHRV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl4, 0),
+                                    SDValue(sub13, 0),
+                                    SDValue(shl4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shl4, 1)
+                                    );
+
+// R26 = R26 >> R61;
+// Instr #232
+SDNode *shr5 = CurDAG->getMachineNode(
+                                    Connex::SHRV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl3, 0),
+                                    SDValue(sub12, 0),
+                                    SDValue(shl3, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shr4, 1)
+                                    );
+
+// END_WHERE;
+// Instr #233
+SDNode *endwhere18 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(shr5, 1)
+                                    );
+
+SDValue ct74 = CurDAG->getConstant(1024, DL, MVT::i16, true, false);
+// R08 = 1024;
+// Instr #234
+SDNode *vload38 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct74,
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere18, 0)
+                                    );
+
+// R08 = R26 < R08;
+// Instr #235
+SDNode *lt11 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shr5, 0),
+                                    SDValue(vload38, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload38, 1)
+                                    );
+
+// R09 = R25 == R30;
+// Instr #236
+SDNode *eq33 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload37, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt11, 1)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #237
+SDNode *and31 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(eq33, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq33, 1)
+                                    );
+
+// R09 = R09 & R08;
+// Instr #238
+SDNode *and32 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(lt11, 0),
+                                    SDValue(and31, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and31, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #239
+SDNode *eq34 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and32, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and32, 1)
+                                    );
+
+SDValue ct75 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #240
+SDNode *nop19 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct75,
+                                    // glue (or chain) input edge
+                                    SDValue(eq34, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #241
+SDNode *whereeq19 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq34, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop19, 0)
+                                    );
+
+SDValue ct76 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R25 = 0;
+// Instr #242
+SDNode *vload39 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct76,
+                                    SDValue(vload37, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq19, 1)
+                                    );
+
+// END_WHERE;
+// Instr #243
+SDNode *endwhere19 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload39, 1)
+                                    );
+
+// R26 = R26 & R13;
+// Instr #244
+SDNode *and33 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload5, 0),
+                                    SDValue(shr5, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere19, 0)
+                                    );
+
+SDValue ct77 = CurDAG->getConstant(30, DL, MVT::i16, true, false);
+// R09 = 30;
+// Instr #245
+SDNode *vload40 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct77,
+                                    // glue (or chain) input edge
+                                    SDValue(and33, 1)
+                                    );
+
+// R09 = R09 < R25;
+// Instr #246
+SDNode *lt12 = CurDAG->getMachineNode(
+                                    Connex::LT_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload40, 0),
+                                    SDValue(vload39, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload40, 1)
+                                    );
+
+// R09 = R09 & R14;
+// Instr #247
+SDNode *and34 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload24, 0),
+                                    SDValue(lt12, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(lt12, 1)
+                                    );
+
+// R09 = R09 == R30;
+// Instr #248
+SDNode *eq35 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and34, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and34, 1)
+                                    );
+
+SDValue ct78 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #249
+SDNode *nop20 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct78,
+                                    // glue (or chain) input edge
+                                    SDValue(eq35, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #250
+SDNode *whereeq20 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq35, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop20, 0)
+                                    );
+
+SDValue ct79 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R14 = 0;
+// Instr #251
+SDNode *vload41 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct79,
+                                    SDValue(vload24, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq20, 1)
+                                    );
+
+SDValue ct80 = CurDAG->getConstant(31744, DL, MVT::i16, true, false);
+// R19 = 31744;
+// Instr #252
+SDNode *vload42 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct80,
+                                    SDValue(xor0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload41, 1)
+                                    );
+
+// R19 = R19 | R24;
+// Instr #253
+SDNode *or13 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and26, 0),
+                                    SDValue(vload42, 0),
+                                    SDValue(vload42, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload42, 1)
+                                    );
+
+// END_WHERE;
+// Instr #254
+SDNode *endwhere20 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(or13, 1)
+                                    );
+
+// R08 = R14 == R30;
+// Instr #255
+SDNode *eq36 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload41, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere20, 0)
+                                    );
+
+SDValue ct81 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #256
+SDNode *nop21 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct81,
+                                    // glue (or chain) input edge
+                                    SDValue(eq36, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #257
+SDNode *whereeq21 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq36, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop21, 0)
+                                    );
+
+SDValue ct82 = CurDAG->getConstant(10, DL, MVT::i16, true, false);
+// R19 = R25 << 10;
+// Instr #258
+SDNode *ishl11 = CurDAG->getMachineNode(
+                                    Connex::ISHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload39, 0),
+                                    ct82,
+                                    SDValue(or13, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq21, 1)
+                                    );
+
+// R19 = R19 | R26;
+// Instr #259
+SDNode *or14 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and33, 0),
+                                    SDValue(ishl11, 0),
+                                    SDValue(ishl11, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishl11, 1)
+                                    );
+
+// R04 = R26 & R30;
+// Instr #260
+SDNode *and35 = CurDAG->getMachineNode(
+                                    Connex::ANDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(and33, 0),
+                                    SDValue(vload14, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or14, 1)
+                                    );
+
+// R07 = R61 - R30;
+// Instr #261
+SDNode *sub14 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub12, 0),
+                                    SDValue(vload1, 0),
+                                    SDValue(and17, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and35, 1)
+                                    );
+
+// R08 = R30 << R08;
+// Instr #262
+SDNode *shl5 = CurDAG->getMachineNode(
+                                    Connex::SHLV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(eq36, 0),
+                                    SDValue(eq36, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub14, 1)
+                                    );
+
+// R03 = R62 & R08;
+// Instr #263
+SDNode *and36 = CurDAG->getMachineNode(
+                                    Connex::ANDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl5, 0),
+                                    SDValue(shr4, 0),
+                                    SDValue(vload15, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(shl5, 1)
+                                    );
+
+// R62 = R62 ^ R03;
+// Instr #264
+SDNode *xor1 = CurDAG->getMachineNode(
+                                    Connex::XORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and36, 0),
+                                    SDValue(shr4, 0),
+                                    SDValue(shr4, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and36, 1)
+                                    );
+
+// R03 = R03 == R31;
+// Instr #265
+SDNode *eq37 = CurDAG->getMachineNode(
+                                    Connex::EQ_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and36, 0),
+                                    SDValue(vload2, 0),
+                                    SDValue(and36, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(xor1, 1)
+                                    );
+
+// R03 = R30 - R03;
+// Instr #266
+SDNode *sub15 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(eq37, 0),
+                                    SDValue(eq37, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq37, 1)
+                                    );
+
+SDValue ct83 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R08 = R08 >> 1;
+// Instr #267
+SDNode *ishr6 = CurDAG->getMachineNode(
+                                    Connex::ISHRV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(shl5, 0),
+                                    ct83,
+                                    SDValue(shl5, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub15, 1)
+                                    );
+
+// R02 = R62 & R08;
+// Instr #268
+SDNode *and37 = CurDAG->getMachineNode(
+                                    Connex::ANDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(ishr6, 0),
+                                    SDValue(xor1, 0),
+                                    SDValue(vload16, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ishr6, 1)
+                                    );
+
+// R62 = R62 ^ R02;
+// Instr #269
+SDNode *xor2 = CurDAG->getMachineNode(
+                                    Connex::XORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and37, 0),
+                                    SDValue(xor1, 0),
+                                    SDValue(xor1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and37, 1)
+                                    );
+
+// R02 = R02 == R31;
+// Instr #270
+SDNode *eq38 = CurDAG->getMachineNode(
+                                    Connex::EQ_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and37, 0),
+                                    SDValue(vload2, 0),
+                                    SDValue(and37, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(xor2, 1)
+                                    );
+
+// R02 = R30 - R02;
+// Instr #271
+SDNode *sub16 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(eq38, 0),
+                                    SDValue(eq38, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq38, 1)
+                                    );
+
+// R01 = R62 == R31;
+// Instr #272
+SDNode *eq39 = CurDAG->getMachineNode(
+                                    Connex::EQ_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(xor2, 0),
+                                    SDValue(vload2, 0),
+                                    SDValue(vload17, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub16, 1)
+                                    );
+
+// R01 = R30 - R01;
+// Instr #273
+SDNode *sub17 = CurDAG->getMachineNode(
+                                    Connex::SUBV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(eq39, 0),
+                                    SDValue(eq39, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(eq39, 1)
+                                    );
+
+// R00 = R04 | R02;
+// Instr #274
+SDNode *or15 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub16, 0),
+                                    SDValue(and35, 0),
+                                    SDValue(vload18, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(sub17, 1)
+                                    );
+
+// R00 = R00 | R01;
+// Instr #275
+SDNode *or16 = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub17, 0),
+                                    SDValue(or15, 0),
+                                    SDValue(or15, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or15, 1)
+                                    );
+
+// R00 = R00 & R03;
+// Instr #276
+SDNode *and38 = CurDAG->getMachineNode(
+                                    Connex::ANDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub15, 0),
+                                    SDValue(or16, 0),
+                                    SDValue(or16, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(or16, 1)
+                                    );
+
+// R19 = R00 + R19;
+// Instr #277
+SDNode *add2 = CurDAG->getMachineNode(
+                                    Connex::ADDV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(or14, 0),
+                                    SDValue(and38, 0),
+                                    SDValue(or14, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and38, 1)
+                                    );
+
+// R19 = R19 | R24;
+// Instr #278
+SDNode *resF16 /*or17*/ = CurDAG->getMachineNode(
+                                    Connex::ORV_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and26, 0),
+                                    SDValue(add2, 0),
+                                    SDValue(add2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(add2, 1)
+                                    );
+
+// END_WHERE;
+// Instr #279
+SDNode *lastNode /*endwhere21*/ = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+// Alex:                                    MVT::Glue,
+                                    MVT::Other,
+                                    // glue (or chain) input edge
+                                    SDValue(resF16 /*or17*/, 1)
+                                    );
+

lib/Target/Connex/Select_SUBi32_OpincaaCodeGen.cpp

+// From /home/asusu/LLVM/llvm38Nov2016/llvm/build40/bin/Tests/NEW_v128i16/opincaa_standalone_apps/Emulate_i32/SUB_i32_manual/DumpISel_OpincaaCodeGen_old110_400.cpp
+
+// R27 is REG_SRC1. It is represented by result of nodeOpSrcCast1.
+// R28 is REG_SRC2. It is represented by result of nodeOpSrcCast2.
+
+
+
+// Code auto-generated by method Kernel::genLLVMISelManualCode() 
+//   from Opincaa lib from kernel: simpleIoTest_allowOverwrite123456.
+// It is important to put this code in the Select() method of the
+//   SelectionDAGISel class of your back end, after the ISelLowering pass,
+//   which contains the DAG Combiner, because the DAG Combiner can remove
+//   the getCopyToReg() we create, which can lead to the following error:
+//   <<Register use before def!>> assertion failed.
+// Number of instructions generated: 15.
+
+
+
+
+SDValue ct0 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R31 = 0;
+// Instr #0
+SDNode *vload0 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct0,
+                                    // glue (or chain) input edge
+                                    SDValue(nodeOpSrcCast2, 1)
+                                    );
+
+SDValue ct1 = CurDAG->getConstant(1, DL, MVT::i16, true, false);
+// R30 = 1;
+// Instr #1
+SDNode *vload1 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct1,
+                                    // glue (or chain) input edge
+                                    SDValue(vload0, 1)
+                                    );
+
+// R29 = R27 - R28;
+// Instr #2
+SDNode *sub0 = CurDAG->getMachineNode(
+                                    Connex::SUBV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(nodeOpSrcCast1, 0),
+                                    SDValue(nodeOpSrcCast2, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(vload1, 1)
+                                    );
+
+// R23 = ADDC(R31, R31);
+// Instr #3
+SDNode *addc0 = CurDAG->getMachineNode(
+                                    Connex::ADDCV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload0, 0),
+                                    SDValue(vload0, 0),
+                                    SDValue(sub0, 0)
+                                    // no need for glue or chain input (since it normally consumes the output of the predecessor)
+                                    );
+
+// R26 = INDEX;
+// Instr #4
+SDNode *ldix0 = CurDAG->getMachineNode(
+                                    Connex::LDIX_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(addc0, 1)
+                                    );
+
+// R25 = R26 & R30;
+// Instr #5
+SDNode *and0 = CurDAG->getMachineNode(
+                                    Connex::ANDV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(vload1, 0),
+                                    SDValue(ldix0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ldix0, 1)
+                                    );
+
+// R24 = R25 == R30;
+// Instr #6
+SDNode *eq0 = CurDAG->getMachineNode(
+                                    Connex::EQ_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(and0, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(and0, 1)
+                                    );
+
+SDValue ct2 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #7
+SDNode *nop0 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct2,
+                                    // glue (or chain) input edge
+                                    SDValue(eq0, 1)
+                                    );
+
+// WHERE_EQ;
+// Instr #8
+SDNode *whereeq0 = CurDAG->getMachineNode(
+                                    Connex::WHEREEQ,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(eq0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(nop0, 0)
+                                    );
+
+SDValue ct3 = CurDAG->getConstant(0, DL, MVT::i16, true, false);
+// R23 = 0;
+// Instr #9
+SDNode *vload2 = CurDAG->getMachineNode(
+                                    Connex::VLOAD_SPECIAL_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    ct3,
+                                    SDValue(addc0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(whereeq0, 1)
+                                    );
+
+// END_WHERE;
+// Instr #10
+SDNode *endwhere0 = CurDAG->getMachineNode(
+                                    Connex::END_WHERE,
+                                    DL,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(vload2, 1)
+                                    );
+
+// CELL_SHR(R23, R30);
+// Instr #11
+SDNode *cellshr0 = CurDAG->getMachineNode(
+                                    Connex::CELLSHR_H,
+                                    DL,
+                                    MVT::Glue,
+                                    SDValue(vload2, 0),
+                                    SDValue(vload1, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(endwhere0, 0)
+                                    );
+
+SDValue ct4 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false);
+// NOP;
+// Instr #12
+SDNode *nop1 = CurDAG->getMachineNode(
+                                    Connex::NOP_BPF,
+                                    DL,
+                                    MVT::Glue,
+                                    ct4,
+                                    // glue (or chain) input edge
+                                    SDValue(cellshr0, 0)
+                                    );
+
+// R23 = SHIFT_REG;
+// Instr #13
+SDNode *ldsh0 = CurDAG->getMachineNode(
+                                    Connex::LDSH_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    // glue (or chain) input edge
+                                    SDValue(nop1, 0)
+                                    );
+
+// R29 = R29 - R23;
+// Instr #14
+SDNode *resH /*sub1*/ = CurDAG->getMachineNode(
+                                    Connex::SUBV_H,
+                                    DL,
+                                    TYPE_VECTOR_I16,
+                                    MVT::Glue,
+                                    SDValue(sub0, 0),
+                                    SDValue(ldsh0, 0),
+                                    // glue (or chain) input edge
+                                    SDValue(ldsh0, 1)
+                                    );
+
+SDNode *lastNode = resH;

lib/Target/LLVMBuild.txt

 [common]
 subdirectories =
  AMDGPU
  ARC
  ARM
  AArch64
  AVR
  BPF
+ Connex
  Lanai
  Hexagon
  MSP430
  NVPTX
  Mips
  PowerPC
  RISCV
  Sparc