const int lhs_rank = mlir::cast<ShapedType>(lhs.getType()).getShape().size();
  const int rhs_rank = mlir::cast<ShapedType>(rhs.getType()).getShape().size();

  const std::string einsum_equation =
      CreateEinsumEquation(dot_dimension_numbers, lhs_rank, rhs_rank);

  return builder.create<TF::EinsumOp>(loc, output.getType(), input_arguments,

    public String toString() {
        return getGroupId() + ":" + getArtifactId() + ":" + getVersion() + ":"
                + (getClassifier() == null ? "" : getClassifier()) + ":"
                + (getType() == null ? DEFAULT_TYPE : getType());
    }

	}
}

func typeString(sotype int) string {
	var s string
	switch sotype & 0xff {
	case syscall.SOCK_STREAM:
		s = "stream"
	case syscall.SOCK_DGRAM:
		s = "datagram"
	case syscall.SOCK_RAW:
		s = "raw"
	case syscall.SOCK_SEQPACKET:
		s = "seqpacket"
	default:
		s = fmt.Sprintf("%d", sotype&0xff)
	}
	if flags := uint(sotype) & ^uint(0xff); flags != 0 {
		s += fmt.Sprintf("|%#x", flags)

      if (const QuantizedType qtype =
              QuantizedType::getQuantizedElementType(q.getArg().getType())) {
        rewriter.setInsertionPoint(op);
        rewriter.replaceOpWithNewOp<quantfork::DequantizeCastOp>(
            op, op.getResult().getType(), q.getArg());
        return success();
      }

      op.replaceAllUsesWith(q.getArg());
      return success();
    }

  for (OpOperand& operand : op.getOpOperands()) {
    if (mlir::isa<TF::ResourceType>(
            getElementTypeOrSelf(operand.get().getType()))) {
      return op.emitOpError()
             << "found unexpected type " << operand.get().getType()
             << " of operand #" << operand.getOperandNumber()
             << ", resource type operands are expected to have been "

                    Hexdump.toHexString(checksumData),
                    this.serverSignature.getType(),
                    Hexdump.toHexString(this.serverSignature.getChecksum())));
        }

        byte checksum[] = PacMac.calculateMac(this.serverSignature.getType(), keys, checksumData);
        if ( !MessageDigest.isEqual(this.serverSignature.getChecksum(), checksum) ) {

	var sotype int
	switch net {
	case "unix":
		sotype = syscall.SOCK_STREAM
	case "unixgram":
		sotype = syscall.SOCK_DGRAM
	case "unixpacket":
		sotype = syscall.SOCK_SEQPACKET
	default:
		return nil, UnknownNetworkError(net)
	}

	switch mode {
	case "dial":

)

func setDefaultSockopts(s, family, sotype int, ipv6only bool) error {
	if family == syscall.AF_INET6 && sotype != syscall.SOCK_RAW {
		// Allow both IP versions even if the OS default
		// is otherwise. Note that some operating systems
		// never admit this option.
		syscall.SetsockoptInt(s, syscall.IPPROTO_IPV6, syscall.IPV6_V6ONLY, boolint(ipv6only))
	}
	if (sotype == syscall.SOCK_DGRAM || sotype == syscall.SOCK_RAW) && family != syscall.AF_UNIX {

		}
	}
	if family == syscall.AF_INET6 && sotype != syscall.SOCK_RAW && supportsIPv4map() {
		// Allow both IP versions even if the OS default
		// is otherwise. Note that some operating systems
		// never admit this option.
		syscall.SetsockoptInt(s, syscall.IPPROTO_IPV6, syscall.IPV6_V6ONLY, boolint(ipv6only))
	}
	if (sotype == syscall.SOCK_DGRAM || sotype == syscall.SOCK_RAW) && family != syscall.AF_UNIX {
		// Allow broadcast.

        if (expression.getType() == IncludeType.QUOTED || expression.getType() == IncludeType.SYSTEM) {
            // Returns a fixed value expression
            macroFunctions.add(new ReturnFixedValueMacroFunction(macroName, paramNames.size(), expression.getType(), expression.getValue(), Collections.<Expression>emptyList()));
            return;
        }
        if (expression.getType() == IncludeType.IDENTIFIER) {