Prompt: Sort these versions into PEP 440 order, lowest first: '1.0.0.post1', '1.0.0', '1.0.0rc1', '1.0.0a1', '1.0.0.dev1', '1.0.0b1'. Return one row of the six version strings.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: Are '1.0', '1.0.0' and '1.0.0.0' equal under PEP 440? Give 1 or 0 for each of the comparisons 1.0 == 1.0.0, 1.0.0 == 1.0.0.0 and 1.0 == 1.0.0.0. Return one row of three values.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: PEP 440 epochs. Sort '2.0', '1!1.0' and '1!0.5' lowest first. Return one row of the three version strings.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: Where does a LOCAL version sort? Sort '1.0.0', '1.0.0+local', '1.0.0.post1' and '1.0.0rc1' lowest first. Return one row of the four version strings.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: Give 1 if the version is a pre-release and 0 if not, for '1.0.0', '1.0.0rc1', '1.0.0.post1', '1.0.0.dev1' and '1.1.0rc1'. Return one row of five values.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: Normalise these version strings the way PEP 440 does and give the results: '1.0.0-alpha.1', '1.0.0-rc1', '1.0.0.RELEASE'.  If a string cannot be parsed, give the exact word 'invalid' instead. Return one row of three values.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: Sort every version of 'epsilon' in the index into PEP 440 order, lowest first, and then give how many of them are pre-releases. Return one row: the version strings followed by the count.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: The compatible-release operator. For the specifier '~=1.4.2', give 1 or 0 for whether it matches '1.4.2', '1.4.9', '1.5.0' and '1.4.1'. Return one row of four values.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: For the specifier '~=1.4', give 1 or 0 for whether it matches '1.4.0', '1.9.0', '2.0.0' and '1.3.0'. Return one row of four values.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: Wildcard equality. For '==1.4.*', give 1 or 0 for '1.4.0', '1.4.9', '1.5.0' and '1.40.0'. Return one row of four values.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: THE PRE-RELEASE ASYMMETRY. Using the specifier '>=1.0' and the candidate list ['0.9', '1.0', '1.1.0rc1', '1.1.0', '2.0.0a1'], give (a) how many candidates the `in` operator accepts, and (b) how many SpecifierSet.filter returns with its default settings. Return one row of the two integers.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: Continuing the asymmetry: give the versions SpecifierSet('>=1.0').filter returns from ['0.9', '1.0', '1.1.0rc1', '1.1.0', '2.0.0a1'], in the order returned. Then do the same for SpecifierSet('>=1.0rc1'). Return two rows of version strings.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: For the combined specifier '>=1.0,<2.0,!=1.5.0', give 1 or 0 for '1.0.0', '1.5.0', '1.9.9' and '2.0.0'. Return one row of four values.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: Which versions of 'beta' in the index satisfy '>=1.0,<1.1'? Give them newest first. Return one row of version strings.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: Which versions of 'epsilon' in the index satisfy '>=0.5' with pre-releases excluded, and which satisfy '>=1.1.0rc1'? Give each newest first. Return two rows of version strings.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: Evaluate the PEP 508 marker 'python_version >= "3.11"' in each of the environments linux311, win310 and macarm312. Give 1 or 0 for each, in that order. Return one row of three values.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: Evaluate 'sys_platform == "linux" and platform_machine == "x86_64"' in linux311, win310 and macarm312. Return one row of three values.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: Evaluate 'sys_platform != "win32" or python_version < "3.11"' in linux311, win310 and macarm312. Return one row of three values.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: python_version is compared as a VERSION, not lexically. For the marker 'python_version >= "3.9"', give its value in linux311, win310 and macarm312; then give what a NAIVE LEXICAL string comparison of that environment's python_version against "3.9" would give in the same three environments. Return two rows of three values.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: How many of the three environments satisfy 'platform_system == "Darwin" and platform_machine == "arm64"', and which one — give its name, or the exact word 'none'. Return one row [count, name].

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: Given the requirement list ['gamma>=0.2', 'delta>=2 ; sys_platform == "win32"', 'epsilon>=1 ; python_version >= "3.12"'], give the number of requirements that APPLY in linux311, in win310 and in macarm312. Return one row of three values.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: Resolve the single requirement 'alpha' against the fixed index under the stated rules. Return one row per resolved package, [name, version], sorted by name.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: Resolve 'alpha<2'. Return one row per resolved package, [name, version], sorted by name.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: Resolve 'alpha==1.0.0'. Return one row per resolved package, [name, version], sorted by name.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: Resolve the two requirements 'alpha' and 'gamma<0.3' together. Return one row per resolved package, [name, version], sorted by name.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: Resolve 'delta>=2' together with 'gamma>=0.3'. This forces a backtrack: delta 2.0.0 requires gamma<0.3. Return one row per resolved package, [name, version], sorted by name.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: Resolve 'epsilon'. Note the pre-release rule. Return one row per resolved package, [name, version], sorted by name.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: Give the number of packages in the resolution of 'alpha', of 'alpha<2', and of 'delta>=2'. Return one row of three integers.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: Is the requirement pair 'alpha==1.2.0' and 'gamma<0.3' satisfiable? Give 1 or 0, then the number of packages in the resolution (0 if unsatisfiable). Return one row of two integers.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: Is 'alpha==1.2.0' together with 'gamma==0.1.0' satisfiable? Give 1 or 0, then the number of packages in the resolution (0 if unsatisfiable). Return one row of two integers.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: Resolve 'alpha[plus]<2' — alpha with its 'plus' extra. Return one row per resolved package, [name, version], sorted by name.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: Resolve 'alpha[plus]==2.0.0'. Return one row per resolved package, [name, version], sorted by name.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: How many packages does 'alpha<2' resolve to WITHOUT the plus extra, and how many WITH it? Return one row of two integers.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: Resolve 'beta[fast]'. Return one row per resolved package, [name, version], sorted by name.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.


Prompt: Give the names of every package in the resolution of 'alpha[plus]<2', sorted alphabetically. Return one row of the names.

The tasks use this FIXED package index. There is no network; these are all the
distributions that exist.

  alpha:   1.0.0, 1.1.0, 1.2.0, 2.0.0
  beta:    0.9.0, 1.0.0, 1.0.1, 1.1.0
  gamma:   0.1.0, 0.2.0, 0.3.0
  delta:   1.0.0, 2.0.0, 2.1.0
  epsilon: 0.5.0, 1.0.0, 1.1.0rc1

Requirements of each distribution:

  alpha 1.0.0   -> beta>=0.9,<1.1
  alpha 1.1.0   -> beta>=1.0, gamma>=0.2
  alpha 1.2.0   -> beta>=1.1, gamma>=0.2
  alpha 2.0.0   -> beta>=1.1, delta>=2
  beta  0.9.0   -> (none)
  beta  1.0.0   -> gamma>=0.1
  beta  1.0.1   -> gamma>=0.1
  beta  1.1.0   -> gamma>=0.3
  gamma any     -> (none)
  delta 1.0.0   -> (none)
  delta 2.0.0   -> gamma<0.3
  delta 2.1.0   -> gamma>=0.2
  epsilon 0.5.0 -> (none)
  epsilon 1.0.0 -> gamma>=0.2
  epsilon 1.1.0rc1 -> gamma>=0.3

Extras:
  alpha[plus] 1.2.0 -> delta>=1, epsilon>=0.5
  alpha[plus] 2.0.0 -> epsilon>=1
  beta[fast]  1.1.0 -> delta>=2.1

RESOLUTION RULES — these are the rules to apply, and they are the ones uv and pip follow:
  * prefer the HIGHEST version of every package that satisfies all constraints;
  * PRE-RELEASES ARE EXCLUDED unless a constraint on that package explicitly names a
    pre-release. This is the `SpecifierSet.filter` behaviour, not the `in` behaviour — they
    differ, and the difference is the point of two of these tasks;
  * when a choice fails, BACKTRACK on the most recently chosen package;
  * a resolution is a set of (name, version) pairs; report it sorted by package name.

MARKER ENVIRONMENTS, referred to by name:
  linux311   python_version 3.11, sys_platform linux,  platform_machine x86_64
  win310     python_version 3.10, sys_platform win32,  platform_machine AMD64
  macarm312  python_version 3.12, sys_platform darwin, platform_machine arm64

Available imports: packaging.version (Version), packaging.specifiers (SpecifierSet),
packaging.markers (Marker), itertools. Nothing else is needed and there is no network.

Put the requested values in `result` as a list of rows of plain values. Versions are returned
as STRINGS exactly as they appear in the index above. A resolution is one row per resolved
package, each row [name, version], sorted by name.

{"rows": [["alpha", "beta", "delta", "epsilon", "gamma"]]}