rewriter))
    return success();
  return failure();
}

LogicalResult ConvertTFMatMulOp::matchAndRewrite(
    Operation* op, PatternRewriter& rewriter) const {
  auto tf_matmul_op = cast<TF::MatMulOp>(op);
  auto lhs = op->getOperand(0);
  auto rhs = op->getOperand(1);

namespace {

// Returns true if the given op is TF/XLA communication op in the old bridge.
bool IsCommunicationOp(Operation* op) {
  return isa<TF::XlaHostComputeOp, TF::XlaSendToHostOp, TF::XlaRecvFromHostOp>(
      op);
}

// Returns true if the given op is one of ops supported to have communication
// subcomputation in the TF/XLA bridge.
bool SupportsCommunicationComputation(Operation* op) {

		}
		if rno <= WZR {
			op = op + "W"
		} else if rno >= S0 && rno <= S31 {
			op = "F" + op + "S"
		} else if rno >= D0 && rno <= D31 {
			op = "F" + op + "D"
		} else if rno >= Q0 && rno <= Q31 {
			op = "F" + op + "Q"
		}
		op = op + suffix
		if inst.Op.String() == "STP" {
			return op + " " + args[0] + ", " + args[1]
		} else {
			return op + " " + args[1] + ", " + args[0]
		}

			op = op[:len(op)-1] + "CC"
		}
	}
	// laid out the instruction
	switch inst.Op {
	default: // dst, sA, sB, ...
		switch len(args) {
		case 0:
			return op
		case 1:
			return fmt.Sprintf("%s %s", op, args[0])
		case 2:
			if inst.Op == COPY || inst.Op == PASTECC {
				return op + " " + args[0] + "," + args[1]
			}
			return op + " " + args[1] + "," + args[0]
		case 3:
			if reverseOperandOrder(inst.Op) {

          UpdateSideEffectsByResourceId(entry.second, op_side_effect_map_[op]);
        }
      }
    }
  }

  // Collects op-based side effects for `op` in `op_side_effect_map_[op]`.
  void CollectOpSideEffects(Operation* op) {
    if (!MayHaveSideEffect(op)) return;
    // Skip following ops to avoid that every island, graph and function is

  llvm::DenseSet<Block*> blocks;
  Operation* op = bottom;
  while (op && op != top) {
    blocks.insert(op->getBlock());
    op = op->getParentOp();
  }
  return blocks;
}

// For a given value defined somewhere underneath `target_blocks`, get the
// result that's emitted through the op(s) that wrap it, in one of the
// `target_blocks`.

      return failure();
    }
    element_type = getElementTypeOrSelf(op->getOperand(1).getType());
  }
  if (attr == "output_quantization") {
    if (op->getNumResults() < 1) {
      return failure();
    }
    element_type = getElementTypeOrSelf(op->getOpResult(0).getType());
  }
  if (element_type) {
    is_8_bit = mlir::isa<TF::Qint8Type>(element_type);
    return success();
  }

  ASSERT_TRUE(succeeded(res));
  ASSERT_EQ(2147483647, op.getLhsQuantizationMaxValAttr().getInt());
  ASSERT_EQ(-2147483648, op.getLhsQuantizationMinValAttr().getInt());
  ASSERT_EQ(2147483647, op.getRhsQuantizationMaxValAttr().getInt());
  ASSERT_EQ(-2147483648, op.getRhsQuantizationMinValAttr().getInt());
  ASSERT_EQ(2147483647, op.getOutputQuantizationMaxValAttr().getInt());
  ASSERT_EQ(-2147483648, op.getOutputQuantizationMinValAttr().getInt());

      return states_[operand_states_[{op, index}]];
    }

    // Returns the state of the index-th result of the op.
    QuantState &GetResultQuantState(Operation *op, int index) {
      return states_[result_states_[{op, index}]];
    }

    // Returns the state of the index-th operand of the op.
    RequantizeState &GetOperandRequantizeState(Operation *op, int index) {

    }
    auto arg_type = cast<func::FuncOp>(op).getArgument(arg_index).getType();
    return VerifyBoundInputArgType(op, arg_type, symbol_op);
  }
  if (named_attr.getName() == kTfSavedModelIndexPathAttr) {
    return VerifyIndexPath(op, named_attr);
  }

  return op->emitError() << "unknown tf_saved_model dialect arg attribute '"
                         << named_attr.getName().getValue() << "'";
}