return null;
                })).status(ApiResult.Status.OK).result());
    }

    /**
     * Creates a new stemmer override dictionary item.
     *
     * @param dictId the dictionary ID
     * @param body the request body containing stemmer override item information
     * @return JSON response with result status
     */
    // POST /api/admin/dict/stemmerOverride/setting/{dictId}
    @Execute

  @Override
  public SortedMultiset<E> descendingMultiset() {
    UnmodifiableSortedMultiset<E> result = descendingMultiset;
    if (result == null) {
      result = new UnmodifiableSortedMultiset<>(delegate().descendingMultiset());
      result.descendingMultiset = this;
      return descendingMultiset = result;
    }
    return result;
  }

  @Override
  public @Nullable Entry<E> firstEntry() {

For example, if you were translating to Spanish, you would write:

/// note | Nota

Some examples in Spanish:

Source (English):

/// tip

Result (Spanish):

/// tip | Consejo

Source (English):

/// details | Preview

Result (Spanish):

/// details | Vista previa

### Tab blocks

            boolQuery.must(QueryBuilders.termQuery("field", "value"));
        });

        QueryBuilder result = queryContext.getQueryBuilder();
        assertNotNull(result);
        assertTrue(result instanceof BoolQueryBuilder);
        assertTrue(((BoolQueryBuilder) result).hasClauses());
    }

    // Test addQuery with existing query
    @Test
    public void test_addQuery_withExistingQuery() {

					k = field.DBName
				}
			}

			if _, ok := result[k]; !ok {
				if v, ok := selectColumns[k]; (ok && v) || (!ok && !restricted) {
					result[k] = make([]interface{}, len(mapValues))
					columns = append(columns, k)
				} else {
					continue
				}
			}

			result[k][idx] = v
		}
	}

	sort.Strings(columns)
	values.Values = make([][]interface{}, len(mapValues))

        when:
        def result = gradleRunner("yamlRestTestV${compatibleVersion}CompatTest").build()

        then:
        result.task(":yamlRestTestV${compatibleVersion}CompatTest").outcome == TaskOutcome.SKIPPED
        result.task(':copyRestCompatApiTask').outcome == TaskOutcome.SUCCESS
        result.task(':copyRestCompatTestTask').outcome == TaskOutcome.SUCCESS
        result.task(transformTask).outcome == TaskOutcome.SUCCESS

	}

	ctx := context.Background()

	u := withResultUser{Name: "with-result-ok"}
	r := gorm.WithResult()
	if err := gorm.G[withResultUser](db, r).Create(ctx, &u); err != nil {
		t.Fatalf("create failed: %v", err)
	}
	if u.ID == 0 {
		t.Fatalf("expected ID to be set")
	}
	if r.Error != nil {
		t.Fatalf("unexpected result error: %v", r.Error)
	}
	if r.RowsAffected <= 0 {

    private final MavenExecutionResult result;

    private final ClassLoader originalContextClassLoader;

    private final ReactorBuildStatus reactorBuildStatus;

    public ReactorContext(
            MavenExecutionResult result,
            ClassLoader originalContextClassLoader,
            ReactorBuildStatus reactorBuildStatus) {
        this.result = result;

    results[idx] = *static_cast<float*>(TF_TensorData(f_t));
    TF_DeleteTensor(f_t);
  }
  ASSERT_EQ(results[0], 5.0);
  ASSERT_EQ(results[1], 6.0);

  for (int idx = 0; idx < 2; ++idx) {
    TF_AbstractTensor* result = TF_OutputListGet(func_outputs, idx);
    TF_DeleteAbstractTensor(result);
  }
  TF_DeleteOutputList(func_outputs);
  TF_DeleteExecutionContext(eager_execution_ctx);

   * contains {@link Double#NEGATIVE_INFINITY} and not {@link Double#NaN} then the result is {@link
   * Double#NEGATIVE_INFINITY}. If it contains {@link Double#POSITIVE_INFINITY} and finite values
   * only then the result is the lowest finite value. If it contains {@link
   * Double#POSITIVE_INFINITY} only then the result is {@link Double#POSITIVE_INFINITY}.
   *