err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *listPathOptions) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 19
	// write "ID"
	err = en.Append(0xde, 0x0, 0x13, 0xa2, 0x49, 0x44)
	if err != nil {
		return
	}
	err = en.WriteString(z.ID)
	if err != nil {
		err = msgp.WrapError(err, "ID")
		return
	}

pkg debug/elf, type Chdr32 struct
pkg debug/elf, type Chdr32 struct, Addralign uint32
pkg debug/elf, type Chdr32 struct, Size uint32
pkg debug/elf, type Chdr32 struct, Type uint32
pkg debug/elf, type Chdr64 struct
pkg debug/elf, type Chdr64 struct, Addralign uint64
pkg debug/elf, type Chdr64 struct, Size uint64
pkg debug/elf, type Chdr64 struct, Type uint32
pkg debug/elf, type CompressionType int
pkg debug/elf, type R_MIPS int

                final String[] deduped = dedupe(elements);
                return new AbstractSet<String>() {
                  @Override
                  public int size() {
                    return deduped.length;
                  }

                  @Override
                  public Iterator<String> iterator() {

 * a {@code Map<R, Map<C, V>>}. A method call like {@code column(columnKey).get(rowKey)} still runs
 * quickly, since the row key is provided. However, {@code column(columnKey).size()} takes longer,
 * since an iteration across all row keys occurs.
 *
 * <p>Because a {@code TreeBasedTable} has unique sorted values for a given row, both {@code

      Java8Compatibility.clear(buf);
    }
    return total;
  }

  // TODO(lukes): consider allowing callers to pass in a buffer to use, some callers would be able
  // to reuse buffers, others would be able to size them more appropriately than the constant
  // defaults

  /**
   * Copies all characters between the {@link Reader} and {@link StringBuilder} objects. Does not
   * close or flush the reader.
   *

	Name string
	Pets []AssociationEmptyPet
}

type AssociationEmptyPet struct {
	AssociationEmptyUserID *uint  `gorm:"uniqueIndex:uniq_user_id_name"`
	Name                   string `gorm:"uniqueIndex:uniq_user_id_name;size:256"`
}

func TestAssociationEmptyPrimaryKey(t *testing.T) {
	if DB.Dialector.Name() != "mysql" {
		t.Skip()
	}
	DB.Migrator().DropTable(&AssociationEmptyUser{}, &AssociationEmptyPet{})

	case string:
		return json.Unmarshal([]byte(value), l)
	case []byte:
		return json.Unmarshal(value, l)
	default:
		return errors.New("not supported")
	}
}

type Role struct {
	Name string `gorm:"size:256"`
}

func (role *Role) Scan(value interface{}) error {
	if b, ok := value.([]uint8); ok {
		role.Name = string(b)
	} else {
		role.Name = value.(string)
	}
	return nil
}

import aQute.bnd.build.Workspace
import aQute.bnd.build.model.BndEditModel
import aQute.bnd.deployer.repository.LocalIndexedRepo
import aQute.bnd.osgi.Constants
import aQute.bnd.service.RepositoryPlugin
import biz.aQute.resolve.Bndrun
import java.io.File
import okio.FileSystem
import okio.Path
import okio.Path.Companion.toPath
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Tag

          "interval": "1m",
          "intervalFactor": 2,
          "legendFormat": "Last Hour Failed Size [{{bucket}}]",
          "refId": "A"
        }
      ],
      "title": "Last Hour Failed Size",
      "type": "timeseries"
    },
    {
      "datasource": {
        "type": "prometheus",
        "uid": "${DS_PROMETHEUS}"
      },

      // k is really large; just do a straightforward sorted-copy-and-sublist
      ArrayList<E> list = Lists.newArrayList(iterator);
      sort(list, this);
      if (list.size() > k) {
        list.subList(k, list.size()).clear();
      }
      list.trimToSize();
      return unmodifiableList(list);
    } else {
      TopKSelector<E> selector = TopKSelector.least(k, this);
      selector.offerAll(iterator);