}
		is1xx := 100 <= resCode && resCode <= 199
		// treat 101 as a terminal status, see issue 26161
		is1xxNonTerminal := is1xx && resCode != StatusSwitchingProtocols
		if is1xxNonTerminal {
			num1xx++
			if num1xx > max1xxResponses {
				return nil, errors.New("net/http: too many 1xx informational responses")
			}
			pc.readLimit = pc.maxHeaderResponseSize() // reset the limit

	if statusCode >= 100 && statusCode <= 199 {
		if f.StreamEnded() {
			return nil, errors.New("1xx informational response with END_STREAM flag")
		}
		cs.num1xx++
		const max1xxResponses = 5 // arbitrary bound on number of informational responses, same as net/http
		if cs.num1xx > max1xxResponses {
			return nil, errors.New("http2: too many 1xx informational responses")
		}
		if fn := cs.get1xxTraceFunc(); fn != nil {

			}
		}

		// Read csect auxiliary entry (by convention, it is the last).
		if !needAuxFcn {
			if _, err := sr.Seek(int64(numaux-1)*SYMESZ, io.SeekCurrent); err != nil {
				return nil, err
			}
		}
		i += numaux
		numaux = 0
		switch f.TargetMachine {
		case U802TOCMAGIC:
			aux := new(AuxCSect32)
			if err := binary.Read(sr, binary.BigEndian, aux); err != nil {

    if (attr.getSplatValue<Eigen::half>() != Eigen::half(0))
      output->Add(
          Eigen::numext::bit_cast<uint16_t>(attr.getSplatValue<Eigen::half>()));
  } else {
    output->Reserve(attr.getNumElements());
    for (const Eigen::half value : attr.getValues<Eigen::half>())
      output->AddAlreadyReserved(Eigen::numext::bit_cast<uint16_t>(value));
  }
}

    const double double_val = static_cast<double>(values_array[i]);
    if (Eigen::numext::isnan(double_val)) {
      std::ostringstream err;
      err << "Nan in summary histogram for: " << k->op_node_name;
      TF_SetStatus(status.get(), TF_INVALID_ARGUMENT, err.str().c_str());
      TF_OpKernelContext_Failure(ctx, status.get());
      return;
    } else if (Eigen::numext::isinf(double_val)) {
      std::ostringstream err;

func main() {
	z := MyStruct{
		Foo:		"foo",
		Bar:		"bar",
		Name:		"name",
		LongName:	"longname",
		Baz:		"baz",
	}
	y := MyStruct{
		Foo:			"foo",
		Bar:			"bar",
		NameXX:			"name",
		LongNameXXXXXXXXXXXXX:	"longname",
		Baz:			"baz",
	}
	z := MyStruct{
		Foo:			"foo",
		Bar:			"bar",
		Name:			"name",
		LongNameXXXXXXXXXXXXX:	"longname",
		Baz:			"baz",
	}
}

        Bar:      "bar",
        Name:     "name",
        LongName: "longname",
        Baz:      "baz",
    }
    y := MyStruct{
        Foo:                   "foo",
        Bar:                   "bar",
        NameXX:                "name",
        LongNameXXXXXXXXXXXXX: "longname",
        Baz: "baz",
    }
    z := MyStruct{
        Foo:  "foo",
        Bar:  "bar",
        Name: "name",

			rel.SetSiz(rSize)
			rel.SetSym(rSym)
			rel.SetAdd(rAdd)

		}

		sb.SortRelocs()
	}

	// enter sub-symbols into symbol table.
	for i, numaux := 0, 0; i < len(f.COFFSymbols); i += numaux + 1 {
		pesym := &f.COFFSymbols[i]

		numaux = int(pesym.NumberOfAuxSymbols)

		name, err := pesym.FullName(f.StringTable)
		if err != nil {
			return nil, err
		}
		if name == "" {
			continue
		}

import org.gradle.api.tasks.TaskAction

open class MyCustomTask : DefaultTask() {
    @TaskAction
    fun calculateSum() {
        // Custom logic to calculate the sum of two numbers
        val num1 = 5
        val num2 = 7
        val sum = num1 + num2

        // Print the result
        println("Sum: $sum")
    }
}
----
=====
[.multi-language-sample]
=====
.MyCustomTask.groovy
[source, groovy]
----

			"key": "value",
		}
		u.Object["num"] = map[string]interface{}{
			"num1": int64(1),
			"num2": int64(1000000),
		}
	case "v1beta1":
		u.Object["content"] = map[string]interface{}{
			"key": "value",
		}
		u.Object["num"] = map[string]interface{}{
			"num1": int64(1),
			"num2": int64(1000000),
		}
	case "v1beta2":