License. For legal entities, "You" includes any entity that
    controls, is controlled by, or is under common control with You. For
    purposes of this definition, "control" means (a) the power, direct
    or indirect, to cause the direction or management of such entity,
    whether by contract or otherwise, or (b) ownership of more than
    fifty percent (50%) of the outstanding shares or beneficial
    ownership of such entity.

module gorm.io/gorm

go 1.18

require (
	github.com/jinzhu/inflection v1.0.0
	github.com/jinzhu/now v1.1.5
	golang.org/x/text v0.20.0
)

require (
	github.com/mattn/go-sqlite3 v1.14.22 // indirect
	gorm.io/driver/sqlite v1.6.0 // indirect

		field.ValueOf = func(ctx context.Context, v reflect.Value) (interface{}, bool) {
			v = reflect.Indirect(v)
			fieldValue := v.Field(fieldIndex)
			return fieldValue.Interface(), fieldValue.IsZero()
		}
	default:
		field.ValueOf = func(ctx context.Context, v reflect.Value) (interface{}, bool) {
			v = reflect.Indirect(v)
			for _, fieldIdx := range field.StructField.Index {
				if fieldIdx >= 0 {
					v = v.Field(fieldIdx)

//go:build !amd64
// +build !amd64

package p

import (
	"indirect"
)

var in = []algo{
	{indirect.F},

					distinctElems := reflect.MakeSlice(reflect.SliceOf(fieldType), 0, 10)
					identityMap := map[string]bool{}
					for i := 0; i < rValLen; i++ {
						obj := db.Statement.ReflectValue.Index(i)
						if reflect.Indirect(obj).Kind() != reflect.Struct {
							break
						}
						if _, zero := rel.Field.ValueOf(db.Statement.Context, obj); !zero { // check belongs to relation value

   * which loaded -> ReferenceMap.class which has a static -> FinalizableReferenceQueue instance
   *
   * Even if no other references to classes from the application class loader remain, the Finalizer
   * thread keeps an indirect strong reference to the queue in ReferenceMap, which keeps the
   * Finalizer running, and as a result, the application class loader can never be reclaimed.
   *

    "scripts/tests/test_translation_fixer/test_code_blocks/data"
).absolute()


@pytest.mark.parametrize(
    "copy_test_files",
    [(f"{data_path}/en_doc.md", f"{data_path}/translated_doc_number_gt.md")],
    indirect=True,
)
def test_gt(runner: CliRunner, root_dir: Path, copy_test_files):
    result = runner.invoke(
        cli,
        ["fix-pages", "docs/lang/docs/doc.md"],
    )
    assert result.exit_code == 1, result.output

            out = (SmbFileOutputStream) pipe.getNamedPipeOutputStream();
        }
        if (isDirect) {
            out.writeDirect(buf, off, length, 1);
            return;
        }
        out.write(buf, off, length);
    }

    @Override
    protected void doReceiveFragment(final byte[] buf, final boolean isDirect) throws IOException {
        int off, flags, length;

        if (buf.length < max_recv) {

package jcifs.internal.smb2.rdma;

import jcifs.internal.util.SMBUtil;

/**
 * SMB Direct Negotiate Response message.
 *
 * As per MS-SMBD 2.2.2 - SMB_DIRECT_NEGOTIATE_RESPONSE
 * This message is sent in response to negotiate SMB Direct protocol parameters.
 */
public class SmbDirectNegotiateResponse {

    // Protocol constants
    /** SMB Direct negotiate response message type */
    public static final int NEGOTIATE_RESPONSE = 0x02;

			rv := reflect.Indirect(reflect.ValueOf(value))
			appendToRelations(reflectValue, rv, clear && idx == 0)
			if association.Error != nil {
				return
			}
		}

		if len(values) > 0 {
			association.Error = associationDB.Updates(reflectValue.Addr().Interface()).Error
		}
	}

	for _, assignBack := range assignBacks {