} else {
				s += ", \"bitrot_valid\": false"
			}
			if value {
				if utf8.Valid(data) {
					// Encode as JSON string.
					b, err := json.Marshal(string(data))
					if err == nil {
						s += `, "data_string": ` + string(b)
					}
				}
				// Base64 encode.
				s += `, "data_base64": "` + base64.StdEncoding.EncodeToString(data) + `"`
			}
			s += "}"
		}
		res = append(res, []byte(s)...)
	}

    assertThat(compactTable.mappings.length).isLessThan(1 shl 14)

    // Confirm the data strings are ASCII.
    for (dataString in listOf<String>(compactTable.sections, compactTable.ranges)) {
      for (codePoint in dataString.codePoints()) {
        assertThat(codePoint and 0x7f).isEqualTo(codePoint)
      }
    }

    // Confirm the sections are increasing.

            if (!this.element.val().length) return;

            var dateString = this.element.val().split(this.locale.separator),
                start = null,
                end = null;

            if (dateString.length === 2) {
                start = moment(dateString[0], this.locale.format);
                end = moment(dateString[1], this.locale.format);
            }

  absl::Status status;
  for (const std::vector<int64_t>& dims :
       std::vector<std::vector<int64_t>>{{n}, {1, n}, {n, 1}, {n / 2, 2}}) {
    // Create C++ Tensor
    Tensor src(tensorflow::DT_STRING, TensorShape(dims));
    for (int64_t i = 0; i < src.NumElements(); ++i) {
      src.flat<tstring>()(i) = data[i];
    }
    TF_Tensor* dst = TF_TensorFromTensor(src, &status);

  const std::string& func_str =
      "    signature {"
      "      name: 'FunctionWith__OP_NAME__'"
      "      output_arg {"
      "        name: 'out'"
      "        type: DT_STRING"
      "      }"
      "    }"
      "    node_def {"
      "      name: 'error_op'"
      "      op: '__OP_NAME__'"
      "    }"
      "    ret {"
      "      key: 'out'"