/**
     * Try Broadcast queries first, then try to resolve the name using the
     * nameserver.
     */

    public static final int M_NODE = 2;

    /**
     * A Hybrid node tries to resolve a name using the nameserver first. If
     * that fails use the broadcast address. This is the default if a nameserver
     * is provided. This is the behavior of Microsoft Windows machines.
     */

// operations. See also mwbbuf.go.

package runtime

import (
	"internal/abi"
	"internal/goarch"
	"internal/goexperiment"
	"unsafe"
)

// Go uses a hybrid barrier that combines a Yuasa-style deletion
// barrier—which shades the object whose reference is being
// overwritten—with Dijkstra insertion barrier—which shades the object

			if err != nil {
				return nil, nil, nil, err
			}
			// For draft-tls-westerbaan-xyber768d00-03, we send both a hybrid
			// and a standard X25519 key share, since most servers will only
			// support the latter. We reuse the same X25519 ephemeral key for
			// both, as allowed by draft-ietf-tls-hybrid-design-09, Section 3.2.
			hello.keyShares = []keyShare{

		}
		t.Fatal(err)
	}

	// Expect a single line like this:
	// 0::/user.slice/user-1000.slice/******@****.***e/app.slice/vte-spawn-891992a2-efbb-4f28-aedb-b24f9e706770.scope
	// Otherwise it's either cgroup v1 or a hybrid hierarchy.
	if bytes.Count(selfCg, []byte("\n")) > 1 {
		t.Skip("cgroup v2 not available")
	}
	cg := bytes.TrimPrefix(selfCg, []byte("0::"))
	if len(cg) == len(selfCg) { // No prefix found.

      }
    }
  }
}

TEST_F(QuantizeWeightsTest, VerifyCustomOpQuantizationDequantize) {
  LoadCustomOpTestModel();

  // The custom op is not hybrid, and the second input is a constant that can
  // be quantized.
  CustomOpMap custom_op_map;
  custom_op_map["CustomTestOp"] = {
      {1},   // quantizable_input_indices
      true,  // is_weight_only
  };

    public static final int P_NODE = 1;

/** 
 * Try Broadcast queries first, then try to resolve the name using the
 * nameserver.
 */

    public static final int M_NODE = 2;

/** 
 * A Hybrid node tries to resolve a name using the nameserver first. If
 * that fails use the broadcast address. This is the default if a nameserver
 * is provided. This is the behavior of Microsoft Windows machines.
 */ 

		// because we currently only support it at all when CurvePreferences is
		// empty, which will cause us to also send a key share for it.
		//
		// This will have to change once we support selecting hybrid KEMs
		// without sending key shares for them.
		if _, ok := curveForCurveID(curveID); !ok {
			c.sendAlert(alertInternalError)
			return errors.New("tls: CurvePreferences includes unsupported curve")
		}

  return %0 : tensor<1x2x4x5xf32>
}

// CHECK: stablehlo.constant
// CHECK-NOT: tfl.pseudo_qconst
// CHECK-NOT: tfl.pseudo_const
// CHECK-NOT: arith.constant

// -----

// Tests that a hybrid quantized dot_general is splitted into dequantize and float
// dot_general.

// CHECK-LABEL: func @dot_general_hybrid
// CHECK-SAME: %[[ARG0:.+]]: tensor<1x2x3x4xf32>

    if (!op->getAttr(kQuantizationMethodAttr)) return failure();

    // Ignore unquantized ops.
    if (!IsQuantizedXlaCallModuleOp(op)) return failure();

    // For weight-only quantization, op should be hybrid quantized.
    if (HasWeightOnlyPtqMethod(op) && !IsHybridQuantizedOp(op)) {
      return failure();
    }

    func::FuncOp entry_func_op = GetEntryFuncOp(op, SymbolTable(module_op));
    if (!entry_func_op) {

//
// In TLS 1.2, this registry used to support only elliptic curves. In TLS 1.3,
// it was extended to other groups and renamed NamedGroup. See RFC 8446, Section
// 4.2.7. It was then also extended to other mechanisms, such as hybrid
// post-quantum KEMs.
type CurveID uint16

const (
	CurveP256 CurveID = 23
	CurveP384 CurveID = 24
	CurveP521 CurveID = 25
	X25519    CurveID = 29