.DirectControlPredecessors(
               to_merge,
               [&c](Operation* pred) {
                 Operation* const last_c_op = c.ops.back();
                 return last_c_op->getBlock() == pred->getBlock() &&
                        last_c_op->isBeforeInBlock(pred);
               })
           .empty();
  if (has_control_predecessors_after_cluster) {
    return false;
  }

                 const TF::SideEffectAnalysis::Info& side_effect_analysis) {
  // IfRegion ops must be in the same block.
  if (second_if.getOperation()->getBlock() !=
      first_if.getOperation()->getBlock()) {
    return false;
  }
  assert(first_if.getOperation()->isBeforeInBlock(second_if.getOperation()));

  llvm::SmallSetVector<Operation*, 4> destination_ops =

		Archreloc:        archreloc,
		Archrelocvariant: archrelocvariant,
		Extreloc:         extreloc,
		Trampoline:       trampoline,
		Gentext:          gentext,
		Machoreloc1:      machoreloc1,
		PEreloc1:         pereloc1,

		ELF: ld.ELFArch{
			Linuxdynld:     "/lib/ld-linux.so.3", // 2 for OABI, 3 for EABI
			LinuxdynldMusl: "/lib/ld-musl-arm.so.1",
			Freebsddynld:   "/usr/libexec/ld-elf.so.1",

		Adddynrel:        adddynrel,
		Archinit:         archinit,
		Archreloc:        archreloc,
		Archrelocvariant: archrelocvariant,
		Gentext:          gentext,
		Machoreloc1:      machoreloc1,
		PEreloc1:         pereloc1,

		ELF: ld.ELFArch{
			Linuxdynld:     "/lib/ld-linux.so.2",
			LinuxdynldMusl: "/lib/ld-musl-i386.so.1",
			Freebsddynld:   "/usr/libexec/ld-elf.so.1",
			Openbsddynld:   "/usr/libexec/ld.so",

				}
			}
		}
		for _, ctl := range block.ControlValues() {
			// for control values that can become constants, find their use blocks
			if possibleConst(ctl) {
				t.defBlock[ctl] = append(t.defBlock[ctl], block)
			}
		}
	}
}

// addUses finds all uses of value and appends them into work list for further process
func (t *worklist) addUses(val *Value) {
	for _, use := range t.defUse[val] {

					// the new blocks to be re-examined.
					d = f.NewBlock(BlockPlain)
					d.Pos = p.Pos
					blocks[argID] = d
					if f.pass.debug > 0 {
						f.Warnl(p.Pos, "split critical edge")
					}
				} else {
					reusedBlock = true
				}
			} else {
				// no existing block, so allocate a new block
				// to place on the edge
				d = f.NewBlock(BlockPlain)
				d.Pos = p.Pos
				if f.pass.debug > 0 {

	// |--r.window--|--r.buffer--|
	//        |<-----offset------|
	//        |------match----------->|
	bufferOffset := uint32(0)
	lenBlock := uint32(len(r.buffer))
	if lenBlock < offset {
		lenWindow := r.window.len()
		copy := offset - lenBlock
		if copy > lenWindow {
			return rbr.makeError("offset past window")
		}
		windowOffset := lenWindow - copy
		if copy > match {
			copy = match
		}

		Archinit:         archinit,
		Archreloc:        archreloc,
		Archrelocvariant: archrelocvariant,
		Gentext:          gentext,
		Machoreloc1:      machoreloc1,
		MachorelocSize:   8,
		PEreloc1:         pereloc1,
		TLSIEtoLE:        tlsIEtoLE,

		ELF: ld.ELFArch{
			Linuxdynld:     "/lib64/ld-linux-x86-64.so.2",
			LinuxdynldMusl: "/lib/ld-musl-x86_64.so.1",
			Freebsddynld:   "/libexec/ld-elf.so.1",

		Archrelocvariant: archrelocvariant,
		Extreloc:         extreloc,
		Gentext:          gentext,
		GenSymsLate:      gensymlate,
		Machoreloc1:      machoreloc1,
		MachorelocSize:   8,
		PEreloc1:         pereloc1,
		Trampoline:       trampoline,

		ELF: ld.ELFArch{
			Androiddynld:   "/system/bin/linker64",
			Linuxdynld:     "/lib/ld-linux-aarch64.so.1",
			LinuxdynldMusl: "/lib/ld-musl-aarch64.so.1",

    assert(op && "member operation must be not null");

    for (Operation *user : op->getUsers()) {
      // Skip users in other blocks.
      if (user->getBlock() != op->getBlock()) continue;

      // Skip users is in the `dst_root` or `src_root` clusters, if we'll merge
      // roots they'll become a single cluster and will not violate the
      // dominance property after that.