{"3/0", "division by zero"},
	{"(1<<63)/0", "divide of value with high bit set"},
	{"3%0", "modulo by zero"},
	{"(1<<63)%0", "modulo of value with high bit set"},
	{"3<<-4", "negative left shift count"},
	{"3<<(1<<63)", "negative left shift count"},
	{"3>>-4", "negative right shift count"},
	{"3>>(1<<63)", "negative right shift count"},
	{"(1<<63)>>2", "right shift of value with high bit set"},
	{"(1<<62)>>2", ""},

                "-PtestJavaVendor=openjdk",
                "-Dscan.tag.FunctionalTest",
                "-Dscan.value.coverageOs=windows",
                "-Dscan.value.coverageArch=amd64",
                "-Dscan.value.coverageJvmVendor=openjdk",
                "-Dscan.value.coverageJvmVersion=java23",
                "-PflakyTests=exclude",
                "-Dscan.tag.Check",

  }

  /** Returns the hash prefix given the current mask. */
  static int getHashPrefix(int value, int mask) {
    return value & ~mask;
  }

  /** Returns the index, or 0 if the entry is "null". */
  static int getNext(int entry, int mask) {
    return entry & mask;
  }

  /** Returns a new value combining the prefix and suffix using the given mask. */
  static int maskCombine(int prefix, int suffix, int mask) {

    @Override
    public boolean contains(final Object value) {
        return getProperties().contains(value);
    }

    @Override
    public boolean containsKey(final Object key) {
        return getProperties().containsKey(key);
    }

    @Override
    public boolean containsValue(final Object value) {
        return getProperties().containsValue(value);
    }

    @Override

            "content": {
                "application/json": {
                    "example": {"id": "bar", "value": "The bar tenders"}
                }
            },
        },
    },
)
async def read_item(item_id: str):
    if item_id == "foo":
        return {"id": "foo", "value": "there goes my hero"}
    else:

  }

  @Benchmark
  int iteration(int reps) {
    int sum = 0;
    for (int i = 0; i < reps; i++) {
      for (Set<Integer> subset : powerSet) {
        for (Integer value : subset) {
          sum += value;
        }
      }
    }
    return sum;
  }

        }

        private
        fun propertiesFrom(data: Map<String, Any>): Properties = Properties().apply {
            putAll(data.map { (key, value) -> key to value.toString() })
        }
    }

    for (K key : sampleKeys()) {
      for (V value : sampleValues()) {
        resetContainer();

        List<V> values = multimap().get(key);
        List<V> expectedValues = copyToList(values);

        assertTrue(multimap().put(key, value));
        expectedValues.add(value);

        assertGet(key, expectedValues);
        assertEquals(value, values.get(values.size() - 1));
      }
    }
  }

        server_name  localhost;

        # To allow special characters in headers
        ignore_invalid_headers off;
        # Allow any size file to be uploaded.
        # Set to a value such as 1000m; to restrict file size to a specific value
        client_max_body_size 0;
        # To disable buffering
        proxy_buffering off;
        proxy_request_buffering off;

        location / {

   *
   * @since 12.0
   */
  public static <T extends Enum<T>> Optional<T> getIfPresent(Class<T> enumClass, String value) {
    checkNotNull(enumClass);
    checkNotNull(value);
    return Platform.getEnumIfPresent(enumClass, value);
  }

  @GwtIncompatible // java.lang.ref.WeakReference
  private static final Map<Class<? extends Enum<?>>, Map<String, WeakReference<? extends Enum<?>>>>