Coverage Report

Created: 2026-05-14 06:08

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/fmt/test/fuzzing/two-args.cc
Line
Count
Source
1
// Copyright (c) 2019, Paul Dreik
2
// For the license information refer to format.h.
3
4
#include <fmt/format.h>
5
6
#include <cstdint>
7
#include <exception>
8
#include <string>
9
10
#include "fuzzer-common.h"
11
12
template <typename Item1, typename Item2>
13
11.9k
void invoke_fmt(const uint8_t* data, size_t size) {
14
11.9k
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
11.9k
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
11.9k
  if (size <= fixed_size + fixed_size) return;
17
18
10.4k
  const Item1 item1 = assign_from_buf<Item1>(data);
19
10.4k
  data += fixed_size;
20
10.4k
  size -= fixed_size;
21
22
10.4k
  const Item2 item2 = assign_from_buf<Item2>(data);
23
10.4k
  data += fixed_size;
24
10.4k
  size -= fixed_size;
25
26
10.4k
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
10.4k
  auto buf = fmt::memory_buffer();
31
10.4k
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
10.4k
#endif
33
10.4k
}
void invoke_fmt<bool, bool>(unsigned char const*, unsigned long)
Line
Count
Source
13
101
void invoke_fmt(const uint8_t* data, size_t size) {
14
101
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
101
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
101
  if (size <= fixed_size + fixed_size) return;
17
18
93
  const Item1 item1 = assign_from_buf<Item1>(data);
19
93
  data += fixed_size;
20
93
  size -= fixed_size;
21
22
93
  const Item2 item2 = assign_from_buf<Item2>(data);
23
93
  data += fixed_size;
24
93
  size -= fixed_size;
25
26
93
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
93
  auto buf = fmt::memory_buffer();
31
93
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
93
#endif
33
93
}
void invoke_fmt<bool, char>(unsigned char const*, unsigned long)
Line
Count
Source
13
82
void invoke_fmt(const uint8_t* data, size_t size) {
14
82
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
82
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
82
  if (size <= fixed_size + fixed_size) return;
17
18
74
  const Item1 item1 = assign_from_buf<Item1>(data);
19
74
  data += fixed_size;
20
74
  size -= fixed_size;
21
22
74
  const Item2 item2 = assign_from_buf<Item2>(data);
23
74
  data += fixed_size;
24
74
  size -= fixed_size;
25
26
74
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
74
  auto buf = fmt::memory_buffer();
31
74
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
74
#endif
33
74
}
void invoke_fmt<bool, signed char>(unsigned char const*, unsigned long)
Line
Count
Source
13
24
void invoke_fmt(const uint8_t* data, size_t size) {
14
24
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
24
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
24
  if (size <= fixed_size + fixed_size) return;
17
18
16
  const Item1 item1 = assign_from_buf<Item1>(data);
19
16
  data += fixed_size;
20
16
  size -= fixed_size;
21
22
16
  const Item2 item2 = assign_from_buf<Item2>(data);
23
16
  data += fixed_size;
24
16
  size -= fixed_size;
25
26
16
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
16
  auto buf = fmt::memory_buffer();
31
16
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
16
#endif
33
16
}
void invoke_fmt<bool, unsigned char>(unsigned char const*, unsigned long)
Line
Count
Source
13
50
void invoke_fmt(const uint8_t* data, size_t size) {
14
50
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
50
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
50
  if (size <= fixed_size + fixed_size) return;
17
18
42
  const Item1 item1 = assign_from_buf<Item1>(data);
19
42
  data += fixed_size;
20
42
  size -= fixed_size;
21
22
42
  const Item2 item2 = assign_from_buf<Item2>(data);
23
42
  data += fixed_size;
24
42
  size -= fixed_size;
25
26
42
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
42
  auto buf = fmt::memory_buffer();
31
42
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
42
#endif
33
42
}
void invoke_fmt<bool, short>(unsigned char const*, unsigned long)
Line
Count
Source
13
28
void invoke_fmt(const uint8_t* data, size_t size) {
14
28
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
28
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
28
  if (size <= fixed_size + fixed_size) return;
17
18
21
  const Item1 item1 = assign_from_buf<Item1>(data);
19
21
  data += fixed_size;
20
21
  size -= fixed_size;
21
22
21
  const Item2 item2 = assign_from_buf<Item2>(data);
23
21
  data += fixed_size;
24
21
  size -= fixed_size;
25
26
21
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
21
  auto buf = fmt::memory_buffer();
31
21
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
21
#endif
33
21
}
void invoke_fmt<bool, unsigned short>(unsigned char const*, unsigned long)
Line
Count
Source
13
34
void invoke_fmt(const uint8_t* data, size_t size) {
14
34
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
34
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
34
  if (size <= fixed_size + fixed_size) return;
17
18
26
  const Item1 item1 = assign_from_buf<Item1>(data);
19
26
  data += fixed_size;
20
26
  size -= fixed_size;
21
22
26
  const Item2 item2 = assign_from_buf<Item2>(data);
23
26
  data += fixed_size;
24
26
  size -= fixed_size;
25
26
26
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
26
  auto buf = fmt::memory_buffer();
31
26
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
26
#endif
33
26
}
void invoke_fmt<bool, int>(unsigned char const*, unsigned long)
Line
Count
Source
13
49
void invoke_fmt(const uint8_t* data, size_t size) {
14
49
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
49
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
49
  if (size <= fixed_size + fixed_size) return;
17
18
41
  const Item1 item1 = assign_from_buf<Item1>(data);
19
41
  data += fixed_size;
20
41
  size -= fixed_size;
21
22
41
  const Item2 item2 = assign_from_buf<Item2>(data);
23
41
  data += fixed_size;
24
41
  size -= fixed_size;
25
26
41
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
41
  auto buf = fmt::memory_buffer();
31
41
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
41
#endif
33
41
}
void invoke_fmt<bool, unsigned int>(unsigned char const*, unsigned long)
Line
Count
Source
13
35
void invoke_fmt(const uint8_t* data, size_t size) {
14
35
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
35
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
35
  if (size <= fixed_size + fixed_size) return;
17
18
27
  const Item1 item1 = assign_from_buf<Item1>(data);
19
27
  data += fixed_size;
20
27
  size -= fixed_size;
21
22
27
  const Item2 item2 = assign_from_buf<Item2>(data);
23
27
  data += fixed_size;
24
27
  size -= fixed_size;
25
26
27
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
27
  auto buf = fmt::memory_buffer();
31
27
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
27
#endif
33
27
}
void invoke_fmt<bool, long>(unsigned char const*, unsigned long)
Line
Count
Source
13
42
void invoke_fmt(const uint8_t* data, size_t size) {
14
42
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
42
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
42
  if (size <= fixed_size + fixed_size) return;
17
18
34
  const Item1 item1 = assign_from_buf<Item1>(data);
19
34
  data += fixed_size;
20
34
  size -= fixed_size;
21
22
34
  const Item2 item2 = assign_from_buf<Item2>(data);
23
34
  data += fixed_size;
24
34
  size -= fixed_size;
25
26
34
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
34
  auto buf = fmt::memory_buffer();
31
34
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
34
#endif
33
34
}
void invoke_fmt<bool, unsigned long>(unsigned char const*, unsigned long)
Line
Count
Source
13
25
void invoke_fmt(const uint8_t* data, size_t size) {
14
25
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
25
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
25
  if (size <= fixed_size + fixed_size) return;
17
18
18
  const Item1 item1 = assign_from_buf<Item1>(data);
19
18
  data += fixed_size;
20
18
  size -= fixed_size;
21
22
18
  const Item2 item2 = assign_from_buf<Item2>(data);
23
18
  data += fixed_size;
24
18
  size -= fixed_size;
25
26
18
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
18
  auto buf = fmt::memory_buffer();
31
18
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
18
#endif
33
18
}
void invoke_fmt<bool, float>(unsigned char const*, unsigned long)
Line
Count
Source
13
31
void invoke_fmt(const uint8_t* data, size_t size) {
14
31
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
31
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
31
  if (size <= fixed_size + fixed_size) return;
17
18
23
  const Item1 item1 = assign_from_buf<Item1>(data);
19
23
  data += fixed_size;
20
23
  size -= fixed_size;
21
22
23
  const Item2 item2 = assign_from_buf<Item2>(data);
23
23
  data += fixed_size;
24
23
  size -= fixed_size;
25
26
23
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
23
  auto buf = fmt::memory_buffer();
31
23
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
23
#endif
33
23
}
void invoke_fmt<bool, double>(unsigned char const*, unsigned long)
Line
Count
Source
13
17
void invoke_fmt(const uint8_t* data, size_t size) {
14
17
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
17
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
17
  if (size <= fixed_size + fixed_size) return;
17
18
9
  const Item1 item1 = assign_from_buf<Item1>(data);
19
9
  data += fixed_size;
20
9
  size -= fixed_size;
21
22
9
  const Item2 item2 = assign_from_buf<Item2>(data);
23
9
  data += fixed_size;
24
9
  size -= fixed_size;
25
26
9
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
9
  auto buf = fmt::memory_buffer();
31
9
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
9
#endif
33
9
}
void invoke_fmt<bool, long double>(unsigned char const*, unsigned long)
Line
Count
Source
13
21
void invoke_fmt(const uint8_t* data, size_t size) {
14
21
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
21
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
21
  if (size <= fixed_size + fixed_size) return;
17
18
13
  const Item1 item1 = assign_from_buf<Item1>(data);
19
13
  data += fixed_size;
20
13
  size -= fixed_size;
21
22
13
  const Item2 item2 = assign_from_buf<Item2>(data);
23
13
  data += fixed_size;
24
13
  size -= fixed_size;
25
26
13
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
13
  auto buf = fmt::memory_buffer();
31
13
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
13
#endif
33
13
}
void invoke_fmt<bool, void*>(unsigned char const*, unsigned long)
Line
Count
Source
13
21
void invoke_fmt(const uint8_t* data, size_t size) {
14
21
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
21
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
21
  if (size <= fixed_size + fixed_size) return;
17
18
14
  const Item1 item1 = assign_from_buf<Item1>(data);
19
14
  data += fixed_size;
20
14
  size -= fixed_size;
21
22
14
  const Item2 item2 = assign_from_buf<Item2>(data);
23
14
  data += fixed_size;
24
14
  size -= fixed_size;
25
26
14
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
14
  auto buf = fmt::memory_buffer();
31
14
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
14
#endif
33
14
}
void invoke_fmt<char, bool>(unsigned char const*, unsigned long)
Line
Count
Source
13
74
void invoke_fmt(const uint8_t* data, size_t size) {
14
74
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
74
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
74
  if (size <= fixed_size + fixed_size) return;
17
18
66
  const Item1 item1 = assign_from_buf<Item1>(data);
19
66
  data += fixed_size;
20
66
  size -= fixed_size;
21
22
66
  const Item2 item2 = assign_from_buf<Item2>(data);
23
66
  data += fixed_size;
24
66
  size -= fixed_size;
25
26
66
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
66
  auto buf = fmt::memory_buffer();
31
66
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
66
#endif
33
66
}
void invoke_fmt<char, char>(unsigned char const*, unsigned long)
Line
Count
Source
13
66
void invoke_fmt(const uint8_t* data, size_t size) {
14
66
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
66
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
66
  if (size <= fixed_size + fixed_size) return;
17
18
58
  const Item1 item1 = assign_from_buf<Item1>(data);
19
58
  data += fixed_size;
20
58
  size -= fixed_size;
21
22
58
  const Item2 item2 = assign_from_buf<Item2>(data);
23
58
  data += fixed_size;
24
58
  size -= fixed_size;
25
26
58
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
58
  auto buf = fmt::memory_buffer();
31
58
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
58
#endif
33
58
}
void invoke_fmt<char, signed char>(unsigned char const*, unsigned long)
Line
Count
Source
13
33
void invoke_fmt(const uint8_t* data, size_t size) {
14
33
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
33
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
33
  if (size <= fixed_size + fixed_size) return;
17
18
25
  const Item1 item1 = assign_from_buf<Item1>(data);
19
25
  data += fixed_size;
20
25
  size -= fixed_size;
21
22
25
  const Item2 item2 = assign_from_buf<Item2>(data);
23
25
  data += fixed_size;
24
25
  size -= fixed_size;
25
26
25
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
25
  auto buf = fmt::memory_buffer();
31
25
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
25
#endif
33
25
}
void invoke_fmt<char, unsigned char>(unsigned char const*, unsigned long)
Line
Count
Source
13
39
void invoke_fmt(const uint8_t* data, size_t size) {
14
39
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
39
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
39
  if (size <= fixed_size + fixed_size) return;
17
18
31
  const Item1 item1 = assign_from_buf<Item1>(data);
19
31
  data += fixed_size;
20
31
  size -= fixed_size;
21
22
31
  const Item2 item2 = assign_from_buf<Item2>(data);
23
31
  data += fixed_size;
24
31
  size -= fixed_size;
25
26
31
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
31
  auto buf = fmt::memory_buffer();
31
31
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
31
#endif
33
31
}
void invoke_fmt<char, short>(unsigned char const*, unsigned long)
Line
Count
Source
13
53
void invoke_fmt(const uint8_t* data, size_t size) {
14
53
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
53
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
53
  if (size <= fixed_size + fixed_size) return;
17
18
45
  const Item1 item1 = assign_from_buf<Item1>(data);
19
45
  data += fixed_size;
20
45
  size -= fixed_size;
21
22
45
  const Item2 item2 = assign_from_buf<Item2>(data);
23
45
  data += fixed_size;
24
45
  size -= fixed_size;
25
26
45
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
45
  auto buf = fmt::memory_buffer();
31
45
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
45
#endif
33
45
}
void invoke_fmt<char, unsigned short>(unsigned char const*, unsigned long)
Line
Count
Source
13
18
void invoke_fmt(const uint8_t* data, size_t size) {
14
18
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
18
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
18
  if (size <= fixed_size + fixed_size) return;
17
18
13
  const Item1 item1 = assign_from_buf<Item1>(data);
19
13
  data += fixed_size;
20
13
  size -= fixed_size;
21
22
13
  const Item2 item2 = assign_from_buf<Item2>(data);
23
13
  data += fixed_size;
24
13
  size -= fixed_size;
25
26
13
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
13
  auto buf = fmt::memory_buffer();
31
13
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
13
#endif
33
13
}
void invoke_fmt<char, int>(unsigned char const*, unsigned long)
Line
Count
Source
13
45
void invoke_fmt(const uint8_t* data, size_t size) {
14
45
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
45
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
45
  if (size <= fixed_size + fixed_size) return;
17
18
37
  const Item1 item1 = assign_from_buf<Item1>(data);
19
37
  data += fixed_size;
20
37
  size -= fixed_size;
21
22
37
  const Item2 item2 = assign_from_buf<Item2>(data);
23
37
  data += fixed_size;
24
37
  size -= fixed_size;
25
26
37
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
37
  auto buf = fmt::memory_buffer();
31
37
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
37
#endif
33
37
}
void invoke_fmt<char, unsigned int>(unsigned char const*, unsigned long)
Line
Count
Source
13
37
void invoke_fmt(const uint8_t* data, size_t size) {
14
37
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
37
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
37
  if (size <= fixed_size + fixed_size) return;
17
18
31
  const Item1 item1 = assign_from_buf<Item1>(data);
19
31
  data += fixed_size;
20
31
  size -= fixed_size;
21
22
31
  const Item2 item2 = assign_from_buf<Item2>(data);
23
31
  data += fixed_size;
24
31
  size -= fixed_size;
25
26
31
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
31
  auto buf = fmt::memory_buffer();
31
31
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
31
#endif
33
31
}
void invoke_fmt<char, long>(unsigned char const*, unsigned long)
Line
Count
Source
13
33
void invoke_fmt(const uint8_t* data, size_t size) {
14
33
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
33
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
33
  if (size <= fixed_size + fixed_size) return;
17
18
25
  const Item1 item1 = assign_from_buf<Item1>(data);
19
25
  data += fixed_size;
20
25
  size -= fixed_size;
21
22
25
  const Item2 item2 = assign_from_buf<Item2>(data);
23
25
  data += fixed_size;
24
25
  size -= fixed_size;
25
26
25
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
25
  auto buf = fmt::memory_buffer();
31
25
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
25
#endif
33
25
}
void invoke_fmt<char, unsigned long>(unsigned char const*, unsigned long)
Line
Count
Source
13
31
void invoke_fmt(const uint8_t* data, size_t size) {
14
31
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
31
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
31
  if (size <= fixed_size + fixed_size) return;
17
18
23
  const Item1 item1 = assign_from_buf<Item1>(data);
19
23
  data += fixed_size;
20
23
  size -= fixed_size;
21
22
23
  const Item2 item2 = assign_from_buf<Item2>(data);
23
23
  data += fixed_size;
24
23
  size -= fixed_size;
25
26
23
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
23
  auto buf = fmt::memory_buffer();
31
23
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
23
#endif
33
23
}
void invoke_fmt<char, float>(unsigned char const*, unsigned long)
Line
Count
Source
13
28
void invoke_fmt(const uint8_t* data, size_t size) {
14
28
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
28
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
28
  if (size <= fixed_size + fixed_size) return;
17
18
21
  const Item1 item1 = assign_from_buf<Item1>(data);
19
21
  data += fixed_size;
20
21
  size -= fixed_size;
21
22
21
  const Item2 item2 = assign_from_buf<Item2>(data);
23
21
  data += fixed_size;
24
21
  size -= fixed_size;
25
26
21
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
21
  auto buf = fmt::memory_buffer();
31
21
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
21
#endif
33
21
}
void invoke_fmt<char, double>(unsigned char const*, unsigned long)
Line
Count
Source
13
23
void invoke_fmt(const uint8_t* data, size_t size) {
14
23
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
23
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
23
  if (size <= fixed_size + fixed_size) return;
17
18
15
  const Item1 item1 = assign_from_buf<Item1>(data);
19
15
  data += fixed_size;
20
15
  size -= fixed_size;
21
22
15
  const Item2 item2 = assign_from_buf<Item2>(data);
23
15
  data += fixed_size;
24
15
  size -= fixed_size;
25
26
15
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
15
  auto buf = fmt::memory_buffer();
31
15
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
15
#endif
33
15
}
void invoke_fmt<char, long double>(unsigned char const*, unsigned long)
Line
Count
Source
13
25
void invoke_fmt(const uint8_t* data, size_t size) {
14
25
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
25
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
25
  if (size <= fixed_size + fixed_size) return;
17
18
17
  const Item1 item1 = assign_from_buf<Item1>(data);
19
17
  data += fixed_size;
20
17
  size -= fixed_size;
21
22
17
  const Item2 item2 = assign_from_buf<Item2>(data);
23
17
  data += fixed_size;
24
17
  size -= fixed_size;
25
26
17
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
17
  auto buf = fmt::memory_buffer();
31
17
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
17
#endif
33
17
}
void invoke_fmt<char, void*>(unsigned char const*, unsigned long)
Line
Count
Source
13
20
void invoke_fmt(const uint8_t* data, size_t size) {
14
20
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
20
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
20
  if (size <= fixed_size + fixed_size) return;
17
18
12
  const Item1 item1 = assign_from_buf<Item1>(data);
19
12
  data += fixed_size;
20
12
  size -= fixed_size;
21
22
12
  const Item2 item2 = assign_from_buf<Item2>(data);
23
12
  data += fixed_size;
24
12
  size -= fixed_size;
25
26
12
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
12
  auto buf = fmt::memory_buffer();
31
12
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
12
#endif
33
12
}
void invoke_fmt<signed char, bool>(unsigned char const*, unsigned long)
Line
Count
Source
13
41
void invoke_fmt(const uint8_t* data, size_t size) {
14
41
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
41
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
41
  if (size <= fixed_size + fixed_size) return;
17
18
33
  const Item1 item1 = assign_from_buf<Item1>(data);
19
33
  data += fixed_size;
20
33
  size -= fixed_size;
21
22
33
  const Item2 item2 = assign_from_buf<Item2>(data);
23
33
  data += fixed_size;
24
33
  size -= fixed_size;
25
26
33
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
33
  auto buf = fmt::memory_buffer();
31
33
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
33
#endif
33
33
}
void invoke_fmt<signed char, char>(unsigned char const*, unsigned long)
Line
Count
Source
13
20
void invoke_fmt(const uint8_t* data, size_t size) {
14
20
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
20
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
20
  if (size <= fixed_size + fixed_size) return;
17
18
13
  const Item1 item1 = assign_from_buf<Item1>(data);
19
13
  data += fixed_size;
20
13
  size -= fixed_size;
21
22
13
  const Item2 item2 = assign_from_buf<Item2>(data);
23
13
  data += fixed_size;
24
13
  size -= fixed_size;
25
26
13
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
13
  auto buf = fmt::memory_buffer();
31
13
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
13
#endif
33
13
}
void invoke_fmt<signed char, signed char>(unsigned char const*, unsigned long)
Line
Count
Source
13
29
void invoke_fmt(const uint8_t* data, size_t size) {
14
29
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
29
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
29
  if (size <= fixed_size + fixed_size) return;
17
18
21
  const Item1 item1 = assign_from_buf<Item1>(data);
19
21
  data += fixed_size;
20
21
  size -= fixed_size;
21
22
21
  const Item2 item2 = assign_from_buf<Item2>(data);
23
21
  data += fixed_size;
24
21
  size -= fixed_size;
25
26
21
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
21
  auto buf = fmt::memory_buffer();
31
21
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
21
#endif
33
21
}
void invoke_fmt<signed char, unsigned char>(unsigned char const*, unsigned long)
Line
Count
Source
13
18
void invoke_fmt(const uint8_t* data, size_t size) {
14
18
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
18
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
18
  if (size <= fixed_size + fixed_size) return;
17
18
10
  const Item1 item1 = assign_from_buf<Item1>(data);
19
10
  data += fixed_size;
20
10
  size -= fixed_size;
21
22
10
  const Item2 item2 = assign_from_buf<Item2>(data);
23
10
  data += fixed_size;
24
10
  size -= fixed_size;
25
26
10
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
10
  auto buf = fmt::memory_buffer();
31
10
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
10
#endif
33
10
}
void invoke_fmt<signed char, short>(unsigned char const*, unsigned long)
Line
Count
Source
13
28
void invoke_fmt(const uint8_t* data, size_t size) {
14
28
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
28
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
28
  if (size <= fixed_size + fixed_size) return;
17
18
21
  const Item1 item1 = assign_from_buf<Item1>(data);
19
21
  data += fixed_size;
20
21
  size -= fixed_size;
21
22
21
  const Item2 item2 = assign_from_buf<Item2>(data);
23
21
  data += fixed_size;
24
21
  size -= fixed_size;
25
26
21
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
21
  auto buf = fmt::memory_buffer();
31
21
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
21
#endif
33
21
}
void invoke_fmt<signed char, unsigned short>(unsigned char const*, unsigned long)
Line
Count
Source
13
20
void invoke_fmt(const uint8_t* data, size_t size) {
14
20
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
20
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
20
  if (size <= fixed_size + fixed_size) return;
17
18
13
  const Item1 item1 = assign_from_buf<Item1>(data);
19
13
  data += fixed_size;
20
13
  size -= fixed_size;
21
22
13
  const Item2 item2 = assign_from_buf<Item2>(data);
23
13
  data += fixed_size;
24
13
  size -= fixed_size;
25
26
13
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
13
  auto buf = fmt::memory_buffer();
31
13
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
13
#endif
33
13
}
void invoke_fmt<signed char, int>(unsigned char const*, unsigned long)
Line
Count
Source
13
27
void invoke_fmt(const uint8_t* data, size_t size) {
14
27
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
27
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
27
  if (size <= fixed_size + fixed_size) return;
17
18
20
  const Item1 item1 = assign_from_buf<Item1>(data);
19
20
  data += fixed_size;
20
20
  size -= fixed_size;
21
22
20
  const Item2 item2 = assign_from_buf<Item2>(data);
23
20
  data += fixed_size;
24
20
  size -= fixed_size;
25
26
20
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
20
  auto buf = fmt::memory_buffer();
31
20
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
20
#endif
33
20
}
void invoke_fmt<signed char, unsigned int>(unsigned char const*, unsigned long)
Line
Count
Source
13
28
void invoke_fmt(const uint8_t* data, size_t size) {
14
28
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
28
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
28
  if (size <= fixed_size + fixed_size) return;
17
18
20
  const Item1 item1 = assign_from_buf<Item1>(data);
19
20
  data += fixed_size;
20
20
  size -= fixed_size;
21
22
20
  const Item2 item2 = assign_from_buf<Item2>(data);
23
20
  data += fixed_size;
24
20
  size -= fixed_size;
25
26
20
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
20
  auto buf = fmt::memory_buffer();
31
20
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
20
#endif
33
20
}
void invoke_fmt<signed char, long>(unsigned char const*, unsigned long)
Line
Count
Source
13
26
void invoke_fmt(const uint8_t* data, size_t size) {
14
26
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
26
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
26
  if (size <= fixed_size + fixed_size) return;
17
18
19
  const Item1 item1 = assign_from_buf<Item1>(data);
19
19
  data += fixed_size;
20
19
  size -= fixed_size;
21
22
19
  const Item2 item2 = assign_from_buf<Item2>(data);
23
19
  data += fixed_size;
24
19
  size -= fixed_size;
25
26
19
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
19
  auto buf = fmt::memory_buffer();
31
19
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
19
#endif
33
19
}
void invoke_fmt<signed char, unsigned long>(unsigned char const*, unsigned long)
Line
Count
Source
13
30
void invoke_fmt(const uint8_t* data, size_t size) {
14
30
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
30
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
30
  if (size <= fixed_size + fixed_size) return;
17
18
23
  const Item1 item1 = assign_from_buf<Item1>(data);
19
23
  data += fixed_size;
20
23
  size -= fixed_size;
21
22
23
  const Item2 item2 = assign_from_buf<Item2>(data);
23
23
  data += fixed_size;
24
23
  size -= fixed_size;
25
26
23
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
23
  auto buf = fmt::memory_buffer();
31
23
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
23
#endif
33
23
}
void invoke_fmt<signed char, float>(unsigned char const*, unsigned long)
Line
Count
Source
13
20
void invoke_fmt(const uint8_t* data, size_t size) {
14
20
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
20
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
20
  if (size <= fixed_size + fixed_size) return;
17
18
12
  const Item1 item1 = assign_from_buf<Item1>(data);
19
12
  data += fixed_size;
20
12
  size -= fixed_size;
21
22
12
  const Item2 item2 = assign_from_buf<Item2>(data);
23
12
  data += fixed_size;
24
12
  size -= fixed_size;
25
26
12
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
12
  auto buf = fmt::memory_buffer();
31
12
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
12
#endif
33
12
}
void invoke_fmt<signed char, double>(unsigned char const*, unsigned long)
Line
Count
Source
13
35
void invoke_fmt(const uint8_t* data, size_t size) {
14
35
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
35
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
35
  if (size <= fixed_size + fixed_size) return;
17
18
27
  const Item1 item1 = assign_from_buf<Item1>(data);
19
27
  data += fixed_size;
20
27
  size -= fixed_size;
21
22
27
  const Item2 item2 = assign_from_buf<Item2>(data);
23
27
  data += fixed_size;
24
27
  size -= fixed_size;
25
26
27
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
27
  auto buf = fmt::memory_buffer();
31
27
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
27
#endif
33
27
}
void invoke_fmt<signed char, long double>(unsigned char const*, unsigned long)
Line
Count
Source
13
24
void invoke_fmt(const uint8_t* data, size_t size) {
14
24
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
24
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
24
  if (size <= fixed_size + fixed_size) return;
17
18
16
  const Item1 item1 = assign_from_buf<Item1>(data);
19
16
  data += fixed_size;
20
16
  size -= fixed_size;
21
22
16
  const Item2 item2 = assign_from_buf<Item2>(data);
23
16
  data += fixed_size;
24
16
  size -= fixed_size;
25
26
16
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
16
  auto buf = fmt::memory_buffer();
31
16
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
16
#endif
33
16
}
void invoke_fmt<signed char, void*>(unsigned char const*, unsigned long)
Line
Count
Source
13
23
void invoke_fmt(const uint8_t* data, size_t size) {
14
23
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
23
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
23
  if (size <= fixed_size + fixed_size) return;
17
18
15
  const Item1 item1 = assign_from_buf<Item1>(data);
19
15
  data += fixed_size;
20
15
  size -= fixed_size;
21
22
15
  const Item2 item2 = assign_from_buf<Item2>(data);
23
15
  data += fixed_size;
24
15
  size -= fixed_size;
25
26
15
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
15
  auto buf = fmt::memory_buffer();
31
15
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
15
#endif
33
15
}
void invoke_fmt<unsigned char, bool>(unsigned char const*, unsigned long)
Line
Count
Source
13
27
void invoke_fmt(const uint8_t* data, size_t size) {
14
27
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
27
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
27
  if (size <= fixed_size + fixed_size) return;
17
18
19
  const Item1 item1 = assign_from_buf<Item1>(data);
19
19
  data += fixed_size;
20
19
  size -= fixed_size;
21
22
19
  const Item2 item2 = assign_from_buf<Item2>(data);
23
19
  data += fixed_size;
24
19
  size -= fixed_size;
25
26
19
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
19
  auto buf = fmt::memory_buffer();
31
19
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
19
#endif
33
19
}
void invoke_fmt<unsigned char, char>(unsigned char const*, unsigned long)
Line
Count
Source
13
29
void invoke_fmt(const uint8_t* data, size_t size) {
14
29
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
29
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
29
  if (size <= fixed_size + fixed_size) return;
17
18
21
  const Item1 item1 = assign_from_buf<Item1>(data);
19
21
  data += fixed_size;
20
21
  size -= fixed_size;
21
22
21
  const Item2 item2 = assign_from_buf<Item2>(data);
23
21
  data += fixed_size;
24
21
  size -= fixed_size;
25
26
21
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
21
  auto buf = fmt::memory_buffer();
31
21
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
21
#endif
33
21
}
void invoke_fmt<unsigned char, signed char>(unsigned char const*, unsigned long)
Line
Count
Source
13
41
void invoke_fmt(const uint8_t* data, size_t size) {
14
41
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
41
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
41
  if (size <= fixed_size + fixed_size) return;
17
18
34
  const Item1 item1 = assign_from_buf<Item1>(data);
19
34
  data += fixed_size;
20
34
  size -= fixed_size;
21
22
34
  const Item2 item2 = assign_from_buf<Item2>(data);
23
34
  data += fixed_size;
24
34
  size -= fixed_size;
25
26
34
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
34
  auto buf = fmt::memory_buffer();
31
34
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
34
#endif
33
34
}
void invoke_fmt<unsigned char, unsigned char>(unsigned char const*, unsigned long)
Line
Count
Source
13
21
void invoke_fmt(const uint8_t* data, size_t size) {
14
21
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
21
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
21
  if (size <= fixed_size + fixed_size) return;
17
18
13
  const Item1 item1 = assign_from_buf<Item1>(data);
19
13
  data += fixed_size;
20
13
  size -= fixed_size;
21
22
13
  const Item2 item2 = assign_from_buf<Item2>(data);
23
13
  data += fixed_size;
24
13
  size -= fixed_size;
25
26
13
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
13
  auto buf = fmt::memory_buffer();
31
13
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
13
#endif
33
13
}
void invoke_fmt<unsigned char, short>(unsigned char const*, unsigned long)
Line
Count
Source
13
27
void invoke_fmt(const uint8_t* data, size_t size) {
14
27
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
27
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
27
  if (size <= fixed_size + fixed_size) return;
17
18
20
  const Item1 item1 = assign_from_buf<Item1>(data);
19
20
  data += fixed_size;
20
20
  size -= fixed_size;
21
22
20
  const Item2 item2 = assign_from_buf<Item2>(data);
23
20
  data += fixed_size;
24
20
  size -= fixed_size;
25
26
20
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
20
  auto buf = fmt::memory_buffer();
31
20
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
20
#endif
33
20
}
void invoke_fmt<unsigned char, unsigned short>(unsigned char const*, unsigned long)
Line
Count
Source
13
23
void invoke_fmt(const uint8_t* data, size_t size) {
14
23
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
23
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
23
  if (size <= fixed_size + fixed_size) return;
17
18
15
  const Item1 item1 = assign_from_buf<Item1>(data);
19
15
  data += fixed_size;
20
15
  size -= fixed_size;
21
22
15
  const Item2 item2 = assign_from_buf<Item2>(data);
23
15
  data += fixed_size;
24
15
  size -= fixed_size;
25
26
15
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
15
  auto buf = fmt::memory_buffer();
31
15
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
15
#endif
33
15
}
void invoke_fmt<unsigned char, int>(unsigned char const*, unsigned long)
Line
Count
Source
13
38
void invoke_fmt(const uint8_t* data, size_t size) {
14
38
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
38
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
38
  if (size <= fixed_size + fixed_size) return;
17
18
30
  const Item1 item1 = assign_from_buf<Item1>(data);
19
30
  data += fixed_size;
20
30
  size -= fixed_size;
21
22
30
  const Item2 item2 = assign_from_buf<Item2>(data);
23
30
  data += fixed_size;
24
30
  size -= fixed_size;
25
26
30
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
30
  auto buf = fmt::memory_buffer();
31
30
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
30
#endif
33
30
}
void invoke_fmt<unsigned char, unsigned int>(unsigned char const*, unsigned long)
Line
Count
Source
13
34
void invoke_fmt(const uint8_t* data, size_t size) {
14
34
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
34
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
34
  if (size <= fixed_size + fixed_size) return;
17
18
26
  const Item1 item1 = assign_from_buf<Item1>(data);
19
26
  data += fixed_size;
20
26
  size -= fixed_size;
21
22
26
  const Item2 item2 = assign_from_buf<Item2>(data);
23
26
  data += fixed_size;
24
26
  size -= fixed_size;
25
26
26
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
26
  auto buf = fmt::memory_buffer();
31
26
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
26
#endif
33
26
}
void invoke_fmt<unsigned char, long>(unsigned char const*, unsigned long)
Line
Count
Source
13
16
void invoke_fmt(const uint8_t* data, size_t size) {
14
16
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
16
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
16
  if (size <= fixed_size + fixed_size) return;
17
18
9
  const Item1 item1 = assign_from_buf<Item1>(data);
19
9
  data += fixed_size;
20
9
  size -= fixed_size;
21
22
9
  const Item2 item2 = assign_from_buf<Item2>(data);
23
9
  data += fixed_size;
24
9
  size -= fixed_size;
25
26
9
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
9
  auto buf = fmt::memory_buffer();
31
9
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
9
#endif
33
9
}
void invoke_fmt<unsigned char, unsigned long>(unsigned char const*, unsigned long)
Line
Count
Source
13
30
void invoke_fmt(const uint8_t* data, size_t size) {
14
30
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
30
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
30
  if (size <= fixed_size + fixed_size) return;
17
18
22
  const Item1 item1 = assign_from_buf<Item1>(data);
19
22
  data += fixed_size;
20
22
  size -= fixed_size;
21
22
22
  const Item2 item2 = assign_from_buf<Item2>(data);
23
22
  data += fixed_size;
24
22
  size -= fixed_size;
25
26
22
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
22
  auto buf = fmt::memory_buffer();
31
22
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
22
#endif
33
22
}
void invoke_fmt<unsigned char, float>(unsigned char const*, unsigned long)
Line
Count
Source
13
19
void invoke_fmt(const uint8_t* data, size_t size) {
14
19
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
19
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
19
  if (size <= fixed_size + fixed_size) return;
17
18
11
  const Item1 item1 = assign_from_buf<Item1>(data);
19
11
  data += fixed_size;
20
11
  size -= fixed_size;
21
22
11
  const Item2 item2 = assign_from_buf<Item2>(data);
23
11
  data += fixed_size;
24
11
  size -= fixed_size;
25
26
11
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
11
  auto buf = fmt::memory_buffer();
31
11
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
11
#endif
33
11
}
void invoke_fmt<unsigned char, double>(unsigned char const*, unsigned long)
Line
Count
Source
13
20
void invoke_fmt(const uint8_t* data, size_t size) {
14
20
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
20
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
20
  if (size <= fixed_size + fixed_size) return;
17
18
15
  const Item1 item1 = assign_from_buf<Item1>(data);
19
15
  data += fixed_size;
20
15
  size -= fixed_size;
21
22
15
  const Item2 item2 = assign_from_buf<Item2>(data);
23
15
  data += fixed_size;
24
15
  size -= fixed_size;
25
26
15
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
15
  auto buf = fmt::memory_buffer();
31
15
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
15
#endif
33
15
}
void invoke_fmt<unsigned char, long double>(unsigned char const*, unsigned long)
Line
Count
Source
13
22
void invoke_fmt(const uint8_t* data, size_t size) {
14
22
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
22
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
22
  if (size <= fixed_size + fixed_size) return;
17
18
14
  const Item1 item1 = assign_from_buf<Item1>(data);
19
14
  data += fixed_size;
20
14
  size -= fixed_size;
21
22
14
  const Item2 item2 = assign_from_buf<Item2>(data);
23
14
  data += fixed_size;
24
14
  size -= fixed_size;
25
26
14
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
14
  auto buf = fmt::memory_buffer();
31
14
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
14
#endif
33
14
}
void invoke_fmt<unsigned char, void*>(unsigned char const*, unsigned long)
Line
Count
Source
13
11
void invoke_fmt(const uint8_t* data, size_t size) {
14
11
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
11
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
11
  if (size <= fixed_size + fixed_size) return;
17
18
4
  const Item1 item1 = assign_from_buf<Item1>(data);
19
4
  data += fixed_size;
20
4
  size -= fixed_size;
21
22
4
  const Item2 item2 = assign_from_buf<Item2>(data);
23
4
  data += fixed_size;
24
4
  size -= fixed_size;
25
26
4
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
4
  auto buf = fmt::memory_buffer();
31
4
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
4
#endif
33
4
}
void invoke_fmt<short, bool>(unsigned char const*, unsigned long)
Line
Count
Source
13
22
void invoke_fmt(const uint8_t* data, size_t size) {
14
22
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
22
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
22
  if (size <= fixed_size + fixed_size) return;
17
18
14
  const Item1 item1 = assign_from_buf<Item1>(data);
19
14
  data += fixed_size;
20
14
  size -= fixed_size;
21
22
14
  const Item2 item2 = assign_from_buf<Item2>(data);
23
14
  data += fixed_size;
24
14
  size -= fixed_size;
25
26
14
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
14
  auto buf = fmt::memory_buffer();
31
14
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
14
#endif
33
14
}
void invoke_fmt<short, char>(unsigned char const*, unsigned long)
Line
Count
Source
13
21
void invoke_fmt(const uint8_t* data, size_t size) {
14
21
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
21
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
21
  if (size <= fixed_size + fixed_size) return;
17
18
13
  const Item1 item1 = assign_from_buf<Item1>(data);
19
13
  data += fixed_size;
20
13
  size -= fixed_size;
21
22
13
  const Item2 item2 = assign_from_buf<Item2>(data);
23
13
  data += fixed_size;
24
13
  size -= fixed_size;
25
26
13
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
13
  auto buf = fmt::memory_buffer();
31
13
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
13
#endif
33
13
}
void invoke_fmt<short, signed char>(unsigned char const*, unsigned long)
Line
Count
Source
13
32
void invoke_fmt(const uint8_t* data, size_t size) {
14
32
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
32
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
32
  if (size <= fixed_size + fixed_size) return;
17
18
24
  const Item1 item1 = assign_from_buf<Item1>(data);
19
24
  data += fixed_size;
20
24
  size -= fixed_size;
21
22
24
  const Item2 item2 = assign_from_buf<Item2>(data);
23
24
  data += fixed_size;
24
24
  size -= fixed_size;
25
26
24
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
24
  auto buf = fmt::memory_buffer();
31
24
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
24
#endif
33
24
}
void invoke_fmt<short, unsigned char>(unsigned char const*, unsigned long)
Line
Count
Source
13
16
void invoke_fmt(const uint8_t* data, size_t size) {
14
16
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
16
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
16
  if (size <= fixed_size + fixed_size) return;
17
18
10
  const Item1 item1 = assign_from_buf<Item1>(data);
19
10
  data += fixed_size;
20
10
  size -= fixed_size;
21
22
10
  const Item2 item2 = assign_from_buf<Item2>(data);
23
10
  data += fixed_size;
24
10
  size -= fixed_size;
25
26
10
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
10
  auto buf = fmt::memory_buffer();
31
10
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
10
#endif
33
10
}
void invoke_fmt<short, short>(unsigned char const*, unsigned long)
Line
Count
Source
13
30
void invoke_fmt(const uint8_t* data, size_t size) {
14
30
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
30
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
30
  if (size <= fixed_size + fixed_size) return;
17
18
22
  const Item1 item1 = assign_from_buf<Item1>(data);
19
22
  data += fixed_size;
20
22
  size -= fixed_size;
21
22
22
  const Item2 item2 = assign_from_buf<Item2>(data);
23
22
  data += fixed_size;
24
22
  size -= fixed_size;
25
26
22
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
22
  auto buf = fmt::memory_buffer();
31
22
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
22
#endif
33
22
}
void invoke_fmt<short, unsigned short>(unsigned char const*, unsigned long)
Line
Count
Source
13
19
void invoke_fmt(const uint8_t* data, size_t size) {
14
19
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
19
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
19
  if (size <= fixed_size + fixed_size) return;
17
18
12
  const Item1 item1 = assign_from_buf<Item1>(data);
19
12
  data += fixed_size;
20
12
  size -= fixed_size;
21
22
12
  const Item2 item2 = assign_from_buf<Item2>(data);
23
12
  data += fixed_size;
24
12
  size -= fixed_size;
25
26
12
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
12
  auto buf = fmt::memory_buffer();
31
12
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
12
#endif
33
12
}
void invoke_fmt<short, int>(unsigned char const*, unsigned long)
Line
Count
Source
13
40
void invoke_fmt(const uint8_t* data, size_t size) {
14
40
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
40
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
40
  if (size <= fixed_size + fixed_size) return;
17
18
32
  const Item1 item1 = assign_from_buf<Item1>(data);
19
32
  data += fixed_size;
20
32
  size -= fixed_size;
21
22
32
  const Item2 item2 = assign_from_buf<Item2>(data);
23
32
  data += fixed_size;
24
32
  size -= fixed_size;
25
26
32
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
32
  auto buf = fmt::memory_buffer();
31
32
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
32
#endif
33
32
}
void invoke_fmt<short, unsigned int>(unsigned char const*, unsigned long)
Line
Count
Source
13
37
void invoke_fmt(const uint8_t* data, size_t size) {
14
37
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
37
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
37
  if (size <= fixed_size + fixed_size) return;
17
18
29
  const Item1 item1 = assign_from_buf<Item1>(data);
19
29
  data += fixed_size;
20
29
  size -= fixed_size;
21
22
29
  const Item2 item2 = assign_from_buf<Item2>(data);
23
29
  data += fixed_size;
24
29
  size -= fixed_size;
25
26
29
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
29
  auto buf = fmt::memory_buffer();
31
29
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
29
#endif
33
29
}
void invoke_fmt<short, long>(unsigned char const*, unsigned long)
Line
Count
Source
13
55
void invoke_fmt(const uint8_t* data, size_t size) {
14
55
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
55
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
55
  if (size <= fixed_size + fixed_size) return;
17
18
47
  const Item1 item1 = assign_from_buf<Item1>(data);
19
47
  data += fixed_size;
20
47
  size -= fixed_size;
21
22
47
  const Item2 item2 = assign_from_buf<Item2>(data);
23
47
  data += fixed_size;
24
47
  size -= fixed_size;
25
26
47
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
47
  auto buf = fmt::memory_buffer();
31
47
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
47
#endif
33
47
}
void invoke_fmt<short, unsigned long>(unsigned char const*, unsigned long)
Line
Count
Source
13
27
void invoke_fmt(const uint8_t* data, size_t size) {
14
27
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
27
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
27
  if (size <= fixed_size + fixed_size) return;
17
18
21
  const Item1 item1 = assign_from_buf<Item1>(data);
19
21
  data += fixed_size;
20
21
  size -= fixed_size;
21
22
21
  const Item2 item2 = assign_from_buf<Item2>(data);
23
21
  data += fixed_size;
24
21
  size -= fixed_size;
25
26
21
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
21
  auto buf = fmt::memory_buffer();
31
21
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
21
#endif
33
21
}
void invoke_fmt<short, float>(unsigned char const*, unsigned long)
Line
Count
Source
13
25
void invoke_fmt(const uint8_t* data, size_t size) {
14
25
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
25
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
25
  if (size <= fixed_size + fixed_size) return;
17
18
17
  const Item1 item1 = assign_from_buf<Item1>(data);
19
17
  data += fixed_size;
20
17
  size -= fixed_size;
21
22
17
  const Item2 item2 = assign_from_buf<Item2>(data);
23
17
  data += fixed_size;
24
17
  size -= fixed_size;
25
26
17
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
17
  auto buf = fmt::memory_buffer();
31
17
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
17
#endif
33
17
}
void invoke_fmt<short, double>(unsigned char const*, unsigned long)
Line
Count
Source
13
38
void invoke_fmt(const uint8_t* data, size_t size) {
14
38
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
38
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
38
  if (size <= fixed_size + fixed_size) return;
17
18
30
  const Item1 item1 = assign_from_buf<Item1>(data);
19
30
  data += fixed_size;
20
30
  size -= fixed_size;
21
22
30
  const Item2 item2 = assign_from_buf<Item2>(data);
23
30
  data += fixed_size;
24
30
  size -= fixed_size;
25
26
30
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
30
  auto buf = fmt::memory_buffer();
31
30
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
30
#endif
33
30
}
void invoke_fmt<short, long double>(unsigned char const*, unsigned long)
Line
Count
Source
13
25
void invoke_fmt(const uint8_t* data, size_t size) {
14
25
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
25
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
25
  if (size <= fixed_size + fixed_size) return;
17
18
17
  const Item1 item1 = assign_from_buf<Item1>(data);
19
17
  data += fixed_size;
20
17
  size -= fixed_size;
21
22
17
  const Item2 item2 = assign_from_buf<Item2>(data);
23
17
  data += fixed_size;
24
17
  size -= fixed_size;
25
26
17
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
17
  auto buf = fmt::memory_buffer();
31
17
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
17
#endif
33
17
}
void invoke_fmt<short, void*>(unsigned char const*, unsigned long)
Line
Count
Source
13
20
void invoke_fmt(const uint8_t* data, size_t size) {
14
20
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
20
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
20
  if (size <= fixed_size + fixed_size) return;
17
18
12
  const Item1 item1 = assign_from_buf<Item1>(data);
19
12
  data += fixed_size;
20
12
  size -= fixed_size;
21
22
12
  const Item2 item2 = assign_from_buf<Item2>(data);
23
12
  data += fixed_size;
24
12
  size -= fixed_size;
25
26
12
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
12
  auto buf = fmt::memory_buffer();
31
12
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
12
#endif
33
12
}
void invoke_fmt<unsigned short, bool>(unsigned char const*, unsigned long)
Line
Count
Source
13
16
void invoke_fmt(const uint8_t* data, size_t size) {
14
16
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
16
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
16
  if (size <= fixed_size + fixed_size) return;
17
18
8
  const Item1 item1 = assign_from_buf<Item1>(data);
19
8
  data += fixed_size;
20
8
  size -= fixed_size;
21
22
8
  const Item2 item2 = assign_from_buf<Item2>(data);
23
8
  data += fixed_size;
24
8
  size -= fixed_size;
25
26
8
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
8
  auto buf = fmt::memory_buffer();
31
8
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
8
#endif
33
8
}
void invoke_fmt<unsigned short, char>(unsigned char const*, unsigned long)
Line
Count
Source
13
28
void invoke_fmt(const uint8_t* data, size_t size) {
14
28
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
28
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
28
  if (size <= fixed_size + fixed_size) return;
17
18
20
  const Item1 item1 = assign_from_buf<Item1>(data);
19
20
  data += fixed_size;
20
20
  size -= fixed_size;
21
22
20
  const Item2 item2 = assign_from_buf<Item2>(data);
23
20
  data += fixed_size;
24
20
  size -= fixed_size;
25
26
20
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
20
  auto buf = fmt::memory_buffer();
31
20
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
20
#endif
33
20
}
void invoke_fmt<unsigned short, signed char>(unsigned char const*, unsigned long)
Line
Count
Source
13
26
void invoke_fmt(const uint8_t* data, size_t size) {
14
26
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
26
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
26
  if (size <= fixed_size + fixed_size) return;
17
18
18
  const Item1 item1 = assign_from_buf<Item1>(data);
19
18
  data += fixed_size;
20
18
  size -= fixed_size;
21
22
18
  const Item2 item2 = assign_from_buf<Item2>(data);
23
18
  data += fixed_size;
24
18
  size -= fixed_size;
25
26
18
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
18
  auto buf = fmt::memory_buffer();
31
18
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
18
#endif
33
18
}
void invoke_fmt<unsigned short, unsigned char>(unsigned char const*, unsigned long)
Line
Count
Source
13
17
void invoke_fmt(const uint8_t* data, size_t size) {
14
17
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
17
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
17
  if (size <= fixed_size + fixed_size) return;
17
18
10
  const Item1 item1 = assign_from_buf<Item1>(data);
19
10
  data += fixed_size;
20
10
  size -= fixed_size;
21
22
10
  const Item2 item2 = assign_from_buf<Item2>(data);
23
10
  data += fixed_size;
24
10
  size -= fixed_size;
25
26
10
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
10
  auto buf = fmt::memory_buffer();
31
10
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
10
#endif
33
10
}
void invoke_fmt<unsigned short, short>(unsigned char const*, unsigned long)
Line
Count
Source
13
27
void invoke_fmt(const uint8_t* data, size_t size) {
14
27
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
27
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
27
  if (size <= fixed_size + fixed_size) return;
17
18
19
  const Item1 item1 = assign_from_buf<Item1>(data);
19
19
  data += fixed_size;
20
19
  size -= fixed_size;
21
22
19
  const Item2 item2 = assign_from_buf<Item2>(data);
23
19
  data += fixed_size;
24
19
  size -= fixed_size;
25
26
19
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
19
  auto buf = fmt::memory_buffer();
31
19
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
19
#endif
33
19
}
void invoke_fmt<unsigned short, unsigned short>(unsigned char const*, unsigned long)
Line
Count
Source
13
20
void invoke_fmt(const uint8_t* data, size_t size) {
14
20
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
20
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
20
  if (size <= fixed_size + fixed_size) return;
17
18
12
  const Item1 item1 = assign_from_buf<Item1>(data);
19
12
  data += fixed_size;
20
12
  size -= fixed_size;
21
22
12
  const Item2 item2 = assign_from_buf<Item2>(data);
23
12
  data += fixed_size;
24
12
  size -= fixed_size;
25
26
12
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
12
  auto buf = fmt::memory_buffer();
31
12
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
12
#endif
33
12
}
void invoke_fmt<unsigned short, int>(unsigned char const*, unsigned long)
Line
Count
Source
13
29
void invoke_fmt(const uint8_t* data, size_t size) {
14
29
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
29
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
29
  if (size <= fixed_size + fixed_size) return;
17
18
22
  const Item1 item1 = assign_from_buf<Item1>(data);
19
22
  data += fixed_size;
20
22
  size -= fixed_size;
21
22
22
  const Item2 item2 = assign_from_buf<Item2>(data);
23
22
  data += fixed_size;
24
22
  size -= fixed_size;
25
26
22
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
22
  auto buf = fmt::memory_buffer();
31
22
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
22
#endif
33
22
}
void invoke_fmt<unsigned short, unsigned int>(unsigned char const*, unsigned long)
Line
Count
Source
13
29
void invoke_fmt(const uint8_t* data, size_t size) {
14
29
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
29
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
29
  if (size <= fixed_size + fixed_size) return;
17
18
21
  const Item1 item1 = assign_from_buf<Item1>(data);
19
21
  data += fixed_size;
20
21
  size -= fixed_size;
21
22
21
  const Item2 item2 = assign_from_buf<Item2>(data);
23
21
  data += fixed_size;
24
21
  size -= fixed_size;
25
26
21
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
21
  auto buf = fmt::memory_buffer();
31
21
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
21
#endif
33
21
}
void invoke_fmt<unsigned short, long>(unsigned char const*, unsigned long)
Line
Count
Source
13
24
void invoke_fmt(const uint8_t* data, size_t size) {
14
24
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
24
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
24
  if (size <= fixed_size + fixed_size) return;
17
18
16
  const Item1 item1 = assign_from_buf<Item1>(data);
19
16
  data += fixed_size;
20
16
  size -= fixed_size;
21
22
16
  const Item2 item2 = assign_from_buf<Item2>(data);
23
16
  data += fixed_size;
24
16
  size -= fixed_size;
25
26
16
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
16
  auto buf = fmt::memory_buffer();
31
16
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
16
#endif
33
16
}
void invoke_fmt<unsigned short, unsigned long>(unsigned char const*, unsigned long)
Line
Count
Source
13
21
void invoke_fmt(const uint8_t* data, size_t size) {
14
21
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
21
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
21
  if (size <= fixed_size + fixed_size) return;
17
18
13
  const Item1 item1 = assign_from_buf<Item1>(data);
19
13
  data += fixed_size;
20
13
  size -= fixed_size;
21
22
13
  const Item2 item2 = assign_from_buf<Item2>(data);
23
13
  data += fixed_size;
24
13
  size -= fixed_size;
25
26
13
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
13
  auto buf = fmt::memory_buffer();
31
13
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
13
#endif
33
13
}
void invoke_fmt<unsigned short, float>(unsigned char const*, unsigned long)
Line
Count
Source
13
23
void invoke_fmt(const uint8_t* data, size_t size) {
14
23
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
23
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
23
  if (size <= fixed_size + fixed_size) return;
17
18
15
  const Item1 item1 = assign_from_buf<Item1>(data);
19
15
  data += fixed_size;
20
15
  size -= fixed_size;
21
22
15
  const Item2 item2 = assign_from_buf<Item2>(data);
23
15
  data += fixed_size;
24
15
  size -= fixed_size;
25
26
15
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
15
  auto buf = fmt::memory_buffer();
31
15
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
15
#endif
33
15
}
void invoke_fmt<unsigned short, double>(unsigned char const*, unsigned long)
Line
Count
Source
13
21
void invoke_fmt(const uint8_t* data, size_t size) {
14
21
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
21
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
21
  if (size <= fixed_size + fixed_size) return;
17
18
16
  const Item1 item1 = assign_from_buf<Item1>(data);
19
16
  data += fixed_size;
20
16
  size -= fixed_size;
21
22
16
  const Item2 item2 = assign_from_buf<Item2>(data);
23
16
  data += fixed_size;
24
16
  size -= fixed_size;
25
26
16
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
16
  auto buf = fmt::memory_buffer();
31
16
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
16
#endif
33
16
}
void invoke_fmt<unsigned short, long double>(unsigned char const*, unsigned long)
Line
Count
Source
13
13
void invoke_fmt(const uint8_t* data, size_t size) {
14
13
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
13
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
13
  if (size <= fixed_size + fixed_size) return;
17
18
6
  const Item1 item1 = assign_from_buf<Item1>(data);
19
6
  data += fixed_size;
20
6
  size -= fixed_size;
21
22
6
  const Item2 item2 = assign_from_buf<Item2>(data);
23
6
  data += fixed_size;
24
6
  size -= fixed_size;
25
26
6
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
6
  auto buf = fmt::memory_buffer();
31
6
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
6
#endif
33
6
}
void invoke_fmt<unsigned short, void*>(unsigned char const*, unsigned long)
Line
Count
Source
13
19
void invoke_fmt(const uint8_t* data, size_t size) {
14
19
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
19
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
19
  if (size <= fixed_size + fixed_size) return;
17
18
13
  const Item1 item1 = assign_from_buf<Item1>(data);
19
13
  data += fixed_size;
20
13
  size -= fixed_size;
21
22
13
  const Item2 item2 = assign_from_buf<Item2>(data);
23
13
  data += fixed_size;
24
13
  size -= fixed_size;
25
26
13
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
13
  auto buf = fmt::memory_buffer();
31
13
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
13
#endif
33
13
}
void invoke_fmt<int, bool>(unsigned char const*, unsigned long)
Line
Count
Source
13
37
void invoke_fmt(const uint8_t* data, size_t size) {
14
37
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
37
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
37
  if (size <= fixed_size + fixed_size) return;
17
18
29
  const Item1 item1 = assign_from_buf<Item1>(data);
19
29
  data += fixed_size;
20
29
  size -= fixed_size;
21
22
29
  const Item2 item2 = assign_from_buf<Item2>(data);
23
29
  data += fixed_size;
24
29
  size -= fixed_size;
25
26
29
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
29
  auto buf = fmt::memory_buffer();
31
29
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
29
#endif
33
29
}
void invoke_fmt<int, char>(unsigned char const*, unsigned long)
Line
Count
Source
13
31
void invoke_fmt(const uint8_t* data, size_t size) {
14
31
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
31
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
31
  if (size <= fixed_size + fixed_size) return;
17
18
24
  const Item1 item1 = assign_from_buf<Item1>(data);
19
24
  data += fixed_size;
20
24
  size -= fixed_size;
21
22
24
  const Item2 item2 = assign_from_buf<Item2>(data);
23
24
  data += fixed_size;
24
24
  size -= fixed_size;
25
26
24
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
24
  auto buf = fmt::memory_buffer();
31
24
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
24
#endif
33
24
}
void invoke_fmt<int, signed char>(unsigned char const*, unsigned long)
Line
Count
Source
13
63
void invoke_fmt(const uint8_t* data, size_t size) {
14
63
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
63
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
63
  if (size <= fixed_size + fixed_size) return;
17
18
55
  const Item1 item1 = assign_from_buf<Item1>(data);
19
55
  data += fixed_size;
20
55
  size -= fixed_size;
21
22
55
  const Item2 item2 = assign_from_buf<Item2>(data);
23
55
  data += fixed_size;
24
55
  size -= fixed_size;
25
26
55
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
55
  auto buf = fmt::memory_buffer();
31
55
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
55
#endif
33
55
}
void invoke_fmt<int, unsigned char>(unsigned char const*, unsigned long)
Line
Count
Source
13
29
void invoke_fmt(const uint8_t* data, size_t size) {
14
29
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
29
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
29
  if (size <= fixed_size + fixed_size) return;
17
18
22
  const Item1 item1 = assign_from_buf<Item1>(data);
19
22
  data += fixed_size;
20
22
  size -= fixed_size;
21
22
22
  const Item2 item2 = assign_from_buf<Item2>(data);
23
22
  data += fixed_size;
24
22
  size -= fixed_size;
25
26
22
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
22
  auto buf = fmt::memory_buffer();
31
22
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
22
#endif
33
22
}
void invoke_fmt<int, short>(unsigned char const*, unsigned long)
Line
Count
Source
13
34
void invoke_fmt(const uint8_t* data, size_t size) {
14
34
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
34
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
34
  if (size <= fixed_size + fixed_size) return;
17
18
26
  const Item1 item1 = assign_from_buf<Item1>(data);
19
26
  data += fixed_size;
20
26
  size -= fixed_size;
21
22
26
  const Item2 item2 = assign_from_buf<Item2>(data);
23
26
  data += fixed_size;
24
26
  size -= fixed_size;
25
26
26
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
26
  auto buf = fmt::memory_buffer();
31
26
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
26
#endif
33
26
}
void invoke_fmt<int, unsigned short>(unsigned char const*, unsigned long)
Line
Count
Source
13
32
void invoke_fmt(const uint8_t* data, size_t size) {
14
32
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
32
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
32
  if (size <= fixed_size + fixed_size) return;
17
18
24
  const Item1 item1 = assign_from_buf<Item1>(data);
19
24
  data += fixed_size;
20
24
  size -= fixed_size;
21
22
24
  const Item2 item2 = assign_from_buf<Item2>(data);
23
24
  data += fixed_size;
24
24
  size -= fixed_size;
25
26
24
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
24
  auto buf = fmt::memory_buffer();
31
24
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
24
#endif
33
24
}
void invoke_fmt<int, int>(unsigned char const*, unsigned long)
Line
Count
Source
13
41
void invoke_fmt(const uint8_t* data, size_t size) {
14
41
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
41
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
41
  if (size <= fixed_size + fixed_size) return;
17
18
33
  const Item1 item1 = assign_from_buf<Item1>(data);
19
33
  data += fixed_size;
20
33
  size -= fixed_size;
21
22
33
  const Item2 item2 = assign_from_buf<Item2>(data);
23
33
  data += fixed_size;
24
33
  size -= fixed_size;
25
26
33
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
33
  auto buf = fmt::memory_buffer();
31
33
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
33
#endif
33
33
}
void invoke_fmt<int, unsigned int>(unsigned char const*, unsigned long)
Line
Count
Source
13
25
void invoke_fmt(const uint8_t* data, size_t size) {
14
25
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
25
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
25
  if (size <= fixed_size + fixed_size) return;
17
18
18
  const Item1 item1 = assign_from_buf<Item1>(data);
19
18
  data += fixed_size;
20
18
  size -= fixed_size;
21
22
18
  const Item2 item2 = assign_from_buf<Item2>(data);
23
18
  data += fixed_size;
24
18
  size -= fixed_size;
25
26
18
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
18
  auto buf = fmt::memory_buffer();
31
18
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
18
#endif
33
18
}
void invoke_fmt<int, long>(unsigned char const*, unsigned long)
Line
Count
Source
13
45
void invoke_fmt(const uint8_t* data, size_t size) {
14
45
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
45
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
45
  if (size <= fixed_size + fixed_size) return;
17
18
37
  const Item1 item1 = assign_from_buf<Item1>(data);
19
37
  data += fixed_size;
20
37
  size -= fixed_size;
21
22
37
  const Item2 item2 = assign_from_buf<Item2>(data);
23
37
  data += fixed_size;
24
37
  size -= fixed_size;
25
26
37
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
37
  auto buf = fmt::memory_buffer();
31
37
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
37
#endif
33
37
}
void invoke_fmt<int, unsigned long>(unsigned char const*, unsigned long)
Line
Count
Source
13
42
void invoke_fmt(const uint8_t* data, size_t size) {
14
42
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
42
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
42
  if (size <= fixed_size + fixed_size) return;
17
18
34
  const Item1 item1 = assign_from_buf<Item1>(data);
19
34
  data += fixed_size;
20
34
  size -= fixed_size;
21
22
34
  const Item2 item2 = assign_from_buf<Item2>(data);
23
34
  data += fixed_size;
24
34
  size -= fixed_size;
25
26
34
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
34
  auto buf = fmt::memory_buffer();
31
34
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
34
#endif
33
34
}
void invoke_fmt<int, float>(unsigned char const*, unsigned long)
Line
Count
Source
13
56
void invoke_fmt(const uint8_t* data, size_t size) {
14
56
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
56
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
56
  if (size <= fixed_size + fixed_size) return;
17
18
48
  const Item1 item1 = assign_from_buf<Item1>(data);
19
48
  data += fixed_size;
20
48
  size -= fixed_size;
21
22
48
  const Item2 item2 = assign_from_buf<Item2>(data);
23
48
  data += fixed_size;
24
48
  size -= fixed_size;
25
26
48
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
48
  auto buf = fmt::memory_buffer();
31
48
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
48
#endif
33
48
}
void invoke_fmt<int, double>(unsigned char const*, unsigned long)
Line
Count
Source
13
29
void invoke_fmt(const uint8_t* data, size_t size) {
14
29
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
29
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
29
  if (size <= fixed_size + fixed_size) return;
17
18
22
  const Item1 item1 = assign_from_buf<Item1>(data);
19
22
  data += fixed_size;
20
22
  size -= fixed_size;
21
22
22
  const Item2 item2 = assign_from_buf<Item2>(data);
23
22
  data += fixed_size;
24
22
  size -= fixed_size;
25
26
22
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
22
  auto buf = fmt::memory_buffer();
31
22
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
22
#endif
33
22
}
void invoke_fmt<int, long double>(unsigned char const*, unsigned long)
Line
Count
Source
13
32
void invoke_fmt(const uint8_t* data, size_t size) {
14
32
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
32
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
32
  if (size <= fixed_size + fixed_size) return;
17
18
24
  const Item1 item1 = assign_from_buf<Item1>(data);
19
24
  data += fixed_size;
20
24
  size -= fixed_size;
21
22
24
  const Item2 item2 = assign_from_buf<Item2>(data);
23
24
  data += fixed_size;
24
24
  size -= fixed_size;
25
26
24
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
24
  auto buf = fmt::memory_buffer();
31
24
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
24
#endif
33
24
}
void invoke_fmt<int, void*>(unsigned char const*, unsigned long)
Line
Count
Source
13
29
void invoke_fmt(const uint8_t* data, size_t size) {
14
29
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
29
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
29
  if (size <= fixed_size + fixed_size) return;
17
18
22
  const Item1 item1 = assign_from_buf<Item1>(data);
19
22
  data += fixed_size;
20
22
  size -= fixed_size;
21
22
22
  const Item2 item2 = assign_from_buf<Item2>(data);
23
22
  data += fixed_size;
24
22
  size -= fixed_size;
25
26
22
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
22
  auto buf = fmt::memory_buffer();
31
22
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
22
#endif
33
22
}
void invoke_fmt<unsigned int, bool>(unsigned char const*, unsigned long)
Line
Count
Source
13
55
void invoke_fmt(const uint8_t* data, size_t size) {
14
55
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
55
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
55
  if (size <= fixed_size + fixed_size) return;
17
18
47
  const Item1 item1 = assign_from_buf<Item1>(data);
19
47
  data += fixed_size;
20
47
  size -= fixed_size;
21
22
47
  const Item2 item2 = assign_from_buf<Item2>(data);
23
47
  data += fixed_size;
24
47
  size -= fixed_size;
25
26
47
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
47
  auto buf = fmt::memory_buffer();
31
47
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
47
#endif
33
47
}
void invoke_fmt<unsigned int, char>(unsigned char const*, unsigned long)
Line
Count
Source
13
27
void invoke_fmt(const uint8_t* data, size_t size) {
14
27
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
27
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
27
  if (size <= fixed_size + fixed_size) return;
17
18
19
  const Item1 item1 = assign_from_buf<Item1>(data);
19
19
  data += fixed_size;
20
19
  size -= fixed_size;
21
22
19
  const Item2 item2 = assign_from_buf<Item2>(data);
23
19
  data += fixed_size;
24
19
  size -= fixed_size;
25
26
19
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
19
  auto buf = fmt::memory_buffer();
31
19
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
19
#endif
33
19
}
void invoke_fmt<unsigned int, signed char>(unsigned char const*, unsigned long)
Line
Count
Source
13
44
void invoke_fmt(const uint8_t* data, size_t size) {
14
44
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
44
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
44
  if (size <= fixed_size + fixed_size) return;
17
18
36
  const Item1 item1 = assign_from_buf<Item1>(data);
19
36
  data += fixed_size;
20
36
  size -= fixed_size;
21
22
36
  const Item2 item2 = assign_from_buf<Item2>(data);
23
36
  data += fixed_size;
24
36
  size -= fixed_size;
25
26
36
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
36
  auto buf = fmt::memory_buffer();
31
36
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
36
#endif
33
36
}
void invoke_fmt<unsigned int, unsigned char>(unsigned char const*, unsigned long)
Line
Count
Source
13
25
void invoke_fmt(const uint8_t* data, size_t size) {
14
25
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
25
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
25
  if (size <= fixed_size + fixed_size) return;
17
18
17
  const Item1 item1 = assign_from_buf<Item1>(data);
19
17
  data += fixed_size;
20
17
  size -= fixed_size;
21
22
17
  const Item2 item2 = assign_from_buf<Item2>(data);
23
17
  data += fixed_size;
24
17
  size -= fixed_size;
25
26
17
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
17
  auto buf = fmt::memory_buffer();
31
17
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
17
#endif
33
17
}
void invoke_fmt<unsigned int, short>(unsigned char const*, unsigned long)
Line
Count
Source
13
28
void invoke_fmt(const uint8_t* data, size_t size) {
14
28
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
28
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
28
  if (size <= fixed_size + fixed_size) return;
17
18
21
  const Item1 item1 = assign_from_buf<Item1>(data);
19
21
  data += fixed_size;
20
21
  size -= fixed_size;
21
22
21
  const Item2 item2 = assign_from_buf<Item2>(data);
23
21
  data += fixed_size;
24
21
  size -= fixed_size;
25
26
21
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
21
  auto buf = fmt::memory_buffer();
31
21
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
21
#endif
33
21
}
void invoke_fmt<unsigned int, unsigned short>(unsigned char const*, unsigned long)
Line
Count
Source
13
53
void invoke_fmt(const uint8_t* data, size_t size) {
14
53
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
53
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
53
  if (size <= fixed_size + fixed_size) return;
17
18
45
  const Item1 item1 = assign_from_buf<Item1>(data);
19
45
  data += fixed_size;
20
45
  size -= fixed_size;
21
22
45
  const Item2 item2 = assign_from_buf<Item2>(data);
23
45
  data += fixed_size;
24
45
  size -= fixed_size;
25
26
45
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
45
  auto buf = fmt::memory_buffer();
31
45
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
45
#endif
33
45
}
void invoke_fmt<unsigned int, int>(unsigned char const*, unsigned long)
Line
Count
Source
13
40
void invoke_fmt(const uint8_t* data, size_t size) {
14
40
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
40
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
40
  if (size <= fixed_size + fixed_size) return;
17
18
32
  const Item1 item1 = assign_from_buf<Item1>(data);
19
32
  data += fixed_size;
20
32
  size -= fixed_size;
21
22
32
  const Item2 item2 = assign_from_buf<Item2>(data);
23
32
  data += fixed_size;
24
32
  size -= fixed_size;
25
26
32
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
32
  auto buf = fmt::memory_buffer();
31
32
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
32
#endif
33
32
}
void invoke_fmt<unsigned int, unsigned int>(unsigned char const*, unsigned long)
Line
Count
Source
13
61
void invoke_fmt(const uint8_t* data, size_t size) {
14
61
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
61
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
61
  if (size <= fixed_size + fixed_size) return;
17
18
53
  const Item1 item1 = assign_from_buf<Item1>(data);
19
53
  data += fixed_size;
20
53
  size -= fixed_size;
21
22
53
  const Item2 item2 = assign_from_buf<Item2>(data);
23
53
  data += fixed_size;
24
53
  size -= fixed_size;
25
26
53
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
53
  auto buf = fmt::memory_buffer();
31
53
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
53
#endif
33
53
}
void invoke_fmt<unsigned int, long>(unsigned char const*, unsigned long)
Line
Count
Source
13
69
void invoke_fmt(const uint8_t* data, size_t size) {
14
69
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
69
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
69
  if (size <= fixed_size + fixed_size) return;
17
18
62
  const Item1 item1 = assign_from_buf<Item1>(data);
19
62
  data += fixed_size;
20
62
  size -= fixed_size;
21
22
62
  const Item2 item2 = assign_from_buf<Item2>(data);
23
62
  data += fixed_size;
24
62
  size -= fixed_size;
25
26
62
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
62
  auto buf = fmt::memory_buffer();
31
62
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
62
#endif
33
62
}
void invoke_fmt<unsigned int, unsigned long>(unsigned char const*, unsigned long)
Line
Count
Source
13
37
void invoke_fmt(const uint8_t* data, size_t size) {
14
37
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
37
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
37
  if (size <= fixed_size + fixed_size) return;
17
18
30
  const Item1 item1 = assign_from_buf<Item1>(data);
19
30
  data += fixed_size;
20
30
  size -= fixed_size;
21
22
30
  const Item2 item2 = assign_from_buf<Item2>(data);
23
30
  data += fixed_size;
24
30
  size -= fixed_size;
25
26
30
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
30
  auto buf = fmt::memory_buffer();
31
30
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
30
#endif
33
30
}
void invoke_fmt<unsigned int, float>(unsigned char const*, unsigned long)
Line
Count
Source
13
48
void invoke_fmt(const uint8_t* data, size_t size) {
14
48
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
48
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
48
  if (size <= fixed_size + fixed_size) return;
17
18
41
  const Item1 item1 = assign_from_buf<Item1>(data);
19
41
  data += fixed_size;
20
41
  size -= fixed_size;
21
22
41
  const Item2 item2 = assign_from_buf<Item2>(data);
23
41
  data += fixed_size;
24
41
  size -= fixed_size;
25
26
41
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
41
  auto buf = fmt::memory_buffer();
31
41
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
41
#endif
33
41
}
void invoke_fmt<unsigned int, double>(unsigned char const*, unsigned long)
Line
Count
Source
13
51
void invoke_fmt(const uint8_t* data, size_t size) {
14
51
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
51
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
51
  if (size <= fixed_size + fixed_size) return;
17
18
43
  const Item1 item1 = assign_from_buf<Item1>(data);
19
43
  data += fixed_size;
20
43
  size -= fixed_size;
21
22
43
  const Item2 item2 = assign_from_buf<Item2>(data);
23
43
  data += fixed_size;
24
43
  size -= fixed_size;
25
26
43
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
43
  auto buf = fmt::memory_buffer();
31
43
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
43
#endif
33
43
}
void invoke_fmt<unsigned int, long double>(unsigned char const*, unsigned long)
Line
Count
Source
13
37
void invoke_fmt(const uint8_t* data, size_t size) {
14
37
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
37
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
37
  if (size <= fixed_size + fixed_size) return;
17
18
29
  const Item1 item1 = assign_from_buf<Item1>(data);
19
29
  data += fixed_size;
20
29
  size -= fixed_size;
21
22
29
  const Item2 item2 = assign_from_buf<Item2>(data);
23
29
  data += fixed_size;
24
29
  size -= fixed_size;
25
26
29
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
29
  auto buf = fmt::memory_buffer();
31
29
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
29
#endif
33
29
}
void invoke_fmt<unsigned int, void*>(unsigned char const*, unsigned long)
Line
Count
Source
13
33
void invoke_fmt(const uint8_t* data, size_t size) {
14
33
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
33
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
33
  if (size <= fixed_size + fixed_size) return;
17
18
25
  const Item1 item1 = assign_from_buf<Item1>(data);
19
25
  data += fixed_size;
20
25
  size -= fixed_size;
21
22
25
  const Item2 item2 = assign_from_buf<Item2>(data);
23
25
  data += fixed_size;
24
25
  size -= fixed_size;
25
26
25
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
25
  auto buf = fmt::memory_buffer();
31
25
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
25
#endif
33
25
}
void invoke_fmt<long, bool>(unsigned char const*, unsigned long)
Line
Count
Source
13
40
void invoke_fmt(const uint8_t* data, size_t size) {
14
40
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
40
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
40
  if (size <= fixed_size + fixed_size) return;
17
18
32
  const Item1 item1 = assign_from_buf<Item1>(data);
19
32
  data += fixed_size;
20
32
  size -= fixed_size;
21
22
32
  const Item2 item2 = assign_from_buf<Item2>(data);
23
32
  data += fixed_size;
24
32
  size -= fixed_size;
25
26
32
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
32
  auto buf = fmt::memory_buffer();
31
32
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
32
#endif
33
32
}
void invoke_fmt<long, char>(unsigned char const*, unsigned long)
Line
Count
Source
13
85
void invoke_fmt(const uint8_t* data, size_t size) {
14
85
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
85
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
85
  if (size <= fixed_size + fixed_size) return;
17
18
77
  const Item1 item1 = assign_from_buf<Item1>(data);
19
77
  data += fixed_size;
20
77
  size -= fixed_size;
21
22
77
  const Item2 item2 = assign_from_buf<Item2>(data);
23
77
  data += fixed_size;
24
77
  size -= fixed_size;
25
26
77
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
77
  auto buf = fmt::memory_buffer();
31
77
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
77
#endif
33
77
}
void invoke_fmt<long, signed char>(unsigned char const*, unsigned long)
Line
Count
Source
13
101
void invoke_fmt(const uint8_t* data, size_t size) {
14
101
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
101
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
101
  if (size <= fixed_size + fixed_size) return;
17
18
94
  const Item1 item1 = assign_from_buf<Item1>(data);
19
94
  data += fixed_size;
20
94
  size -= fixed_size;
21
22
94
  const Item2 item2 = assign_from_buf<Item2>(data);
23
94
  data += fixed_size;
24
94
  size -= fixed_size;
25
26
94
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
94
  auto buf = fmt::memory_buffer();
31
94
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
94
#endif
33
94
}
void invoke_fmt<long, unsigned char>(unsigned char const*, unsigned long)
Line
Count
Source
13
39
void invoke_fmt(const uint8_t* data, size_t size) {
14
39
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
39
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
39
  if (size <= fixed_size + fixed_size) return;
17
18
31
  const Item1 item1 = assign_from_buf<Item1>(data);
19
31
  data += fixed_size;
20
31
  size -= fixed_size;
21
22
31
  const Item2 item2 = assign_from_buf<Item2>(data);
23
31
  data += fixed_size;
24
31
  size -= fixed_size;
25
26
31
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
31
  auto buf = fmt::memory_buffer();
31
31
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
31
#endif
33
31
}
void invoke_fmt<long, short>(unsigned char const*, unsigned long)
Line
Count
Source
13
44
void invoke_fmt(const uint8_t* data, size_t size) {
14
44
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
44
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
44
  if (size <= fixed_size + fixed_size) return;
17
18
38
  const Item1 item1 = assign_from_buf<Item1>(data);
19
38
  data += fixed_size;
20
38
  size -= fixed_size;
21
22
38
  const Item2 item2 = assign_from_buf<Item2>(data);
23
38
  data += fixed_size;
24
38
  size -= fixed_size;
25
26
38
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
38
  auto buf = fmt::memory_buffer();
31
38
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
38
#endif
33
38
}
void invoke_fmt<long, unsigned short>(unsigned char const*, unsigned long)
Line
Count
Source
13
54
void invoke_fmt(const uint8_t* data, size_t size) {
14
54
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
54
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
54
  if (size <= fixed_size + fixed_size) return;
17
18
46
  const Item1 item1 = assign_from_buf<Item1>(data);
19
46
  data += fixed_size;
20
46
  size -= fixed_size;
21
22
46
  const Item2 item2 = assign_from_buf<Item2>(data);
23
46
  data += fixed_size;
24
46
  size -= fixed_size;
25
26
46
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
46
  auto buf = fmt::memory_buffer();
31
46
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
46
#endif
33
46
}
void invoke_fmt<long, int>(unsigned char const*, unsigned long)
Line
Count
Source
13
69
void invoke_fmt(const uint8_t* data, size_t size) {
14
69
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
69
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
69
  if (size <= fixed_size + fixed_size) return;
17
18
62
  const Item1 item1 = assign_from_buf<Item1>(data);
19
62
  data += fixed_size;
20
62
  size -= fixed_size;
21
22
62
  const Item2 item2 = assign_from_buf<Item2>(data);
23
62
  data += fixed_size;
24
62
  size -= fixed_size;
25
26
62
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
62
  auto buf = fmt::memory_buffer();
31
62
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
62
#endif
33
62
}
void invoke_fmt<long, unsigned int>(unsigned char const*, unsigned long)
Line
Count
Source
13
102
void invoke_fmt(const uint8_t* data, size_t size) {
14
102
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
102
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
102
  if (size <= fixed_size + fixed_size) return;
17
18
95
  const Item1 item1 = assign_from_buf<Item1>(data);
19
95
  data += fixed_size;
20
95
  size -= fixed_size;
21
22
95
  const Item2 item2 = assign_from_buf<Item2>(data);
23
95
  data += fixed_size;
24
95
  size -= fixed_size;
25
26
95
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
95
  auto buf = fmt::memory_buffer();
31
95
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
95
#endif
33
95
}
void invoke_fmt<long, long>(unsigned char const*, unsigned long)
Line
Count
Source
13
77
void invoke_fmt(const uint8_t* data, size_t size) {
14
77
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
77
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
77
  if (size <= fixed_size + fixed_size) return;
17
18
69
  const Item1 item1 = assign_from_buf<Item1>(data);
19
69
  data += fixed_size;
20
69
  size -= fixed_size;
21
22
69
  const Item2 item2 = assign_from_buf<Item2>(data);
23
69
  data += fixed_size;
24
69
  size -= fixed_size;
25
26
69
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
69
  auto buf = fmt::memory_buffer();
31
69
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
69
#endif
33
69
}
void invoke_fmt<long, unsigned long>(unsigned char const*, unsigned long)
Line
Count
Source
13
56
void invoke_fmt(const uint8_t* data, size_t size) {
14
56
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
56
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
56
  if (size <= fixed_size + fixed_size) return;
17
18
48
  const Item1 item1 = assign_from_buf<Item1>(data);
19
48
  data += fixed_size;
20
48
  size -= fixed_size;
21
22
48
  const Item2 item2 = assign_from_buf<Item2>(data);
23
48
  data += fixed_size;
24
48
  size -= fixed_size;
25
26
48
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
48
  auto buf = fmt::memory_buffer();
31
48
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
48
#endif
33
48
}
void invoke_fmt<long, float>(unsigned char const*, unsigned long)
Line
Count
Source
13
64
void invoke_fmt(const uint8_t* data, size_t size) {
14
64
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
64
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
64
  if (size <= fixed_size + fixed_size) return;
17
18
56
  const Item1 item1 = assign_from_buf<Item1>(data);
19
56
  data += fixed_size;
20
56
  size -= fixed_size;
21
22
56
  const Item2 item2 = assign_from_buf<Item2>(data);
23
56
  data += fixed_size;
24
56
  size -= fixed_size;
25
26
56
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
56
  auto buf = fmt::memory_buffer();
31
56
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
56
#endif
33
56
}
void invoke_fmt<long, double>(unsigned char const*, unsigned long)
Line
Count
Source
13
52
void invoke_fmt(const uint8_t* data, size_t size) {
14
52
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
52
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
52
  if (size <= fixed_size + fixed_size) return;
17
18
45
  const Item1 item1 = assign_from_buf<Item1>(data);
19
45
  data += fixed_size;
20
45
  size -= fixed_size;
21
22
45
  const Item2 item2 = assign_from_buf<Item2>(data);
23
45
  data += fixed_size;
24
45
  size -= fixed_size;
25
26
45
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
45
  auto buf = fmt::memory_buffer();
31
45
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
45
#endif
33
45
}
void invoke_fmt<long, long double>(unsigned char const*, unsigned long)
Line
Count
Source
13
50
void invoke_fmt(const uint8_t* data, size_t size) {
14
50
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
50
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
50
  if (size <= fixed_size + fixed_size) return;
17
18
42
  const Item1 item1 = assign_from_buf<Item1>(data);
19
42
  data += fixed_size;
20
42
  size -= fixed_size;
21
22
42
  const Item2 item2 = assign_from_buf<Item2>(data);
23
42
  data += fixed_size;
24
42
  size -= fixed_size;
25
26
42
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
42
  auto buf = fmt::memory_buffer();
31
42
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
42
#endif
33
42
}
void invoke_fmt<long, void*>(unsigned char const*, unsigned long)
Line
Count
Source
13
52
void invoke_fmt(const uint8_t* data, size_t size) {
14
52
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
52
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
52
  if (size <= fixed_size + fixed_size) return;
17
18
44
  const Item1 item1 = assign_from_buf<Item1>(data);
19
44
  data += fixed_size;
20
44
  size -= fixed_size;
21
22
44
  const Item2 item2 = assign_from_buf<Item2>(data);
23
44
  data += fixed_size;
24
44
  size -= fixed_size;
25
26
44
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
44
  auto buf = fmt::memory_buffer();
31
44
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
44
#endif
33
44
}
void invoke_fmt<unsigned long, bool>(unsigned char const*, unsigned long)
Line
Count
Source
13
66
void invoke_fmt(const uint8_t* data, size_t size) {
14
66
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
66
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
66
  if (size <= fixed_size + fixed_size) return;
17
18
58
  const Item1 item1 = assign_from_buf<Item1>(data);
19
58
  data += fixed_size;
20
58
  size -= fixed_size;
21
22
58
  const Item2 item2 = assign_from_buf<Item2>(data);
23
58
  data += fixed_size;
24
58
  size -= fixed_size;
25
26
58
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
58
  auto buf = fmt::memory_buffer();
31
58
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
58
#endif
33
58
}
void invoke_fmt<unsigned long, char>(unsigned char const*, unsigned long)
Line
Count
Source
13
38
void invoke_fmt(const uint8_t* data, size_t size) {
14
38
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
38
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
38
  if (size <= fixed_size + fixed_size) return;
17
18
31
  const Item1 item1 = assign_from_buf<Item1>(data);
19
31
  data += fixed_size;
20
31
  size -= fixed_size;
21
22
31
  const Item2 item2 = assign_from_buf<Item2>(data);
23
31
  data += fixed_size;
24
31
  size -= fixed_size;
25
26
31
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
31
  auto buf = fmt::memory_buffer();
31
31
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
31
#endif
33
31
}
void invoke_fmt<unsigned long, signed char>(unsigned char const*, unsigned long)
Line
Count
Source
13
69
void invoke_fmt(const uint8_t* data, size_t size) {
14
69
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
69
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
69
  if (size <= fixed_size + fixed_size) return;
17
18
61
  const Item1 item1 = assign_from_buf<Item1>(data);
19
61
  data += fixed_size;
20
61
  size -= fixed_size;
21
22
61
  const Item2 item2 = assign_from_buf<Item2>(data);
23
61
  data += fixed_size;
24
61
  size -= fixed_size;
25
26
61
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
61
  auto buf = fmt::memory_buffer();
31
61
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
61
#endif
33
61
}
void invoke_fmt<unsigned long, unsigned char>(unsigned char const*, unsigned long)
Line
Count
Source
13
35
void invoke_fmt(const uint8_t* data, size_t size) {
14
35
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
35
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
35
  if (size <= fixed_size + fixed_size) return;
17
18
27
  const Item1 item1 = assign_from_buf<Item1>(data);
19
27
  data += fixed_size;
20
27
  size -= fixed_size;
21
22
27
  const Item2 item2 = assign_from_buf<Item2>(data);
23
27
  data += fixed_size;
24
27
  size -= fixed_size;
25
26
27
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
27
  auto buf = fmt::memory_buffer();
31
27
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
27
#endif
33
27
}
void invoke_fmt<unsigned long, short>(unsigned char const*, unsigned long)
Line
Count
Source
13
54
void invoke_fmt(const uint8_t* data, size_t size) {
14
54
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
54
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
54
  if (size <= fixed_size + fixed_size) return;
17
18
47
  const Item1 item1 = assign_from_buf<Item1>(data);
19
47
  data += fixed_size;
20
47
  size -= fixed_size;
21
22
47
  const Item2 item2 = assign_from_buf<Item2>(data);
23
47
  data += fixed_size;
24
47
  size -= fixed_size;
25
26
47
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
47
  auto buf = fmt::memory_buffer();
31
47
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
47
#endif
33
47
}
void invoke_fmt<unsigned long, unsigned short>(unsigned char const*, unsigned long)
Line
Count
Source
13
73
void invoke_fmt(const uint8_t* data, size_t size) {
14
73
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
73
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
73
  if (size <= fixed_size + fixed_size) return;
17
18
65
  const Item1 item1 = assign_from_buf<Item1>(data);
19
65
  data += fixed_size;
20
65
  size -= fixed_size;
21
22
65
  const Item2 item2 = assign_from_buf<Item2>(data);
23
65
  data += fixed_size;
24
65
  size -= fixed_size;
25
26
65
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
65
  auto buf = fmt::memory_buffer();
31
65
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
65
#endif
33
65
}
void invoke_fmt<unsigned long, int>(unsigned char const*, unsigned long)
Line
Count
Source
13
67
void invoke_fmt(const uint8_t* data, size_t size) {
14
67
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
67
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
67
  if (size <= fixed_size + fixed_size) return;
17
18
59
  const Item1 item1 = assign_from_buf<Item1>(data);
19
59
  data += fixed_size;
20
59
  size -= fixed_size;
21
22
59
  const Item2 item2 = assign_from_buf<Item2>(data);
23
59
  data += fixed_size;
24
59
  size -= fixed_size;
25
26
59
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
59
  auto buf = fmt::memory_buffer();
31
59
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
59
#endif
33
59
}
void invoke_fmt<unsigned long, unsigned int>(unsigned char const*, unsigned long)
Line
Count
Source
13
79
void invoke_fmt(const uint8_t* data, size_t size) {
14
79
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
79
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
79
  if (size <= fixed_size + fixed_size) return;
17
18
71
  const Item1 item1 = assign_from_buf<Item1>(data);
19
71
  data += fixed_size;
20
71
  size -= fixed_size;
21
22
71
  const Item2 item2 = assign_from_buf<Item2>(data);
23
71
  data += fixed_size;
24
71
  size -= fixed_size;
25
26
71
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
71
  auto buf = fmt::memory_buffer();
31
71
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
71
#endif
33
71
}
void invoke_fmt<unsigned long, long>(unsigned char const*, unsigned long)
Line
Count
Source
13
61
void invoke_fmt(const uint8_t* data, size_t size) {
14
61
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
61
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
61
  if (size <= fixed_size + fixed_size) return;
17
18
53
  const Item1 item1 = assign_from_buf<Item1>(data);
19
53
  data += fixed_size;
20
53
  size -= fixed_size;
21
22
53
  const Item2 item2 = assign_from_buf<Item2>(data);
23
53
  data += fixed_size;
24
53
  size -= fixed_size;
25
26
53
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
53
  auto buf = fmt::memory_buffer();
31
53
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
53
#endif
33
53
}
void invoke_fmt<unsigned long, unsigned long>(unsigned char const*, unsigned long)
Line
Count
Source
13
65
void invoke_fmt(const uint8_t* data, size_t size) {
14
65
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
65
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
65
  if (size <= fixed_size + fixed_size) return;
17
18
57
  const Item1 item1 = assign_from_buf<Item1>(data);
19
57
  data += fixed_size;
20
57
  size -= fixed_size;
21
22
57
  const Item2 item2 = assign_from_buf<Item2>(data);
23
57
  data += fixed_size;
24
57
  size -= fixed_size;
25
26
57
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
57
  auto buf = fmt::memory_buffer();
31
57
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
57
#endif
33
57
}
void invoke_fmt<unsigned long, float>(unsigned char const*, unsigned long)
Line
Count
Source
13
53
void invoke_fmt(const uint8_t* data, size_t size) {
14
53
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
53
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
53
  if (size <= fixed_size + fixed_size) return;
17
18
45
  const Item1 item1 = assign_from_buf<Item1>(data);
19
45
  data += fixed_size;
20
45
  size -= fixed_size;
21
22
45
  const Item2 item2 = assign_from_buf<Item2>(data);
23
45
  data += fixed_size;
24
45
  size -= fixed_size;
25
26
45
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
45
  auto buf = fmt::memory_buffer();
31
45
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
45
#endif
33
45
}
void invoke_fmt<unsigned long, double>(unsigned char const*, unsigned long)
Line
Count
Source
13
34
void invoke_fmt(const uint8_t* data, size_t size) {
14
34
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
34
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
34
  if (size <= fixed_size + fixed_size) return;
17
18
26
  const Item1 item1 = assign_from_buf<Item1>(data);
19
26
  data += fixed_size;
20
26
  size -= fixed_size;
21
22
26
  const Item2 item2 = assign_from_buf<Item2>(data);
23
26
  data += fixed_size;
24
26
  size -= fixed_size;
25
26
26
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
26
  auto buf = fmt::memory_buffer();
31
26
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
26
#endif
33
26
}
void invoke_fmt<unsigned long, long double>(unsigned char const*, unsigned long)
Line
Count
Source
13
40
void invoke_fmt(const uint8_t* data, size_t size) {
14
40
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
40
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
40
  if (size <= fixed_size + fixed_size) return;
17
18
32
  const Item1 item1 = assign_from_buf<Item1>(data);
19
32
  data += fixed_size;
20
32
  size -= fixed_size;
21
22
32
  const Item2 item2 = assign_from_buf<Item2>(data);
23
32
  data += fixed_size;
24
32
  size -= fixed_size;
25
26
32
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
32
  auto buf = fmt::memory_buffer();
31
32
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
32
#endif
33
32
}
void invoke_fmt<unsigned long, void*>(unsigned char const*, unsigned long)
Line
Count
Source
13
65
void invoke_fmt(const uint8_t* data, size_t size) {
14
65
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
65
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
65
  if (size <= fixed_size + fixed_size) return;
17
18
57
  const Item1 item1 = assign_from_buf<Item1>(data);
19
57
  data += fixed_size;
20
57
  size -= fixed_size;
21
22
57
  const Item2 item2 = assign_from_buf<Item2>(data);
23
57
  data += fixed_size;
24
57
  size -= fixed_size;
25
26
57
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
57
  auto buf = fmt::memory_buffer();
31
57
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
57
#endif
33
57
}
void invoke_fmt<float, bool>(unsigned char const*, unsigned long)
Line
Count
Source
13
89
void invoke_fmt(const uint8_t* data, size_t size) {
14
89
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
89
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
89
  if (size <= fixed_size + fixed_size) return;
17
18
81
  const Item1 item1 = assign_from_buf<Item1>(data);
19
81
  data += fixed_size;
20
81
  size -= fixed_size;
21
22
81
  const Item2 item2 = assign_from_buf<Item2>(data);
23
81
  data += fixed_size;
24
81
  size -= fixed_size;
25
26
81
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
81
  auto buf = fmt::memory_buffer();
31
81
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
81
#endif
33
81
}
void invoke_fmt<float, char>(unsigned char const*, unsigned long)
Line
Count
Source
13
40
void invoke_fmt(const uint8_t* data, size_t size) {
14
40
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
40
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
40
  if (size <= fixed_size + fixed_size) return;
17
18
33
  const Item1 item1 = assign_from_buf<Item1>(data);
19
33
  data += fixed_size;
20
33
  size -= fixed_size;
21
22
33
  const Item2 item2 = assign_from_buf<Item2>(data);
23
33
  data += fixed_size;
24
33
  size -= fixed_size;
25
26
33
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
33
  auto buf = fmt::memory_buffer();
31
33
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
33
#endif
33
33
}
void invoke_fmt<float, signed char>(unsigned char const*, unsigned long)
Line
Count
Source
13
94
void invoke_fmt(const uint8_t* data, size_t size) {
14
94
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
94
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
94
  if (size <= fixed_size + fixed_size) return;
17
18
86
  const Item1 item1 = assign_from_buf<Item1>(data);
19
86
  data += fixed_size;
20
86
  size -= fixed_size;
21
22
86
  const Item2 item2 = assign_from_buf<Item2>(data);
23
86
  data += fixed_size;
24
86
  size -= fixed_size;
25
26
86
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
86
  auto buf = fmt::memory_buffer();
31
86
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
86
#endif
33
86
}
void invoke_fmt<float, unsigned char>(unsigned char const*, unsigned long)
Line
Count
Source
13
116
void invoke_fmt(const uint8_t* data, size_t size) {
14
116
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
116
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
116
  if (size <= fixed_size + fixed_size) return;
17
18
109
  const Item1 item1 = assign_from_buf<Item1>(data);
19
109
  data += fixed_size;
20
109
  size -= fixed_size;
21
22
109
  const Item2 item2 = assign_from_buf<Item2>(data);
23
109
  data += fixed_size;
24
109
  size -= fixed_size;
25
26
109
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
109
  auto buf = fmt::memory_buffer();
31
109
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
109
#endif
33
109
}
void invoke_fmt<float, short>(unsigned char const*, unsigned long)
Line
Count
Source
13
99
void invoke_fmt(const uint8_t* data, size_t size) {
14
99
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
99
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
99
  if (size <= fixed_size + fixed_size) return;
17
18
91
  const Item1 item1 = assign_from_buf<Item1>(data);
19
91
  data += fixed_size;
20
91
  size -= fixed_size;
21
22
91
  const Item2 item2 = assign_from_buf<Item2>(data);
23
91
  data += fixed_size;
24
91
  size -= fixed_size;
25
26
91
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
91
  auto buf = fmt::memory_buffer();
31
91
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
91
#endif
33
91
}
void invoke_fmt<float, unsigned short>(unsigned char const*, unsigned long)
Line
Count
Source
13
145
void invoke_fmt(const uint8_t* data, size_t size) {
14
145
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
145
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
145
  if (size <= fixed_size + fixed_size) return;
17
18
137
  const Item1 item1 = assign_from_buf<Item1>(data);
19
137
  data += fixed_size;
20
137
  size -= fixed_size;
21
22
137
  const Item2 item2 = assign_from_buf<Item2>(data);
23
137
  data += fixed_size;
24
137
  size -= fixed_size;
25
26
137
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
137
  auto buf = fmt::memory_buffer();
31
137
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
137
#endif
33
137
}
void invoke_fmt<float, int>(unsigned char const*, unsigned long)
Line
Count
Source
13
272
void invoke_fmt(const uint8_t* data, size_t size) {
14
272
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
272
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
272
  if (size <= fixed_size + fixed_size) return;
17
18
264
  const Item1 item1 = assign_from_buf<Item1>(data);
19
264
  data += fixed_size;
20
264
  size -= fixed_size;
21
22
264
  const Item2 item2 = assign_from_buf<Item2>(data);
23
264
  data += fixed_size;
24
264
  size -= fixed_size;
25
26
264
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
264
  auto buf = fmt::memory_buffer();
31
264
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
264
#endif
33
264
}
void invoke_fmt<float, unsigned int>(unsigned char const*, unsigned long)
Line
Count
Source
13
434
void invoke_fmt(const uint8_t* data, size_t size) {
14
434
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
434
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
434
  if (size <= fixed_size + fixed_size) return;
17
18
426
  const Item1 item1 = assign_from_buf<Item1>(data);
19
426
  data += fixed_size;
20
426
  size -= fixed_size;
21
22
426
  const Item2 item2 = assign_from_buf<Item2>(data);
23
426
  data += fixed_size;
24
426
  size -= fixed_size;
25
26
426
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
426
  auto buf = fmt::memory_buffer();
31
426
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
426
#endif
33
426
}
void invoke_fmt<float, long>(unsigned char const*, unsigned long)
Line
Count
Source
13
65
void invoke_fmt(const uint8_t* data, size_t size) {
14
65
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
65
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
65
  if (size <= fixed_size + fixed_size) return;
17
18
57
  const Item1 item1 = assign_from_buf<Item1>(data);
19
57
  data += fixed_size;
20
57
  size -= fixed_size;
21
22
57
  const Item2 item2 = assign_from_buf<Item2>(data);
23
57
  data += fixed_size;
24
57
  size -= fixed_size;
25
26
57
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
57
  auto buf = fmt::memory_buffer();
31
57
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
57
#endif
33
57
}
void invoke_fmt<float, unsigned long>(unsigned char const*, unsigned long)
Line
Count
Source
13
105
void invoke_fmt(const uint8_t* data, size_t size) {
14
105
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
105
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
105
  if (size <= fixed_size + fixed_size) return;
17
18
97
  const Item1 item1 = assign_from_buf<Item1>(data);
19
97
  data += fixed_size;
20
97
  size -= fixed_size;
21
22
97
  const Item2 item2 = assign_from_buf<Item2>(data);
23
97
  data += fixed_size;
24
97
  size -= fixed_size;
25
26
97
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
97
  auto buf = fmt::memory_buffer();
31
97
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
97
#endif
33
97
}
void invoke_fmt<float, float>(unsigned char const*, unsigned long)
Line
Count
Source
13
165
void invoke_fmt(const uint8_t* data, size_t size) {
14
165
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
165
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
165
  if (size <= fixed_size + fixed_size) return;
17
18
157
  const Item1 item1 = assign_from_buf<Item1>(data);
19
157
  data += fixed_size;
20
157
  size -= fixed_size;
21
22
157
  const Item2 item2 = assign_from_buf<Item2>(data);
23
157
  data += fixed_size;
24
157
  size -= fixed_size;
25
26
157
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
157
  auto buf = fmt::memory_buffer();
31
157
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
157
#endif
33
157
}
void invoke_fmt<float, double>(unsigned char const*, unsigned long)
Line
Count
Source
13
69
void invoke_fmt(const uint8_t* data, size_t size) {
14
69
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
69
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
69
  if (size <= fixed_size + fixed_size) return;
17
18
62
  const Item1 item1 = assign_from_buf<Item1>(data);
19
62
  data += fixed_size;
20
62
  size -= fixed_size;
21
22
62
  const Item2 item2 = assign_from_buf<Item2>(data);
23
62
  data += fixed_size;
24
62
  size -= fixed_size;
25
26
62
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
62
  auto buf = fmt::memory_buffer();
31
62
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
62
#endif
33
62
}
void invoke_fmt<float, long double>(unsigned char const*, unsigned long)
Line
Count
Source
13
52
void invoke_fmt(const uint8_t* data, size_t size) {
14
52
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
52
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
52
  if (size <= fixed_size + fixed_size) return;
17
18
44
  const Item1 item1 = assign_from_buf<Item1>(data);
19
44
  data += fixed_size;
20
44
  size -= fixed_size;
21
22
44
  const Item2 item2 = assign_from_buf<Item2>(data);
23
44
  data += fixed_size;
24
44
  size -= fixed_size;
25
26
44
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
44
  auto buf = fmt::memory_buffer();
31
44
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
44
#endif
33
44
}
void invoke_fmt<float, void*>(unsigned char const*, unsigned long)
Line
Count
Source
13
21
void invoke_fmt(const uint8_t* data, size_t size) {
14
21
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
21
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
21
  if (size <= fixed_size + fixed_size) return;
17
18
17
  const Item1 item1 = assign_from_buf<Item1>(data);
19
17
  data += fixed_size;
20
17
  size -= fixed_size;
21
22
17
  const Item2 item2 = assign_from_buf<Item2>(data);
23
17
  data += fixed_size;
24
17
  size -= fixed_size;
25
26
17
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
17
  auto buf = fmt::memory_buffer();
31
17
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
17
#endif
33
17
}
void invoke_fmt<double, bool>(unsigned char const*, unsigned long)
Line
Count
Source
13
125
void invoke_fmt(const uint8_t* data, size_t size) {
14
125
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
125
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
125
  if (size <= fixed_size + fixed_size) return;
17
18
118
  const Item1 item1 = assign_from_buf<Item1>(data);
19
118
  data += fixed_size;
20
118
  size -= fixed_size;
21
22
118
  const Item2 item2 = assign_from_buf<Item2>(data);
23
118
  data += fixed_size;
24
118
  size -= fixed_size;
25
26
118
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
118
  auto buf = fmt::memory_buffer();
31
118
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
118
#endif
33
118
}
void invoke_fmt<double, char>(unsigned char const*, unsigned long)
Line
Count
Source
13
99
void invoke_fmt(const uint8_t* data, size_t size) {
14
99
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
99
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
99
  if (size <= fixed_size + fixed_size) return;
17
18
91
  const Item1 item1 = assign_from_buf<Item1>(data);
19
91
  data += fixed_size;
20
91
  size -= fixed_size;
21
22
91
  const Item2 item2 = assign_from_buf<Item2>(data);
23
91
  data += fixed_size;
24
91
  size -= fixed_size;
25
26
91
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
91
  auto buf = fmt::memory_buffer();
31
91
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
91
#endif
33
91
}
void invoke_fmt<double, signed char>(unsigned char const*, unsigned long)
Line
Count
Source
13
212
void invoke_fmt(const uint8_t* data, size_t size) {
14
212
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
212
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
212
  if (size <= fixed_size + fixed_size) return;
17
18
204
  const Item1 item1 = assign_from_buf<Item1>(data);
19
204
  data += fixed_size;
20
204
  size -= fixed_size;
21
22
204
  const Item2 item2 = assign_from_buf<Item2>(data);
23
204
  data += fixed_size;
24
204
  size -= fixed_size;
25
26
204
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
204
  auto buf = fmt::memory_buffer();
31
204
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
204
#endif
33
204
}
void invoke_fmt<double, unsigned char>(unsigned char const*, unsigned long)
Line
Count
Source
13
165
void invoke_fmt(const uint8_t* data, size_t size) {
14
165
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
165
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
165
  if (size <= fixed_size + fixed_size) return;
17
18
159
  const Item1 item1 = assign_from_buf<Item1>(data);
19
159
  data += fixed_size;
20
159
  size -= fixed_size;
21
22
159
  const Item2 item2 = assign_from_buf<Item2>(data);
23
159
  data += fixed_size;
24
159
  size -= fixed_size;
25
26
159
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
159
  auto buf = fmt::memory_buffer();
31
159
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
159
#endif
33
159
}
void invoke_fmt<double, short>(unsigned char const*, unsigned long)
Line
Count
Source
13
123
void invoke_fmt(const uint8_t* data, size_t size) {
14
123
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
123
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
123
  if (size <= fixed_size + fixed_size) return;
17
18
115
  const Item1 item1 = assign_from_buf<Item1>(data);
19
115
  data += fixed_size;
20
115
  size -= fixed_size;
21
22
115
  const Item2 item2 = assign_from_buf<Item2>(data);
23
115
  data += fixed_size;
24
115
  size -= fixed_size;
25
26
115
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
115
  auto buf = fmt::memory_buffer();
31
115
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
115
#endif
33
115
}
void invoke_fmt<double, unsigned short>(unsigned char const*, unsigned long)
Line
Count
Source
13
257
void invoke_fmt(const uint8_t* data, size_t size) {
14
257
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
257
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
257
  if (size <= fixed_size + fixed_size) return;
17
18
249
  const Item1 item1 = assign_from_buf<Item1>(data);
19
249
  data += fixed_size;
20
249
  size -= fixed_size;
21
22
249
  const Item2 item2 = assign_from_buf<Item2>(data);
23
249
  data += fixed_size;
24
249
  size -= fixed_size;
25
26
249
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
249
  auto buf = fmt::memory_buffer();
31
249
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
249
#endif
33
249
}
void invoke_fmt<double, int>(unsigned char const*, unsigned long)
Line
Count
Source
13
458
void invoke_fmt(const uint8_t* data, size_t size) {
14
458
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
458
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
458
  if (size <= fixed_size + fixed_size) return;
17
18
450
  const Item1 item1 = assign_from_buf<Item1>(data);
19
450
  data += fixed_size;
20
450
  size -= fixed_size;
21
22
450
  const Item2 item2 = assign_from_buf<Item2>(data);
23
450
  data += fixed_size;
24
450
  size -= fixed_size;
25
26
450
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
450
  auto buf = fmt::memory_buffer();
31
450
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
450
#endif
33
450
}
void invoke_fmt<double, unsigned int>(unsigned char const*, unsigned long)
Line
Count
Source
13
644
void invoke_fmt(const uint8_t* data, size_t size) {
14
644
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
644
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
644
  if (size <= fixed_size + fixed_size) return;
17
18
636
  const Item1 item1 = assign_from_buf<Item1>(data);
19
636
  data += fixed_size;
20
636
  size -= fixed_size;
21
22
636
  const Item2 item2 = assign_from_buf<Item2>(data);
23
636
  data += fixed_size;
24
636
  size -= fixed_size;
25
26
636
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
636
  auto buf = fmt::memory_buffer();
31
636
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
636
#endif
33
636
}
void invoke_fmt<double, long>(unsigned char const*, unsigned long)
Line
Count
Source
13
168
void invoke_fmt(const uint8_t* data, size_t size) {
14
168
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
168
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
168
  if (size <= fixed_size + fixed_size) return;
17
18
160
  const Item1 item1 = assign_from_buf<Item1>(data);
19
160
  data += fixed_size;
20
160
  size -= fixed_size;
21
22
160
  const Item2 item2 = assign_from_buf<Item2>(data);
23
160
  data += fixed_size;
24
160
  size -= fixed_size;
25
26
160
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
160
  auto buf = fmt::memory_buffer();
31
160
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
160
#endif
33
160
}
void invoke_fmt<double, unsigned long>(unsigned char const*, unsigned long)
Line
Count
Source
13
49
void invoke_fmt(const uint8_t* data, size_t size) {
14
49
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
49
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
49
  if (size <= fixed_size + fixed_size) return;
17
18
42
  const Item1 item1 = assign_from_buf<Item1>(data);
19
42
  data += fixed_size;
20
42
  size -= fixed_size;
21
22
42
  const Item2 item2 = assign_from_buf<Item2>(data);
23
42
  data += fixed_size;
24
42
  size -= fixed_size;
25
26
42
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
42
  auto buf = fmt::memory_buffer();
31
42
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
42
#endif
33
42
}
void invoke_fmt<double, float>(unsigned char const*, unsigned long)
Line
Count
Source
13
66
void invoke_fmt(const uint8_t* data, size_t size) {
14
66
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
66
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
66
  if (size <= fixed_size + fixed_size) return;
17
18
59
  const Item1 item1 = assign_from_buf<Item1>(data);
19
59
  data += fixed_size;
20
59
  size -= fixed_size;
21
22
59
  const Item2 item2 = assign_from_buf<Item2>(data);
23
59
  data += fixed_size;
24
59
  size -= fixed_size;
25
26
59
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
59
  auto buf = fmt::memory_buffer();
31
59
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
59
#endif
33
59
}
void invoke_fmt<double, double>(unsigned char const*, unsigned long)
Line
Count
Source
13
171
void invoke_fmt(const uint8_t* data, size_t size) {
14
171
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
171
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
171
  if (size <= fixed_size + fixed_size) return;
17
18
163
  const Item1 item1 = assign_from_buf<Item1>(data);
19
163
  data += fixed_size;
20
163
  size -= fixed_size;
21
22
163
  const Item2 item2 = assign_from_buf<Item2>(data);
23
163
  data += fixed_size;
24
163
  size -= fixed_size;
25
26
163
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
163
  auto buf = fmt::memory_buffer();
31
163
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
163
#endif
33
163
}
void invoke_fmt<double, long double>(unsigned char const*, unsigned long)
Line
Count
Source
13
118
void invoke_fmt(const uint8_t* data, size_t size) {
14
118
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
118
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
118
  if (size <= fixed_size + fixed_size) return;
17
18
110
  const Item1 item1 = assign_from_buf<Item1>(data);
19
110
  data += fixed_size;
20
110
  size -= fixed_size;
21
22
110
  const Item2 item2 = assign_from_buf<Item2>(data);
23
110
  data += fixed_size;
24
110
  size -= fixed_size;
25
26
110
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
110
  auto buf = fmt::memory_buffer();
31
110
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
110
#endif
33
110
}
void invoke_fmt<double, void*>(unsigned char const*, unsigned long)
Line
Count
Source
13
42
void invoke_fmt(const uint8_t* data, size_t size) {
14
42
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
42
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
42
  if (size <= fixed_size + fixed_size) return;
17
18
34
  const Item1 item1 = assign_from_buf<Item1>(data);
19
34
  data += fixed_size;
20
34
  size -= fixed_size;
21
22
34
  const Item2 item2 = assign_from_buf<Item2>(data);
23
34
  data += fixed_size;
24
34
  size -= fixed_size;
25
26
34
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
34
  auto buf = fmt::memory_buffer();
31
34
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
34
#endif
33
34
}
void invoke_fmt<long double, bool>(unsigned char const*, unsigned long)
Line
Count
Source
13
39
void invoke_fmt(const uint8_t* data, size_t size) {
14
39
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
39
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
39
  if (size <= fixed_size + fixed_size) return;
17
18
32
  const Item1 item1 = assign_from_buf<Item1>(data);
19
32
  data += fixed_size;
20
32
  size -= fixed_size;
21
22
32
  const Item2 item2 = assign_from_buf<Item2>(data);
23
32
  data += fixed_size;
24
32
  size -= fixed_size;
25
26
32
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
32
  auto buf = fmt::memory_buffer();
31
32
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
32
#endif
33
32
}
void invoke_fmt<long double, char>(unsigned char const*, unsigned long)
Line
Count
Source
13
61
void invoke_fmt(const uint8_t* data, size_t size) {
14
61
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
61
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
61
  if (size <= fixed_size + fixed_size) return;
17
18
53
  const Item1 item1 = assign_from_buf<Item1>(data);
19
53
  data += fixed_size;
20
53
  size -= fixed_size;
21
22
53
  const Item2 item2 = assign_from_buf<Item2>(data);
23
53
  data += fixed_size;
24
53
  size -= fixed_size;
25
26
53
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
53
  auto buf = fmt::memory_buffer();
31
53
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
53
#endif
33
53
}
void invoke_fmt<long double, signed char>(unsigned char const*, unsigned long)
Line
Count
Source
13
69
void invoke_fmt(const uint8_t* data, size_t size) {
14
69
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
69
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
69
  if (size <= fixed_size + fixed_size) return;
17
18
62
  const Item1 item1 = assign_from_buf<Item1>(data);
19
62
  data += fixed_size;
20
62
  size -= fixed_size;
21
22
62
  const Item2 item2 = assign_from_buf<Item2>(data);
23
62
  data += fixed_size;
24
62
  size -= fixed_size;
25
26
62
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
62
  auto buf = fmt::memory_buffer();
31
62
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
62
#endif
33
62
}
void invoke_fmt<long double, unsigned char>(unsigned char const*, unsigned long)
Line
Count
Source
13
51
void invoke_fmt(const uint8_t* data, size_t size) {
14
51
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
51
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
51
  if (size <= fixed_size + fixed_size) return;
17
18
44
  const Item1 item1 = assign_from_buf<Item1>(data);
19
44
  data += fixed_size;
20
44
  size -= fixed_size;
21
22
44
  const Item2 item2 = assign_from_buf<Item2>(data);
23
44
  data += fixed_size;
24
44
  size -= fixed_size;
25
26
44
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
44
  auto buf = fmt::memory_buffer();
31
44
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
44
#endif
33
44
}
void invoke_fmt<long double, short>(unsigned char const*, unsigned long)
Line
Count
Source
13
67
void invoke_fmt(const uint8_t* data, size_t size) {
14
67
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
67
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
67
  if (size <= fixed_size + fixed_size) return;
17
18
60
  const Item1 item1 = assign_from_buf<Item1>(data);
19
60
  data += fixed_size;
20
60
  size -= fixed_size;
21
22
60
  const Item2 item2 = assign_from_buf<Item2>(data);
23
60
  data += fixed_size;
24
60
  size -= fixed_size;
25
26
60
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
60
  auto buf = fmt::memory_buffer();
31
60
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
60
#endif
33
60
}
void invoke_fmt<long double, unsigned short>(unsigned char const*, unsigned long)
Line
Count
Source
13
167
void invoke_fmt(const uint8_t* data, size_t size) {
14
167
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
167
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
167
  if (size <= fixed_size + fixed_size) return;
17
18
160
  const Item1 item1 = assign_from_buf<Item1>(data);
19
160
  data += fixed_size;
20
160
  size -= fixed_size;
21
22
160
  const Item2 item2 = assign_from_buf<Item2>(data);
23
160
  data += fixed_size;
24
160
  size -= fixed_size;
25
26
160
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
160
  auto buf = fmt::memory_buffer();
31
160
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
160
#endif
33
160
}
void invoke_fmt<long double, int>(unsigned char const*, unsigned long)
Line
Count
Source
13
483
void invoke_fmt(const uint8_t* data, size_t size) {
14
483
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
483
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
483
  if (size <= fixed_size + fixed_size) return;
17
18
475
  const Item1 item1 = assign_from_buf<Item1>(data);
19
475
  data += fixed_size;
20
475
  size -= fixed_size;
21
22
475
  const Item2 item2 = assign_from_buf<Item2>(data);
23
475
  data += fixed_size;
24
475
  size -= fixed_size;
25
26
475
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
475
  auto buf = fmt::memory_buffer();
31
475
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
475
#endif
33
475
}
void invoke_fmt<long double, unsigned int>(unsigned char const*, unsigned long)
Line
Count
Source
13
280
void invoke_fmt(const uint8_t* data, size_t size) {
14
280
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
280
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
280
  if (size <= fixed_size + fixed_size) return;
17
18
272
  const Item1 item1 = assign_from_buf<Item1>(data);
19
272
  data += fixed_size;
20
272
  size -= fixed_size;
21
22
272
  const Item2 item2 = assign_from_buf<Item2>(data);
23
272
  data += fixed_size;
24
272
  size -= fixed_size;
25
26
272
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
272
  auto buf = fmt::memory_buffer();
31
272
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
272
#endif
33
272
}
void invoke_fmt<long double, long>(unsigned char const*, unsigned long)
Line
Count
Source
13
142
void invoke_fmt(const uint8_t* data, size_t size) {
14
142
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
142
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
142
  if (size <= fixed_size + fixed_size) return;
17
18
134
  const Item1 item1 = assign_from_buf<Item1>(data);
19
134
  data += fixed_size;
20
134
  size -= fixed_size;
21
22
134
  const Item2 item2 = assign_from_buf<Item2>(data);
23
134
  data += fixed_size;
24
134
  size -= fixed_size;
25
26
134
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
134
  auto buf = fmt::memory_buffer();
31
134
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
134
#endif
33
134
}
void invoke_fmt<long double, unsigned long>(unsigned char const*, unsigned long)
Line
Count
Source
13
45
void invoke_fmt(const uint8_t* data, size_t size) {
14
45
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
45
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
45
  if (size <= fixed_size + fixed_size) return;
17
18
39
  const Item1 item1 = assign_from_buf<Item1>(data);
19
39
  data += fixed_size;
20
39
  size -= fixed_size;
21
22
39
  const Item2 item2 = assign_from_buf<Item2>(data);
23
39
  data += fixed_size;
24
39
  size -= fixed_size;
25
26
39
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
39
  auto buf = fmt::memory_buffer();
31
39
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
39
#endif
33
39
}
void invoke_fmt<long double, float>(unsigned char const*, unsigned long)
Line
Count
Source
13
82
void invoke_fmt(const uint8_t* data, size_t size) {
14
82
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
82
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
82
  if (size <= fixed_size + fixed_size) return;
17
18
74
  const Item1 item1 = assign_from_buf<Item1>(data);
19
74
  data += fixed_size;
20
74
  size -= fixed_size;
21
22
74
  const Item2 item2 = assign_from_buf<Item2>(data);
23
74
  data += fixed_size;
24
74
  size -= fixed_size;
25
26
74
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
74
  auto buf = fmt::memory_buffer();
31
74
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
74
#endif
33
74
}
void invoke_fmt<long double, double>(unsigned char const*, unsigned long)
Line
Count
Source
13
86
void invoke_fmt(const uint8_t* data, size_t size) {
14
86
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
86
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
86
  if (size <= fixed_size + fixed_size) return;
17
18
78
  const Item1 item1 = assign_from_buf<Item1>(data);
19
78
  data += fixed_size;
20
78
  size -= fixed_size;
21
22
78
  const Item2 item2 = assign_from_buf<Item2>(data);
23
78
  data += fixed_size;
24
78
  size -= fixed_size;
25
26
78
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
78
  auto buf = fmt::memory_buffer();
31
78
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
78
#endif
33
78
}
void invoke_fmt<long double, long double>(unsigned char const*, unsigned long)
Line
Count
Source
13
114
void invoke_fmt(const uint8_t* data, size_t size) {
14
114
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
114
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
114
  if (size <= fixed_size + fixed_size) return;
17
18
107
  const Item1 item1 = assign_from_buf<Item1>(data);
19
107
  data += fixed_size;
20
107
  size -= fixed_size;
21
22
107
  const Item2 item2 = assign_from_buf<Item2>(data);
23
107
  data += fixed_size;
24
107
  size -= fixed_size;
25
26
107
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
107
  auto buf = fmt::memory_buffer();
31
107
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
107
#endif
33
107
}
void invoke_fmt<long double, void*>(unsigned char const*, unsigned long)
Line
Count
Source
13
44
void invoke_fmt(const uint8_t* data, size_t size) {
14
44
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
44
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
44
  if (size <= fixed_size + fixed_size) return;
17
18
36
  const Item1 item1 = assign_from_buf<Item1>(data);
19
36
  data += fixed_size;
20
36
  size -= fixed_size;
21
22
36
  const Item2 item2 = assign_from_buf<Item2>(data);
23
36
  data += fixed_size;
24
36
  size -= fixed_size;
25
26
36
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
36
  auto buf = fmt::memory_buffer();
31
36
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
36
#endif
33
36
}
void invoke_fmt<void*, bool>(unsigned char const*, unsigned long)
Line
Count
Source
13
38
void invoke_fmt(const uint8_t* data, size_t size) {
14
38
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
38
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
38
  if (size <= fixed_size + fixed_size) return;
17
18
31
  const Item1 item1 = assign_from_buf<Item1>(data);
19
31
  data += fixed_size;
20
31
  size -= fixed_size;
21
22
31
  const Item2 item2 = assign_from_buf<Item2>(data);
23
31
  data += fixed_size;
24
31
  size -= fixed_size;
25
26
31
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
31
  auto buf = fmt::memory_buffer();
31
31
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
31
#endif
33
31
}
void invoke_fmt<void*, char>(unsigned char const*, unsigned long)
Line
Count
Source
13
18
void invoke_fmt(const uint8_t* data, size_t size) {
14
18
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
18
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
18
  if (size <= fixed_size + fixed_size) return;
17
18
11
  const Item1 item1 = assign_from_buf<Item1>(data);
19
11
  data += fixed_size;
20
11
  size -= fixed_size;
21
22
11
  const Item2 item2 = assign_from_buf<Item2>(data);
23
11
  data += fixed_size;
24
11
  size -= fixed_size;
25
26
11
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
11
  auto buf = fmt::memory_buffer();
31
11
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
11
#endif
33
11
}
void invoke_fmt<void*, signed char>(unsigned char const*, unsigned long)
Line
Count
Source
13
38
void invoke_fmt(const uint8_t* data, size_t size) {
14
38
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
38
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
38
  if (size <= fixed_size + fixed_size) return;
17
18
30
  const Item1 item1 = assign_from_buf<Item1>(data);
19
30
  data += fixed_size;
20
30
  size -= fixed_size;
21
22
30
  const Item2 item2 = assign_from_buf<Item2>(data);
23
30
  data += fixed_size;
24
30
  size -= fixed_size;
25
26
30
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
30
  auto buf = fmt::memory_buffer();
31
30
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
30
#endif
33
30
}
void invoke_fmt<void*, unsigned char>(unsigned char const*, unsigned long)
Line
Count
Source
13
25
void invoke_fmt(const uint8_t* data, size_t size) {
14
25
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
25
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
25
  if (size <= fixed_size + fixed_size) return;
17
18
18
  const Item1 item1 = assign_from_buf<Item1>(data);
19
18
  data += fixed_size;
20
18
  size -= fixed_size;
21
22
18
  const Item2 item2 = assign_from_buf<Item2>(data);
23
18
  data += fixed_size;
24
18
  size -= fixed_size;
25
26
18
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
18
  auto buf = fmt::memory_buffer();
31
18
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
18
#endif
33
18
}
void invoke_fmt<void*, short>(unsigned char const*, unsigned long)
Line
Count
Source
13
25
void invoke_fmt(const uint8_t* data, size_t size) {
14
25
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
25
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
25
  if (size <= fixed_size + fixed_size) return;
17
18
17
  const Item1 item1 = assign_from_buf<Item1>(data);
19
17
  data += fixed_size;
20
17
  size -= fixed_size;
21
22
17
  const Item2 item2 = assign_from_buf<Item2>(data);
23
17
  data += fixed_size;
24
17
  size -= fixed_size;
25
26
17
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
17
  auto buf = fmt::memory_buffer();
31
17
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
17
#endif
33
17
}
void invoke_fmt<void*, unsigned short>(unsigned char const*, unsigned long)
Line
Count
Source
13
29
void invoke_fmt(const uint8_t* data, size_t size) {
14
29
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
29
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
29
  if (size <= fixed_size + fixed_size) return;
17
18
22
  const Item1 item1 = assign_from_buf<Item1>(data);
19
22
  data += fixed_size;
20
22
  size -= fixed_size;
21
22
22
  const Item2 item2 = assign_from_buf<Item2>(data);
23
22
  data += fixed_size;
24
22
  size -= fixed_size;
25
26
22
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
22
  auto buf = fmt::memory_buffer();
31
22
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
22
#endif
33
22
}
void invoke_fmt<void*, int>(unsigned char const*, unsigned long)
Line
Count
Source
13
30
void invoke_fmt(const uint8_t* data, size_t size) {
14
30
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
30
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
30
  if (size <= fixed_size + fixed_size) return;
17
18
22
  const Item1 item1 = assign_from_buf<Item1>(data);
19
22
  data += fixed_size;
20
22
  size -= fixed_size;
21
22
22
  const Item2 item2 = assign_from_buf<Item2>(data);
23
22
  data += fixed_size;
24
22
  size -= fixed_size;
25
26
22
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
22
  auto buf = fmt::memory_buffer();
31
22
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
22
#endif
33
22
}
void invoke_fmt<void*, unsigned int>(unsigned char const*, unsigned long)
Line
Count
Source
13
37
void invoke_fmt(const uint8_t* data, size_t size) {
14
37
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
37
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
37
  if (size <= fixed_size + fixed_size) return;
17
18
29
  const Item1 item1 = assign_from_buf<Item1>(data);
19
29
  data += fixed_size;
20
29
  size -= fixed_size;
21
22
29
  const Item2 item2 = assign_from_buf<Item2>(data);
23
29
  data += fixed_size;
24
29
  size -= fixed_size;
25
26
29
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
29
  auto buf = fmt::memory_buffer();
31
29
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
29
#endif
33
29
}
void invoke_fmt<void*, long>(unsigned char const*, unsigned long)
Line
Count
Source
13
31
void invoke_fmt(const uint8_t* data, size_t size) {
14
31
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
31
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
31
  if (size <= fixed_size + fixed_size) return;
17
18
23
  const Item1 item1 = assign_from_buf<Item1>(data);
19
23
  data += fixed_size;
20
23
  size -= fixed_size;
21
22
23
  const Item2 item2 = assign_from_buf<Item2>(data);
23
23
  data += fixed_size;
24
23
  size -= fixed_size;
25
26
23
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
23
  auto buf = fmt::memory_buffer();
31
23
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
23
#endif
33
23
}
void invoke_fmt<void*, unsigned long>(unsigned char const*, unsigned long)
Line
Count
Source
13
29
void invoke_fmt(const uint8_t* data, size_t size) {
14
29
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
29
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
29
  if (size <= fixed_size + fixed_size) return;
17
18
21
  const Item1 item1 = assign_from_buf<Item1>(data);
19
21
  data += fixed_size;
20
21
  size -= fixed_size;
21
22
21
  const Item2 item2 = assign_from_buf<Item2>(data);
23
21
  data += fixed_size;
24
21
  size -= fixed_size;
25
26
21
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
21
  auto buf = fmt::memory_buffer();
31
21
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
21
#endif
33
21
}
void invoke_fmt<void*, float>(unsigned char const*, unsigned long)
Line
Count
Source
13
20
void invoke_fmt(const uint8_t* data, size_t size) {
14
20
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
20
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
20
  if (size <= fixed_size + fixed_size) return;
17
18
14
  const Item1 item1 = assign_from_buf<Item1>(data);
19
14
  data += fixed_size;
20
14
  size -= fixed_size;
21
22
14
  const Item2 item2 = assign_from_buf<Item2>(data);
23
14
  data += fixed_size;
24
14
  size -= fixed_size;
25
26
14
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
14
  auto buf = fmt::memory_buffer();
31
14
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
14
#endif
33
14
}
void invoke_fmt<void*, double>(unsigned char const*, unsigned long)
Line
Count
Source
13
22
void invoke_fmt(const uint8_t* data, size_t size) {
14
22
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
22
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
22
  if (size <= fixed_size + fixed_size) return;
17
18
14
  const Item1 item1 = assign_from_buf<Item1>(data);
19
14
  data += fixed_size;
20
14
  size -= fixed_size;
21
22
14
  const Item2 item2 = assign_from_buf<Item2>(data);
23
14
  data += fixed_size;
24
14
  size -= fixed_size;
25
26
14
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
14
  auto buf = fmt::memory_buffer();
31
14
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
14
#endif
33
14
}
void invoke_fmt<void*, long double>(unsigned char const*, unsigned long)
Line
Count
Source
13
27
void invoke_fmt(const uint8_t* data, size_t size) {
14
27
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
27
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
27
  if (size <= fixed_size + fixed_size) return;
17
18
19
  const Item1 item1 = assign_from_buf<Item1>(data);
19
19
  data += fixed_size;
20
19
  size -= fixed_size;
21
22
19
  const Item2 item2 = assign_from_buf<Item2>(data);
23
19
  data += fixed_size;
24
19
  size -= fixed_size;
25
26
19
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
19
  auto buf = fmt::memory_buffer();
31
19
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
19
#endif
33
19
}
void invoke_fmt<void*, void*>(unsigned char const*, unsigned long)
Line
Count
Source
13
32
void invoke_fmt(const uint8_t* data, size_t size) {
14
32
  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
15
32
  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
16
32
  if (size <= fixed_size + fixed_size) return;
17
18
24
  const Item1 item1 = assign_from_buf<Item1>(data);
19
24
  data += fixed_size;
20
24
  size -= fixed_size;
21
22
24
  const Item2 item2 = assign_from_buf<Item2>(data);
23
24
  data += fixed_size;
24
24
  size -= fixed_size;
25
26
24
  auto format_str = fmt::string_view(as_chars(data), size);
27
#if FMT_FUZZ_FORMAT_TO_STRING
28
  std::string message = fmt::format(format_str, item1, item2);
29
#else
30
24
  auto buf = fmt::memory_buffer();
31
24
  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
32
24
#endif
33
24
}
34
35
// For dynamic dispatching to an explicit instantiation.
36
23.9k
template <typename Callback> void invoke(int index, Callback callback) {
37
23.9k
  switch (index) {
38
1.33k
  case 0:
39
1.33k
    callback(bool());
40
1.33k
    break;
41
1.17k
  case 1:
42
1.17k
    callback(char());
43
1.17k
    break;
44
1.24k
  case 2:
45
1.24k
    using sc = signed char;
46
1.24k
    callback(sc());
47
1.24k
    break;
48
1.00k
  case 3:
49
1.00k
    using uc = unsigned char;
50
1.00k
    callback(uc());
51
1.00k
    break;
52
1.07k
  case 4:
53
1.07k
    callback(short());
54
1.07k
    break;
55
1.25k
  case 5:
56
1.25k
    using us = unsigned short;
57
1.25k
    callback(us());
58
1.25k
    break;
59
2.21k
  case 6:
60
2.21k
    callback(int());
61
2.21k
    break;
62
2.47k
  case 7:
63
2.47k
    callback(unsigned());
64
2.47k
    break;
65
1.74k
  case 8:
66
1.74k
    callback(long());
67
1.74k
    break;
68
1.39k
  case 9:
69
1.39k
    using ul = unsigned long;
70
1.39k
    callback(ul());
71
1.39k
    break;
72
2.46k
  case 10:
73
2.46k
    callback(float());
74
2.46k
    break;
75
3.36k
  case 11:
76
3.36k
    callback(double());
77
3.36k
    break;
78
2.33k
  case 12:
79
2.33k
    using LD = long double;
80
2.33k
    callback(LD());
81
2.33k
    break;
82
834
  case 13:
83
834
    using ptr = void*;
84
834
    callback(ptr());
85
834
    break;
86
23.9k
  }
87
23.9k
}
two-args.cc:void invoke<LLVMFuzzerTestOneInput::$_0>(int, LLVMFuzzerTestOneInput::$_0)
Line
Count
Source
36
11.9k
template <typename Callback> void invoke(int index, Callback callback) {
37
11.9k
  switch (index) {
38
561
  case 0:
39
561
    callback(bool());
40
561
    break;
41
526
  case 1:
42
526
    callback(char());
43
526
    break;
44
370
  case 2:
45
370
    using sc = signed char;
46
370
    callback(sc());
47
370
    break;
48
359
  case 3:
49
359
    using uc = unsigned char;
50
359
    callback(uc());
51
359
    break;
52
408
  case 4:
53
408
    callback(short());
54
408
    break;
55
314
  case 5:
56
314
    using us = unsigned short;
57
314
    callback(us());
58
314
    break;
59
526
  case 6:
60
526
    callback(int());
61
526
    break;
62
609
  case 7:
63
609
    callback(unsigned());
64
609
    break;
65
886
  case 8:
66
886
    callback(long());
67
886
    break;
68
800
  case 9:
69
800
    using ul = unsigned long;
70
800
    callback(ul());
71
800
    break;
72
1.76k
  case 10:
73
1.76k
    callback(float());
74
1.76k
    break;
75
2.69k
  case 11:
76
2.69k
    callback(double());
77
2.69k
    break;
78
1.73k
  case 12:
79
1.73k
    using LD = long double;
80
1.73k
    callback(LD());
81
1.73k
    break;
82
402
  case 13:
83
402
    using ptr = void*;
84
402
    callback(ptr());
85
402
    break;
86
11.9k
  }
87
11.9k
}
two-args.cc:void invoke<LLVMFuzzerTestOneInput::$_0::operator()<bool>(bool) const::{lambda(auto:1)#1}>(int, LLVMFuzzerTestOneInput::$_0::operator()<bool>(bool) const::{lambda(auto:1)#1})
Line
Count
Source
36
561
template <typename Callback> void invoke(int index, Callback callback) {
37
561
  switch (index) {
38
101
  case 0:
39
101
    callback(bool());
40
101
    break;
41
82
  case 1:
42
82
    callback(char());
43
82
    break;
44
24
  case 2:
45
24
    using sc = signed char;
46
24
    callback(sc());
47
24
    break;
48
50
  case 3:
49
50
    using uc = unsigned char;
50
50
    callback(uc());
51
50
    break;
52
28
  case 4:
53
28
    callback(short());
54
28
    break;
55
34
  case 5:
56
34
    using us = unsigned short;
57
34
    callback(us());
58
34
    break;
59
49
  case 6:
60
49
    callback(int());
61
49
    break;
62
35
  case 7:
63
35
    callback(unsigned());
64
35
    break;
65
42
  case 8:
66
42
    callback(long());
67
42
    break;
68
25
  case 9:
69
25
    using ul = unsigned long;
70
25
    callback(ul());
71
25
    break;
72
31
  case 10:
73
31
    callback(float());
74
31
    break;
75
17
  case 11:
76
17
    callback(double());
77
17
    break;
78
21
  case 12:
79
21
    using LD = long double;
80
21
    callback(LD());
81
21
    break;
82
21
  case 13:
83
21
    using ptr = void*;
84
21
    callback(ptr());
85
21
    break;
86
561
  }
87
561
}
two-args.cc:void invoke<LLVMFuzzerTestOneInput::$_0::operator()<char>(char) const::{lambda(auto:1)#1}>(int, LLVMFuzzerTestOneInput::$_0::operator()<char>(char) const::{lambda(auto:1)#1})
Line
Count
Source
36
526
template <typename Callback> void invoke(int index, Callback callback) {
37
526
  switch (index) {
38
74
  case 0:
39
74
    callback(bool());
40
74
    break;
41
66
  case 1:
42
66
    callback(char());
43
66
    break;
44
33
  case 2:
45
33
    using sc = signed char;
46
33
    callback(sc());
47
33
    break;
48
39
  case 3:
49
39
    using uc = unsigned char;
50
39
    callback(uc());
51
39
    break;
52
53
  case 4:
53
53
    callback(short());
54
53
    break;
55
18
  case 5:
56
18
    using us = unsigned short;
57
18
    callback(us());
58
18
    break;
59
45
  case 6:
60
45
    callback(int());
61
45
    break;
62
37
  case 7:
63
37
    callback(unsigned());
64
37
    break;
65
33
  case 8:
66
33
    callback(long());
67
33
    break;
68
31
  case 9:
69
31
    using ul = unsigned long;
70
31
    callback(ul());
71
31
    break;
72
28
  case 10:
73
28
    callback(float());
74
28
    break;
75
23
  case 11:
76
23
    callback(double());
77
23
    break;
78
25
  case 12:
79
25
    using LD = long double;
80
25
    callback(LD());
81
25
    break;
82
20
  case 13:
83
20
    using ptr = void*;
84
20
    callback(ptr());
85
20
    break;
86
526
  }
87
526
}
two-args.cc:void invoke<LLVMFuzzerTestOneInput::$_0::operator()<signed char>(signed char) const::{lambda(auto:1)#1}>(int, LLVMFuzzerTestOneInput::$_0::operator()<signed char>(signed char) const::{lambda(auto:1)#1})
Line
Count
Source
36
370
template <typename Callback> void invoke(int index, Callback callback) {
37
370
  switch (index) {
38
41
  case 0:
39
41
    callback(bool());
40
41
    break;
41
20
  case 1:
42
20
    callback(char());
43
20
    break;
44
29
  case 2:
45
29
    using sc = signed char;
46
29
    callback(sc());
47
29
    break;
48
18
  case 3:
49
18
    using uc = unsigned char;
50
18
    callback(uc());
51
18
    break;
52
28
  case 4:
53
28
    callback(short());
54
28
    break;
55
20
  case 5:
56
20
    using us = unsigned short;
57
20
    callback(us());
58
20
    break;
59
27
  case 6:
60
27
    callback(int());
61
27
    break;
62
28
  case 7:
63
28
    callback(unsigned());
64
28
    break;
65
26
  case 8:
66
26
    callback(long());
67
26
    break;
68
30
  case 9:
69
30
    using ul = unsigned long;
70
30
    callback(ul());
71
30
    break;
72
20
  case 10:
73
20
    callback(float());
74
20
    break;
75
35
  case 11:
76
35
    callback(double());
77
35
    break;
78
24
  case 12:
79
24
    using LD = long double;
80
24
    callback(LD());
81
24
    break;
82
23
  case 13:
83
23
    using ptr = void*;
84
23
    callback(ptr());
85
23
    break;
86
370
  }
87
370
}
two-args.cc:void invoke<LLVMFuzzerTestOneInput::$_0::operator()<unsigned char>(unsigned char) const::{lambda(auto:1)#1}>(int, LLVMFuzzerTestOneInput::$_0::operator()<unsigned char>(unsigned char) const::{lambda(auto:1)#1})
Line
Count
Source
36
359
template <typename Callback> void invoke(int index, Callback callback) {
37
359
  switch (index) {
38
27
  case 0:
39
27
    callback(bool());
40
27
    break;
41
29
  case 1:
42
29
    callback(char());
43
29
    break;
44
41
  case 2:
45
41
    using sc = signed char;
46
41
    callback(sc());
47
41
    break;
48
21
  case 3:
49
21
    using uc = unsigned char;
50
21
    callback(uc());
51
21
    break;
52
27
  case 4:
53
27
    callback(short());
54
27
    break;
55
23
  case 5:
56
23
    using us = unsigned short;
57
23
    callback(us());
58
23
    break;
59
38
  case 6:
60
38
    callback(int());
61
38
    break;
62
34
  case 7:
63
34
    callback(unsigned());
64
34
    break;
65
16
  case 8:
66
16
    callback(long());
67
16
    break;
68
30
  case 9:
69
30
    using ul = unsigned long;
70
30
    callback(ul());
71
30
    break;
72
19
  case 10:
73
19
    callback(float());
74
19
    break;
75
20
  case 11:
76
20
    callback(double());
77
20
    break;
78
22
  case 12:
79
22
    using LD = long double;
80
22
    callback(LD());
81
22
    break;
82
11
  case 13:
83
11
    using ptr = void*;
84
11
    callback(ptr());
85
11
    break;
86
359
  }
87
359
}
two-args.cc:void invoke<LLVMFuzzerTestOneInput::$_0::operator()<short>(short) const::{lambda(auto:1)#1}>(int, LLVMFuzzerTestOneInput::$_0::operator()<short>(short) const::{lambda(auto:1)#1})
Line
Count
Source
36
408
template <typename Callback> void invoke(int index, Callback callback) {
37
408
  switch (index) {
38
22
  case 0:
39
22
    callback(bool());
40
22
    break;
41
21
  case 1:
42
21
    callback(char());
43
21
    break;
44
32
  case 2:
45
32
    using sc = signed char;
46
32
    callback(sc());
47
32
    break;
48
16
  case 3:
49
16
    using uc = unsigned char;
50
16
    callback(uc());
51
16
    break;
52
30
  case 4:
53
30
    callback(short());
54
30
    break;
55
19
  case 5:
56
19
    using us = unsigned short;
57
19
    callback(us());
58
19
    break;
59
40
  case 6:
60
40
    callback(int());
61
40
    break;
62
37
  case 7:
63
37
    callback(unsigned());
64
37
    break;
65
55
  case 8:
66
55
    callback(long());
67
55
    break;
68
27
  case 9:
69
27
    using ul = unsigned long;
70
27
    callback(ul());
71
27
    break;
72
25
  case 10:
73
25
    callback(float());
74
25
    break;
75
38
  case 11:
76
38
    callback(double());
77
38
    break;
78
25
  case 12:
79
25
    using LD = long double;
80
25
    callback(LD());
81
25
    break;
82
20
  case 13:
83
20
    using ptr = void*;
84
20
    callback(ptr());
85
20
    break;
86
408
  }
87
408
}
two-args.cc:void invoke<LLVMFuzzerTestOneInput::$_0::operator()<unsigned short>(unsigned short) const::{lambda(auto:1)#1}>(int, LLVMFuzzerTestOneInput::$_0::operator()<unsigned short>(unsigned short) const::{lambda(auto:1)#1})
Line
Count
Source
36
314
template <typename Callback> void invoke(int index, Callback callback) {
37
314
  switch (index) {
38
16
  case 0:
39
16
    callback(bool());
40
16
    break;
41
28
  case 1:
42
28
    callback(char());
43
28
    break;
44
26
  case 2:
45
26
    using sc = signed char;
46
26
    callback(sc());
47
26
    break;
48
17
  case 3:
49
17
    using uc = unsigned char;
50
17
    callback(uc());
51
17
    break;
52
27
  case 4:
53
27
    callback(short());
54
27
    break;
55
20
  case 5:
56
20
    using us = unsigned short;
57
20
    callback(us());
58
20
    break;
59
29
  case 6:
60
29
    callback(int());
61
29
    break;
62
29
  case 7:
63
29
    callback(unsigned());
64
29
    break;
65
24
  case 8:
66
24
    callback(long());
67
24
    break;
68
21
  case 9:
69
21
    using ul = unsigned long;
70
21
    callback(ul());
71
21
    break;
72
23
  case 10:
73
23
    callback(float());
74
23
    break;
75
21
  case 11:
76
21
    callback(double());
77
21
    break;
78
13
  case 12:
79
13
    using LD = long double;
80
13
    callback(LD());
81
13
    break;
82
19
  case 13:
83
19
    using ptr = void*;
84
19
    callback(ptr());
85
19
    break;
86
314
  }
87
314
}
two-args.cc:void invoke<LLVMFuzzerTestOneInput::$_0::operator()<int>(int) const::{lambda(auto:1)#1}>(int, LLVMFuzzerTestOneInput::$_0::operator()<int>(int) const::{lambda(auto:1)#1})
Line
Count
Source
36
526
template <typename Callback> void invoke(int index, Callback callback) {
37
526
  switch (index) {
38
37
  case 0:
39
37
    callback(bool());
40
37
    break;
41
31
  case 1:
42
31
    callback(char());
43
31
    break;
44
63
  case 2:
45
63
    using sc = signed char;
46
63
    callback(sc());
47
63
    break;
48
29
  case 3:
49
29
    using uc = unsigned char;
50
29
    callback(uc());
51
29
    break;
52
34
  case 4:
53
34
    callback(short());
54
34
    break;
55
32
  case 5:
56
32
    using us = unsigned short;
57
32
    callback(us());
58
32
    break;
59
41
  case 6:
60
41
    callback(int());
61
41
    break;
62
25
  case 7:
63
25
    callback(unsigned());
64
25
    break;
65
45
  case 8:
66
45
    callback(long());
67
45
    break;
68
42
  case 9:
69
42
    using ul = unsigned long;
70
42
    callback(ul());
71
42
    break;
72
56
  case 10:
73
56
    callback(float());
74
56
    break;
75
29
  case 11:
76
29
    callback(double());
77
29
    break;
78
32
  case 12:
79
32
    using LD = long double;
80
32
    callback(LD());
81
32
    break;
82
29
  case 13:
83
29
    using ptr = void*;
84
29
    callback(ptr());
85
29
    break;
86
526
  }
87
526
}
two-args.cc:void invoke<LLVMFuzzerTestOneInput::$_0::operator()<unsigned int>(unsigned int) const::{lambda(auto:1)#1}>(int, LLVMFuzzerTestOneInput::$_0::operator()<unsigned int>(unsigned int) const::{lambda(auto:1)#1})
Line
Count
Source
36
609
template <typename Callback> void invoke(int index, Callback callback) {
37
609
  switch (index) {
38
55
  case 0:
39
55
    callback(bool());
40
55
    break;
41
27
  case 1:
42
27
    callback(char());
43
27
    break;
44
44
  case 2:
45
44
    using sc = signed char;
46
44
    callback(sc());
47
44
    break;
48
25
  case 3:
49
25
    using uc = unsigned char;
50
25
    callback(uc());
51
25
    break;
52
28
  case 4:
53
28
    callback(short());
54
28
    break;
55
53
  case 5:
56
53
    using us = unsigned short;
57
53
    callback(us());
58
53
    break;
59
40
  case 6:
60
40
    callback(int());
61
40
    break;
62
61
  case 7:
63
61
    callback(unsigned());
64
61
    break;
65
69
  case 8:
66
69
    callback(long());
67
69
    break;
68
37
  case 9:
69
37
    using ul = unsigned long;
70
37
    callback(ul());
71
37
    break;
72
48
  case 10:
73
48
    callback(float());
74
48
    break;
75
51
  case 11:
76
51
    callback(double());
77
51
    break;
78
37
  case 12:
79
37
    using LD = long double;
80
37
    callback(LD());
81
37
    break;
82
33
  case 13:
83
33
    using ptr = void*;
84
33
    callback(ptr());
85
33
    break;
86
609
  }
87
609
}
two-args.cc:void invoke<LLVMFuzzerTestOneInput::$_0::operator()<long>(long) const::{lambda(auto:1)#1}>(int, LLVMFuzzerTestOneInput::$_0::operator()<long>(long) const::{lambda(auto:1)#1})
Line
Count
Source
36
886
template <typename Callback> void invoke(int index, Callback callback) {
37
886
  switch (index) {
38
40
  case 0:
39
40
    callback(bool());
40
40
    break;
41
85
  case 1:
42
85
    callback(char());
43
85
    break;
44
101
  case 2:
45
101
    using sc = signed char;
46
101
    callback(sc());
47
101
    break;
48
39
  case 3:
49
39
    using uc = unsigned char;
50
39
    callback(uc());
51
39
    break;
52
44
  case 4:
53
44
    callback(short());
54
44
    break;
55
54
  case 5:
56
54
    using us = unsigned short;
57
54
    callback(us());
58
54
    break;
59
69
  case 6:
60
69
    callback(int());
61
69
    break;
62
102
  case 7:
63
102
    callback(unsigned());
64
102
    break;
65
77
  case 8:
66
77
    callback(long());
67
77
    break;
68
56
  case 9:
69
56
    using ul = unsigned long;
70
56
    callback(ul());
71
56
    break;
72
64
  case 10:
73
64
    callback(float());
74
64
    break;
75
52
  case 11:
76
52
    callback(double());
77
52
    break;
78
50
  case 12:
79
50
    using LD = long double;
80
50
    callback(LD());
81
50
    break;
82
52
  case 13:
83
52
    using ptr = void*;
84
52
    callback(ptr());
85
52
    break;
86
886
  }
87
886
}
two-args.cc:void invoke<LLVMFuzzerTestOneInput::$_0::operator()<unsigned long>(unsigned long) const::{lambda(auto:1)#1}>(int, LLVMFuzzerTestOneInput::$_0::operator()<unsigned long>(unsigned long) const::{lambda(auto:1)#1})
Line
Count
Source
36
800
template <typename Callback> void invoke(int index, Callback callback) {
37
800
  switch (index) {
38
66
  case 0:
39
66
    callback(bool());
40
66
    break;
41
38
  case 1:
42
38
    callback(char());
43
38
    break;
44
69
  case 2:
45
69
    using sc = signed char;
46
69
    callback(sc());
47
69
    break;
48
35
  case 3:
49
35
    using uc = unsigned char;
50
35
    callback(uc());
51
35
    break;
52
54
  case 4:
53
54
    callback(short());
54
54
    break;
55
73
  case 5:
56
73
    using us = unsigned short;
57
73
    callback(us());
58
73
    break;
59
67
  case 6:
60
67
    callback(int());
61
67
    break;
62
79
  case 7:
63
79
    callback(unsigned());
64
79
    break;
65
61
  case 8:
66
61
    callback(long());
67
61
    break;
68
65
  case 9:
69
65
    using ul = unsigned long;
70
65
    callback(ul());
71
65
    break;
72
53
  case 10:
73
53
    callback(float());
74
53
    break;
75
34
  case 11:
76
34
    callback(double());
77
34
    break;
78
40
  case 12:
79
40
    using LD = long double;
80
40
    callback(LD());
81
40
    break;
82
65
  case 13:
83
65
    using ptr = void*;
84
65
    callback(ptr());
85
65
    break;
86
800
  }
87
800
}
two-args.cc:void invoke<LLVMFuzzerTestOneInput::$_0::operator()<float>(float) const::{lambda(auto:1)#1}>(int, LLVMFuzzerTestOneInput::$_0::operator()<float>(float) const::{lambda(auto:1)#1})
Line
Count
Source
36
1.76k
template <typename Callback> void invoke(int index, Callback callback) {
37
1.76k
  switch (index) {
38
89
  case 0:
39
89
    callback(bool());
40
89
    break;
41
40
  case 1:
42
40
    callback(char());
43
40
    break;
44
94
  case 2:
45
94
    using sc = signed char;
46
94
    callback(sc());
47
94
    break;
48
116
  case 3:
49
116
    using uc = unsigned char;
50
116
    callback(uc());
51
116
    break;
52
99
  case 4:
53
99
    callback(short());
54
99
    break;
55
145
  case 5:
56
145
    using us = unsigned short;
57
145
    callback(us());
58
145
    break;
59
272
  case 6:
60
272
    callback(int());
61
272
    break;
62
434
  case 7:
63
434
    callback(unsigned());
64
434
    break;
65
65
  case 8:
66
65
    callback(long());
67
65
    break;
68
105
  case 9:
69
105
    using ul = unsigned long;
70
105
    callback(ul());
71
105
    break;
72
165
  case 10:
73
165
    callback(float());
74
165
    break;
75
69
  case 11:
76
69
    callback(double());
77
69
    break;
78
52
  case 12:
79
52
    using LD = long double;
80
52
    callback(LD());
81
52
    break;
82
21
  case 13:
83
21
    using ptr = void*;
84
21
    callback(ptr());
85
21
    break;
86
1.76k
  }
87
1.76k
}
two-args.cc:void invoke<LLVMFuzzerTestOneInput::$_0::operator()<double>(double) const::{lambda(auto:1)#1}>(int, LLVMFuzzerTestOneInput::$_0::operator()<double>(double) const::{lambda(auto:1)#1})
Line
Count
Source
36
2.69k
template <typename Callback> void invoke(int index, Callback callback) {
37
2.69k
  switch (index) {
38
125
  case 0:
39
125
    callback(bool());
40
125
    break;
41
99
  case 1:
42
99
    callback(char());
43
99
    break;
44
212
  case 2:
45
212
    using sc = signed char;
46
212
    callback(sc());
47
212
    break;
48
165
  case 3:
49
165
    using uc = unsigned char;
50
165
    callback(uc());
51
165
    break;
52
123
  case 4:
53
123
    callback(short());
54
123
    break;
55
257
  case 5:
56
257
    using us = unsigned short;
57
257
    callback(us());
58
257
    break;
59
458
  case 6:
60
458
    callback(int());
61
458
    break;
62
644
  case 7:
63
644
    callback(unsigned());
64
644
    break;
65
168
  case 8:
66
168
    callback(long());
67
168
    break;
68
49
  case 9:
69
49
    using ul = unsigned long;
70
49
    callback(ul());
71
49
    break;
72
66
  case 10:
73
66
    callback(float());
74
66
    break;
75
171
  case 11:
76
171
    callback(double());
77
171
    break;
78
118
  case 12:
79
118
    using LD = long double;
80
118
    callback(LD());
81
118
    break;
82
42
  case 13:
83
42
    using ptr = void*;
84
42
    callback(ptr());
85
42
    break;
86
2.69k
  }
87
2.69k
}
two-args.cc:void invoke<LLVMFuzzerTestOneInput::$_0::operator()<long double>(long double) const::{lambda(auto:1)#1}>(int, LLVMFuzzerTestOneInput::$_0::operator()<long double>(long double) const::{lambda(auto:1)#1})
Line
Count
Source
36
1.73k
template <typename Callback> void invoke(int index, Callback callback) {
37
1.73k
  switch (index) {
38
39
  case 0:
39
39
    callback(bool());
40
39
    break;
41
61
  case 1:
42
61
    callback(char());
43
61
    break;
44
69
  case 2:
45
69
    using sc = signed char;
46
69
    callback(sc());
47
69
    break;
48
51
  case 3:
49
51
    using uc = unsigned char;
50
51
    callback(uc());
51
51
    break;
52
67
  case 4:
53
67
    callback(short());
54
67
    break;
55
167
  case 5:
56
167
    using us = unsigned short;
57
167
    callback(us());
58
167
    break;
59
483
  case 6:
60
483
    callback(int());
61
483
    break;
62
280
  case 7:
63
280
    callback(unsigned());
64
280
    break;
65
142
  case 8:
66
142
    callback(long());
67
142
    break;
68
45
  case 9:
69
45
    using ul = unsigned long;
70
45
    callback(ul());
71
45
    break;
72
82
  case 10:
73
82
    callback(float());
74
82
    break;
75
86
  case 11:
76
86
    callback(double());
77
86
    break;
78
114
  case 12:
79
114
    using LD = long double;
80
114
    callback(LD());
81
114
    break;
82
44
  case 13:
83
44
    using ptr = void*;
84
44
    callback(ptr());
85
44
    break;
86
1.73k
  }
87
1.73k
}
two-args.cc:void invoke<LLVMFuzzerTestOneInput::$_0::operator()<void*>(void*) const::{lambda(auto:1)#1}>(int, LLVMFuzzerTestOneInput::$_0::operator()<void*>(void*) const::{lambda(auto:1)#1})
Line
Count
Source
36
402
template <typename Callback> void invoke(int index, Callback callback) {
37
402
  switch (index) {
38
38
  case 0:
39
38
    callback(bool());
40
38
    break;
41
18
  case 1:
42
18
    callback(char());
43
18
    break;
44
38
  case 2:
45
38
    using sc = signed char;
46
38
    callback(sc());
47
38
    break;
48
25
  case 3:
49
25
    using uc = unsigned char;
50
25
    callback(uc());
51
25
    break;
52
25
  case 4:
53
25
    callback(short());
54
25
    break;
55
29
  case 5:
56
29
    using us = unsigned short;
57
29
    callback(us());
58
29
    break;
59
30
  case 6:
60
30
    callback(int());
61
30
    break;
62
37
  case 7:
63
37
    callback(unsigned());
64
37
    break;
65
31
  case 8:
66
31
    callback(long());
67
31
    break;
68
29
  case 9:
69
29
    using ul = unsigned long;
70
29
    callback(ul());
71
29
    break;
72
20
  case 10:
73
20
    callback(float());
74
20
    break;
75
22
  case 11:
76
22
    callback(double());
77
22
    break;
78
27
  case 12:
79
27
    using LD = long double;
80
27
    callback(LD());
81
27
    break;
82
32
  case 13:
83
32
    using ptr = void*;
84
32
    callback(ptr());
85
32
    break;
86
402
  }
87
402
}
88
89
11.9k
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
90
11.9k
  if (size <= 3) return 0;
91
92
  // Switch types depending on the first byte of the input.
93
11.9k
  const auto type1 = data[0] & 0x0F;
94
11.9k
  const auto type2 = (data[0] & 0xF0) >> 4;
95
11.9k
  data++;
96
11.9k
  size--;
97
11.9k
  try {
98
11.9k
    invoke(type1, [=](auto param1) {
99
11.9k
      invoke(type2, [=](auto param2) {
100
11.9k
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
11.9k
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<bool>(bool) const::{lambda(auto:1)#1}::operator()<bool>(bool) const
Line
Count
Source
99
101
      invoke(type2, [=](auto param2) {
100
101
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
101
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<bool>(bool) const::{lambda(auto:1)#1}::operator()<char>(char) const
Line
Count
Source
99
82
      invoke(type2, [=](auto param2) {
100
82
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
82
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<bool>(bool) const::{lambda(auto:1)#1}::operator()<signed char>(signed char) const
Line
Count
Source
99
24
      invoke(type2, [=](auto param2) {
100
24
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
24
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<bool>(bool) const::{lambda(auto:1)#1}::operator()<unsigned char>(unsigned char) const
Line
Count
Source
99
50
      invoke(type2, [=](auto param2) {
100
50
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
50
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<bool>(bool) const::{lambda(auto:1)#1}::operator()<short>(short) const
Line
Count
Source
99
28
      invoke(type2, [=](auto param2) {
100
28
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
28
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<bool>(bool) const::{lambda(auto:1)#1}::operator()<unsigned short>(unsigned short) const
Line
Count
Source
99
34
      invoke(type2, [=](auto param2) {
100
34
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
34
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<bool>(bool) const::{lambda(auto:1)#1}::operator()<int>(int) const
Line
Count
Source
99
49
      invoke(type2, [=](auto param2) {
100
49
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
49
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<bool>(bool) const::{lambda(auto:1)#1}::operator()<unsigned int>(unsigned int) const
Line
Count
Source
99
35
      invoke(type2, [=](auto param2) {
100
35
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
35
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<bool>(bool) const::{lambda(auto:1)#1}::operator()<long>(long) const
Line
Count
Source
99
42
      invoke(type2, [=](auto param2) {
100
42
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
42
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<bool>(bool) const::{lambda(auto:1)#1}::operator()<unsigned long>(unsigned long) const
Line
Count
Source
99
25
      invoke(type2, [=](auto param2) {
100
25
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
25
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<bool>(bool) const::{lambda(auto:1)#1}::operator()<float>(float) const
Line
Count
Source
99
31
      invoke(type2, [=](auto param2) {
100
31
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
31
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<bool>(bool) const::{lambda(auto:1)#1}::operator()<double>(double) const
Line
Count
Source
99
17
      invoke(type2, [=](auto param2) {
100
17
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
17
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<bool>(bool) const::{lambda(auto:1)#1}::operator()<long double>(long double) const
Line
Count
Source
99
21
      invoke(type2, [=](auto param2) {
100
21
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
21
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<bool>(bool) const::{lambda(auto:1)#1}::operator()<void*>(void*) const
Line
Count
Source
99
21
      invoke(type2, [=](auto param2) {
100
21
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
21
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<char>(char) const::{lambda(auto:1)#1}::operator()<bool>(bool) const
Line
Count
Source
99
74
      invoke(type2, [=](auto param2) {
100
74
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
74
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<char>(char) const::{lambda(auto:1)#1}::operator()<char>(char) const
Line
Count
Source
99
66
      invoke(type2, [=](auto param2) {
100
66
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
66
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<char>(char) const::{lambda(auto:1)#1}::operator()<signed char>(signed char) const
Line
Count
Source
99
33
      invoke(type2, [=](auto param2) {
100
33
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
33
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<char>(char) const::{lambda(auto:1)#1}::operator()<unsigned char>(unsigned char) const
Line
Count
Source
99
39
      invoke(type2, [=](auto param2) {
100
39
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
39
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<char>(char) const::{lambda(auto:1)#1}::operator()<short>(short) const
Line
Count
Source
99
53
      invoke(type2, [=](auto param2) {
100
53
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
53
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<char>(char) const::{lambda(auto:1)#1}::operator()<unsigned short>(unsigned short) const
Line
Count
Source
99
18
      invoke(type2, [=](auto param2) {
100
18
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
18
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<char>(char) const::{lambda(auto:1)#1}::operator()<int>(int) const
Line
Count
Source
99
45
      invoke(type2, [=](auto param2) {
100
45
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
45
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<char>(char) const::{lambda(auto:1)#1}::operator()<unsigned int>(unsigned int) const
Line
Count
Source
99
37
      invoke(type2, [=](auto param2) {
100
37
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
37
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<char>(char) const::{lambda(auto:1)#1}::operator()<long>(long) const
Line
Count
Source
99
33
      invoke(type2, [=](auto param2) {
100
33
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
33
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<char>(char) const::{lambda(auto:1)#1}::operator()<unsigned long>(unsigned long) const
Line
Count
Source
99
31
      invoke(type2, [=](auto param2) {
100
31
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
31
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<char>(char) const::{lambda(auto:1)#1}::operator()<float>(float) const
Line
Count
Source
99
28
      invoke(type2, [=](auto param2) {
100
28
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
28
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<char>(char) const::{lambda(auto:1)#1}::operator()<double>(double) const
Line
Count
Source
99
23
      invoke(type2, [=](auto param2) {
100
23
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
23
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<char>(char) const::{lambda(auto:1)#1}::operator()<long double>(long double) const
Line
Count
Source
99
25
      invoke(type2, [=](auto param2) {
100
25
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
25
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<char>(char) const::{lambda(auto:1)#1}::operator()<void*>(void*) const
Line
Count
Source
99
20
      invoke(type2, [=](auto param2) {
100
20
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
20
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<signed char>(signed char) const::{lambda(auto:1)#1}::operator()<bool>(bool) const
Line
Count
Source
99
41
      invoke(type2, [=](auto param2) {
100
41
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
41
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<signed char>(signed char) const::{lambda(auto:1)#1}::operator()<char>(char) const
Line
Count
Source
99
20
      invoke(type2, [=](auto param2) {
100
20
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
20
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<signed char>(signed char) const::{lambda(auto:1)#1}::operator()<signed char>(signed char) const
Line
Count
Source
99
29
      invoke(type2, [=](auto param2) {
100
29
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
29
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<signed char>(signed char) const::{lambda(auto:1)#1}::operator()<unsigned char>(unsigned char) const
Line
Count
Source
99
18
      invoke(type2, [=](auto param2) {
100
18
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
18
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<signed char>(signed char) const::{lambda(auto:1)#1}::operator()<short>(short) const
Line
Count
Source
99
28
      invoke(type2, [=](auto param2) {
100
28
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
28
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<signed char>(signed char) const::{lambda(auto:1)#1}::operator()<unsigned short>(unsigned short) const
Line
Count
Source
99
20
      invoke(type2, [=](auto param2) {
100
20
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
20
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<signed char>(signed char) const::{lambda(auto:1)#1}::operator()<int>(int) const
Line
Count
Source
99
27
      invoke(type2, [=](auto param2) {
100
27
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
27
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<signed char>(signed char) const::{lambda(auto:1)#1}::operator()<unsigned int>(unsigned int) const
Line
Count
Source
99
28
      invoke(type2, [=](auto param2) {
100
28
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
28
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<signed char>(signed char) const::{lambda(auto:1)#1}::operator()<long>(long) const
Line
Count
Source
99
26
      invoke(type2, [=](auto param2) {
100
26
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
26
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<signed char>(signed char) const::{lambda(auto:1)#1}::operator()<unsigned long>(unsigned long) const
Line
Count
Source
99
30
      invoke(type2, [=](auto param2) {
100
30
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
30
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<signed char>(signed char) const::{lambda(auto:1)#1}::operator()<float>(float) const
Line
Count
Source
99
20
      invoke(type2, [=](auto param2) {
100
20
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
20
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<signed char>(signed char) const::{lambda(auto:1)#1}::operator()<double>(double) const
Line
Count
Source
99
35
      invoke(type2, [=](auto param2) {
100
35
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
35
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<signed char>(signed char) const::{lambda(auto:1)#1}::operator()<long double>(long double) const
Line
Count
Source
99
24
      invoke(type2, [=](auto param2) {
100
24
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
24
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<signed char>(signed char) const::{lambda(auto:1)#1}::operator()<void*>(void*) const
Line
Count
Source
99
23
      invoke(type2, [=](auto param2) {
100
23
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
23
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned char>(unsigned char) const::{lambda(auto:1)#1}::operator()<bool>(bool) const
Line
Count
Source
99
27
      invoke(type2, [=](auto param2) {
100
27
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
27
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned char>(unsigned char) const::{lambda(auto:1)#1}::operator()<char>(char) const
Line
Count
Source
99
29
      invoke(type2, [=](auto param2) {
100
29
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
29
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned char>(unsigned char) const::{lambda(auto:1)#1}::operator()<signed char>(signed char) const
Line
Count
Source
99
41
      invoke(type2, [=](auto param2) {
100
41
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
41
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned char>(unsigned char) const::{lambda(auto:1)#1}::operator()<unsigned char>(unsigned char) const
Line
Count
Source
99
21
      invoke(type2, [=](auto param2) {
100
21
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
21
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned char>(unsigned char) const::{lambda(auto:1)#1}::operator()<short>(short) const
Line
Count
Source
99
27
      invoke(type2, [=](auto param2) {
100
27
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
27
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned char>(unsigned char) const::{lambda(auto:1)#1}::operator()<unsigned short>(unsigned short) const
Line
Count
Source
99
23
      invoke(type2, [=](auto param2) {
100
23
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
23
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned char>(unsigned char) const::{lambda(auto:1)#1}::operator()<int>(int) const
Line
Count
Source
99
38
      invoke(type2, [=](auto param2) {
100
38
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
38
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned char>(unsigned char) const::{lambda(auto:1)#1}::operator()<unsigned int>(unsigned int) const
Line
Count
Source
99
34
      invoke(type2, [=](auto param2) {
100
34
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
34
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned char>(unsigned char) const::{lambda(auto:1)#1}::operator()<long>(long) const
Line
Count
Source
99
16
      invoke(type2, [=](auto param2) {
100
16
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
16
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned char>(unsigned char) const::{lambda(auto:1)#1}::operator()<unsigned long>(unsigned long) const
Line
Count
Source
99
30
      invoke(type2, [=](auto param2) {
100
30
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
30
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned char>(unsigned char) const::{lambda(auto:1)#1}::operator()<float>(float) const
Line
Count
Source
99
19
      invoke(type2, [=](auto param2) {
100
19
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
19
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned char>(unsigned char) const::{lambda(auto:1)#1}::operator()<double>(double) const
Line
Count
Source
99
20
      invoke(type2, [=](auto param2) {
100
20
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
20
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned char>(unsigned char) const::{lambda(auto:1)#1}::operator()<long double>(long double) const
Line
Count
Source
99
22
      invoke(type2, [=](auto param2) {
100
22
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
22
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned char>(unsigned char) const::{lambda(auto:1)#1}::operator()<void*>(void*) const
Line
Count
Source
99
11
      invoke(type2, [=](auto param2) {
100
11
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
11
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<short>(short) const::{lambda(auto:1)#1}::operator()<bool>(bool) const
Line
Count
Source
99
22
      invoke(type2, [=](auto param2) {
100
22
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
22
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<short>(short) const::{lambda(auto:1)#1}::operator()<char>(char) const
Line
Count
Source
99
21
      invoke(type2, [=](auto param2) {
100
21
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
21
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<short>(short) const::{lambda(auto:1)#1}::operator()<signed char>(signed char) const
Line
Count
Source
99
32
      invoke(type2, [=](auto param2) {
100
32
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
32
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<short>(short) const::{lambda(auto:1)#1}::operator()<unsigned char>(unsigned char) const
Line
Count
Source
99
16
      invoke(type2, [=](auto param2) {
100
16
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
16
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<short>(short) const::{lambda(auto:1)#1}::operator()<short>(short) const
Line
Count
Source
99
30
      invoke(type2, [=](auto param2) {
100
30
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
30
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<short>(short) const::{lambda(auto:1)#1}::operator()<unsigned short>(unsigned short) const
Line
Count
Source
99
19
      invoke(type2, [=](auto param2) {
100
19
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
19
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<short>(short) const::{lambda(auto:1)#1}::operator()<int>(int) const
Line
Count
Source
99
40
      invoke(type2, [=](auto param2) {
100
40
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
40
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<short>(short) const::{lambda(auto:1)#1}::operator()<unsigned int>(unsigned int) const
Line
Count
Source
99
37
      invoke(type2, [=](auto param2) {
100
37
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
37
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<short>(short) const::{lambda(auto:1)#1}::operator()<long>(long) const
Line
Count
Source
99
55
      invoke(type2, [=](auto param2) {
100
55
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
55
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<short>(short) const::{lambda(auto:1)#1}::operator()<unsigned long>(unsigned long) const
Line
Count
Source
99
27
      invoke(type2, [=](auto param2) {
100
27
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
27
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<short>(short) const::{lambda(auto:1)#1}::operator()<float>(float) const
Line
Count
Source
99
25
      invoke(type2, [=](auto param2) {
100
25
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
25
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<short>(short) const::{lambda(auto:1)#1}::operator()<double>(double) const
Line
Count
Source
99
38
      invoke(type2, [=](auto param2) {
100
38
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
38
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<short>(short) const::{lambda(auto:1)#1}::operator()<long double>(long double) const
Line
Count
Source
99
25
      invoke(type2, [=](auto param2) {
100
25
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
25
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<short>(short) const::{lambda(auto:1)#1}::operator()<void*>(void*) const
Line
Count
Source
99
20
      invoke(type2, [=](auto param2) {
100
20
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
20
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned short>(unsigned short) const::{lambda(auto:1)#1}::operator()<bool>(bool) const
Line
Count
Source
99
16
      invoke(type2, [=](auto param2) {
100
16
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
16
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned short>(unsigned short) const::{lambda(auto:1)#1}::operator()<char>(char) const
Line
Count
Source
99
28
      invoke(type2, [=](auto param2) {
100
28
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
28
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned short>(unsigned short) const::{lambda(auto:1)#1}::operator()<signed char>(signed char) const
Line
Count
Source
99
26
      invoke(type2, [=](auto param2) {
100
26
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
26
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned short>(unsigned short) const::{lambda(auto:1)#1}::operator()<unsigned char>(unsigned char) const
Line
Count
Source
99
17
      invoke(type2, [=](auto param2) {
100
17
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
17
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned short>(unsigned short) const::{lambda(auto:1)#1}::operator()<short>(short) const
Line
Count
Source
99
27
      invoke(type2, [=](auto param2) {
100
27
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
27
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned short>(unsigned short) const::{lambda(auto:1)#1}::operator()<unsigned short>(unsigned short) const
Line
Count
Source
99
20
      invoke(type2, [=](auto param2) {
100
20
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
20
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned short>(unsigned short) const::{lambda(auto:1)#1}::operator()<int>(int) const
Line
Count
Source
99
29
      invoke(type2, [=](auto param2) {
100
29
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
29
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned short>(unsigned short) const::{lambda(auto:1)#1}::operator()<unsigned int>(unsigned int) const
Line
Count
Source
99
29
      invoke(type2, [=](auto param2) {
100
29
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
29
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned short>(unsigned short) const::{lambda(auto:1)#1}::operator()<long>(long) const
Line
Count
Source
99
24
      invoke(type2, [=](auto param2) {
100
24
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
24
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned short>(unsigned short) const::{lambda(auto:1)#1}::operator()<unsigned long>(unsigned long) const
Line
Count
Source
99
21
      invoke(type2, [=](auto param2) {
100
21
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
21
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned short>(unsigned short) const::{lambda(auto:1)#1}::operator()<float>(float) const
Line
Count
Source
99
23
      invoke(type2, [=](auto param2) {
100
23
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
23
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned short>(unsigned short) const::{lambda(auto:1)#1}::operator()<double>(double) const
Line
Count
Source
99
21
      invoke(type2, [=](auto param2) {
100
21
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
21
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned short>(unsigned short) const::{lambda(auto:1)#1}::operator()<long double>(long double) const
Line
Count
Source
99
13
      invoke(type2, [=](auto param2) {
100
13
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
13
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned short>(unsigned short) const::{lambda(auto:1)#1}::operator()<void*>(void*) const
Line
Count
Source
99
19
      invoke(type2, [=](auto param2) {
100
19
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
19
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<int>(int) const::{lambda(auto:1)#1}::operator()<bool>(bool) const
Line
Count
Source
99
37
      invoke(type2, [=](auto param2) {
100
37
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
37
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<int>(int) const::{lambda(auto:1)#1}::operator()<char>(char) const
Line
Count
Source
99
31
      invoke(type2, [=](auto param2) {
100
31
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
31
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<int>(int) const::{lambda(auto:1)#1}::operator()<signed char>(signed char) const
Line
Count
Source
99
63
      invoke(type2, [=](auto param2) {
100
63
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
63
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<int>(int) const::{lambda(auto:1)#1}::operator()<unsigned char>(unsigned char) const
Line
Count
Source
99
29
      invoke(type2, [=](auto param2) {
100
29
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
29
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<int>(int) const::{lambda(auto:1)#1}::operator()<short>(short) const
Line
Count
Source
99
34
      invoke(type2, [=](auto param2) {
100
34
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
34
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<int>(int) const::{lambda(auto:1)#1}::operator()<unsigned short>(unsigned short) const
Line
Count
Source
99
32
      invoke(type2, [=](auto param2) {
100
32
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
32
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<int>(int) const::{lambda(auto:1)#1}::operator()<int>(int) const
Line
Count
Source
99
41
      invoke(type2, [=](auto param2) {
100
41
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
41
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<int>(int) const::{lambda(auto:1)#1}::operator()<unsigned int>(unsigned int) const
Line
Count
Source
99
25
      invoke(type2, [=](auto param2) {
100
25
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
25
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<int>(int) const::{lambda(auto:1)#1}::operator()<long>(long) const
Line
Count
Source
99
45
      invoke(type2, [=](auto param2) {
100
45
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
45
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<int>(int) const::{lambda(auto:1)#1}::operator()<unsigned long>(unsigned long) const
Line
Count
Source
99
42
      invoke(type2, [=](auto param2) {
100
42
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
42
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<int>(int) const::{lambda(auto:1)#1}::operator()<float>(float) const
Line
Count
Source
99
56
      invoke(type2, [=](auto param2) {
100
56
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
56
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<int>(int) const::{lambda(auto:1)#1}::operator()<double>(double) const
Line
Count
Source
99
29
      invoke(type2, [=](auto param2) {
100
29
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
29
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<int>(int) const::{lambda(auto:1)#1}::operator()<long double>(long double) const
Line
Count
Source
99
32
      invoke(type2, [=](auto param2) {
100
32
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
32
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<int>(int) const::{lambda(auto:1)#1}::operator()<void*>(void*) const
Line
Count
Source
99
29
      invoke(type2, [=](auto param2) {
100
29
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
29
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned int>(unsigned int) const::{lambda(auto:1)#1}::operator()<bool>(bool) const
Line
Count
Source
99
55
      invoke(type2, [=](auto param2) {
100
55
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
55
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned int>(unsigned int) const::{lambda(auto:1)#1}::operator()<char>(char) const
Line
Count
Source
99
27
      invoke(type2, [=](auto param2) {
100
27
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
27
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned int>(unsigned int) const::{lambda(auto:1)#1}::operator()<signed char>(signed char) const
Line
Count
Source
99
44
      invoke(type2, [=](auto param2) {
100
44
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
44
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned int>(unsigned int) const::{lambda(auto:1)#1}::operator()<unsigned char>(unsigned char) const
Line
Count
Source
99
25
      invoke(type2, [=](auto param2) {
100
25
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
25
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned int>(unsigned int) const::{lambda(auto:1)#1}::operator()<short>(short) const
Line
Count
Source
99
28
      invoke(type2, [=](auto param2) {
100
28
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
28
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned int>(unsigned int) const::{lambda(auto:1)#1}::operator()<unsigned short>(unsigned short) const
Line
Count
Source
99
53
      invoke(type2, [=](auto param2) {
100
53
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
53
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned int>(unsigned int) const::{lambda(auto:1)#1}::operator()<int>(int) const
Line
Count
Source
99
40
      invoke(type2, [=](auto param2) {
100
40
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
40
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned int>(unsigned int) const::{lambda(auto:1)#1}::operator()<unsigned int>(unsigned int) const
Line
Count
Source
99
61
      invoke(type2, [=](auto param2) {
100
61
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
61
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned int>(unsigned int) const::{lambda(auto:1)#1}::operator()<long>(long) const
Line
Count
Source
99
69
      invoke(type2, [=](auto param2) {
100
69
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
69
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned int>(unsigned int) const::{lambda(auto:1)#1}::operator()<unsigned long>(unsigned long) const
Line
Count
Source
99
37
      invoke(type2, [=](auto param2) {
100
37
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
37
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned int>(unsigned int) const::{lambda(auto:1)#1}::operator()<float>(float) const
Line
Count
Source
99
48
      invoke(type2, [=](auto param2) {
100
48
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
48
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned int>(unsigned int) const::{lambda(auto:1)#1}::operator()<double>(double) const
Line
Count
Source
99
51
      invoke(type2, [=](auto param2) {
100
51
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
51
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned int>(unsigned int) const::{lambda(auto:1)#1}::operator()<long double>(long double) const
Line
Count
Source
99
37
      invoke(type2, [=](auto param2) {
100
37
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
37
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned int>(unsigned int) const::{lambda(auto:1)#1}::operator()<void*>(void*) const
Line
Count
Source
99
33
      invoke(type2, [=](auto param2) {
100
33
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
33
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long>(long) const::{lambda(auto:1)#1}::operator()<bool>(bool) const
Line
Count
Source
99
40
      invoke(type2, [=](auto param2) {
100
40
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
40
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long>(long) const::{lambda(auto:1)#1}::operator()<char>(char) const
Line
Count
Source
99
85
      invoke(type2, [=](auto param2) {
100
85
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
85
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long>(long) const::{lambda(auto:1)#1}::operator()<signed char>(signed char) const
Line
Count
Source
99
101
      invoke(type2, [=](auto param2) {
100
101
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
101
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long>(long) const::{lambda(auto:1)#1}::operator()<unsigned char>(unsigned char) const
Line
Count
Source
99
39
      invoke(type2, [=](auto param2) {
100
39
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
39
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long>(long) const::{lambda(auto:1)#1}::operator()<short>(short) const
Line
Count
Source
99
44
      invoke(type2, [=](auto param2) {
100
44
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
44
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long>(long) const::{lambda(auto:1)#1}::operator()<unsigned short>(unsigned short) const
Line
Count
Source
99
54
      invoke(type2, [=](auto param2) {
100
54
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
54
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long>(long) const::{lambda(auto:1)#1}::operator()<int>(int) const
Line
Count
Source
99
69
      invoke(type2, [=](auto param2) {
100
69
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
69
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long>(long) const::{lambda(auto:1)#1}::operator()<unsigned int>(unsigned int) const
Line
Count
Source
99
102
      invoke(type2, [=](auto param2) {
100
102
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
102
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long>(long) const::{lambda(auto:1)#1}::operator()<long>(long) const
Line
Count
Source
99
77
      invoke(type2, [=](auto param2) {
100
77
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
77
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long>(long) const::{lambda(auto:1)#1}::operator()<unsigned long>(unsigned long) const
Line
Count
Source
99
56
      invoke(type2, [=](auto param2) {
100
56
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
56
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long>(long) const::{lambda(auto:1)#1}::operator()<float>(float) const
Line
Count
Source
99
64
      invoke(type2, [=](auto param2) {
100
64
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
64
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long>(long) const::{lambda(auto:1)#1}::operator()<double>(double) const
Line
Count
Source
99
52
      invoke(type2, [=](auto param2) {
100
52
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
52
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long>(long) const::{lambda(auto:1)#1}::operator()<long double>(long double) const
Line
Count
Source
99
50
      invoke(type2, [=](auto param2) {
100
50
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
50
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long>(long) const::{lambda(auto:1)#1}::operator()<void*>(void*) const
Line
Count
Source
99
52
      invoke(type2, [=](auto param2) {
100
52
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
52
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned long>(unsigned long) const::{lambda(auto:1)#1}::operator()<bool>(bool) const
Line
Count
Source
99
66
      invoke(type2, [=](auto param2) {
100
66
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
66
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned long>(unsigned long) const::{lambda(auto:1)#1}::operator()<char>(char) const
Line
Count
Source
99
38
      invoke(type2, [=](auto param2) {
100
38
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
38
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned long>(unsigned long) const::{lambda(auto:1)#1}::operator()<signed char>(signed char) const
Line
Count
Source
99
69
      invoke(type2, [=](auto param2) {
100
69
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
69
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned long>(unsigned long) const::{lambda(auto:1)#1}::operator()<unsigned char>(unsigned char) const
Line
Count
Source
99
35
      invoke(type2, [=](auto param2) {
100
35
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
35
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned long>(unsigned long) const::{lambda(auto:1)#1}::operator()<short>(short) const
Line
Count
Source
99
54
      invoke(type2, [=](auto param2) {
100
54
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
54
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned long>(unsigned long) const::{lambda(auto:1)#1}::operator()<unsigned short>(unsigned short) const
Line
Count
Source
99
73
      invoke(type2, [=](auto param2) {
100
73
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
73
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned long>(unsigned long) const::{lambda(auto:1)#1}::operator()<int>(int) const
Line
Count
Source
99
67
      invoke(type2, [=](auto param2) {
100
67
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
67
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned long>(unsigned long) const::{lambda(auto:1)#1}::operator()<unsigned int>(unsigned int) const
Line
Count
Source
99
79
      invoke(type2, [=](auto param2) {
100
79
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
79
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned long>(unsigned long) const::{lambda(auto:1)#1}::operator()<long>(long) const
Line
Count
Source
99
61
      invoke(type2, [=](auto param2) {
100
61
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
61
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned long>(unsigned long) const::{lambda(auto:1)#1}::operator()<unsigned long>(unsigned long) const
Line
Count
Source
99
65
      invoke(type2, [=](auto param2) {
100
65
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
65
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned long>(unsigned long) const::{lambda(auto:1)#1}::operator()<float>(float) const
Line
Count
Source
99
53
      invoke(type2, [=](auto param2) {
100
53
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
53
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned long>(unsigned long) const::{lambda(auto:1)#1}::operator()<double>(double) const
Line
Count
Source
99
34
      invoke(type2, [=](auto param2) {
100
34
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
34
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned long>(unsigned long) const::{lambda(auto:1)#1}::operator()<long double>(long double) const
Line
Count
Source
99
40
      invoke(type2, [=](auto param2) {
100
40
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
40
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned long>(unsigned long) const::{lambda(auto:1)#1}::operator()<void*>(void*) const
Line
Count
Source
99
65
      invoke(type2, [=](auto param2) {
100
65
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
65
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<float>(float) const::{lambda(auto:1)#1}::operator()<bool>(bool) const
Line
Count
Source
99
89
      invoke(type2, [=](auto param2) {
100
89
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
89
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<float>(float) const::{lambda(auto:1)#1}::operator()<char>(char) const
Line
Count
Source
99
40
      invoke(type2, [=](auto param2) {
100
40
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
40
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<float>(float) const::{lambda(auto:1)#1}::operator()<signed char>(signed char) const
Line
Count
Source
99
94
      invoke(type2, [=](auto param2) {
100
94
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
94
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<float>(float) const::{lambda(auto:1)#1}::operator()<unsigned char>(unsigned char) const
Line
Count
Source
99
116
      invoke(type2, [=](auto param2) {
100
116
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
116
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<float>(float) const::{lambda(auto:1)#1}::operator()<short>(short) const
Line
Count
Source
99
99
      invoke(type2, [=](auto param2) {
100
99
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
99
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<float>(float) const::{lambda(auto:1)#1}::operator()<unsigned short>(unsigned short) const
Line
Count
Source
99
145
      invoke(type2, [=](auto param2) {
100
145
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
145
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<float>(float) const::{lambda(auto:1)#1}::operator()<int>(int) const
Line
Count
Source
99
272
      invoke(type2, [=](auto param2) {
100
272
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
272
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<float>(float) const::{lambda(auto:1)#1}::operator()<unsigned int>(unsigned int) const
Line
Count
Source
99
434
      invoke(type2, [=](auto param2) {
100
434
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
434
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<float>(float) const::{lambda(auto:1)#1}::operator()<long>(long) const
Line
Count
Source
99
65
      invoke(type2, [=](auto param2) {
100
65
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
65
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<float>(float) const::{lambda(auto:1)#1}::operator()<unsigned long>(unsigned long) const
Line
Count
Source
99
105
      invoke(type2, [=](auto param2) {
100
105
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
105
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<float>(float) const::{lambda(auto:1)#1}::operator()<float>(float) const
Line
Count
Source
99
165
      invoke(type2, [=](auto param2) {
100
165
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
165
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<float>(float) const::{lambda(auto:1)#1}::operator()<double>(double) const
Line
Count
Source
99
69
      invoke(type2, [=](auto param2) {
100
69
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
69
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<float>(float) const::{lambda(auto:1)#1}::operator()<long double>(long double) const
Line
Count
Source
99
52
      invoke(type2, [=](auto param2) {
100
52
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
52
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<float>(float) const::{lambda(auto:1)#1}::operator()<void*>(void*) const
Line
Count
Source
99
21
      invoke(type2, [=](auto param2) {
100
21
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
21
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<double>(double) const::{lambda(auto:1)#1}::operator()<bool>(bool) const
Line
Count
Source
99
125
      invoke(type2, [=](auto param2) {
100
125
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
125
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<double>(double) const::{lambda(auto:1)#1}::operator()<char>(char) const
Line
Count
Source
99
99
      invoke(type2, [=](auto param2) {
100
99
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
99
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<double>(double) const::{lambda(auto:1)#1}::operator()<signed char>(signed char) const
Line
Count
Source
99
212
      invoke(type2, [=](auto param2) {
100
212
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
212
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<double>(double) const::{lambda(auto:1)#1}::operator()<unsigned char>(unsigned char) const
Line
Count
Source
99
165
      invoke(type2, [=](auto param2) {
100
165
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
165
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<double>(double) const::{lambda(auto:1)#1}::operator()<short>(short) const
Line
Count
Source
99
123
      invoke(type2, [=](auto param2) {
100
123
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
123
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<double>(double) const::{lambda(auto:1)#1}::operator()<unsigned short>(unsigned short) const
Line
Count
Source
99
257
      invoke(type2, [=](auto param2) {
100
257
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
257
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<double>(double) const::{lambda(auto:1)#1}::operator()<int>(int) const
Line
Count
Source
99
458
      invoke(type2, [=](auto param2) {
100
458
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
458
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<double>(double) const::{lambda(auto:1)#1}::operator()<unsigned int>(unsigned int) const
Line
Count
Source
99
644
      invoke(type2, [=](auto param2) {
100
644
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
644
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<double>(double) const::{lambda(auto:1)#1}::operator()<long>(long) const
Line
Count
Source
99
168
      invoke(type2, [=](auto param2) {
100
168
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
168
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<double>(double) const::{lambda(auto:1)#1}::operator()<unsigned long>(unsigned long) const
Line
Count
Source
99
49
      invoke(type2, [=](auto param2) {
100
49
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
49
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<double>(double) const::{lambda(auto:1)#1}::operator()<float>(float) const
Line
Count
Source
99
66
      invoke(type2, [=](auto param2) {
100
66
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
66
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<double>(double) const::{lambda(auto:1)#1}::operator()<double>(double) const
Line
Count
Source
99
171
      invoke(type2, [=](auto param2) {
100
171
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
171
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<double>(double) const::{lambda(auto:1)#1}::operator()<long double>(long double) const
Line
Count
Source
99
118
      invoke(type2, [=](auto param2) {
100
118
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
118
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<double>(double) const::{lambda(auto:1)#1}::operator()<void*>(void*) const
Line
Count
Source
99
42
      invoke(type2, [=](auto param2) {
100
42
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
42
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long double>(long double) const::{lambda(auto:1)#1}::operator()<bool>(bool) const
Line
Count
Source
99
39
      invoke(type2, [=](auto param2) {
100
39
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
39
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long double>(long double) const::{lambda(auto:1)#1}::operator()<char>(char) const
Line
Count
Source
99
61
      invoke(type2, [=](auto param2) {
100
61
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
61
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long double>(long double) const::{lambda(auto:1)#1}::operator()<signed char>(signed char) const
Line
Count
Source
99
69
      invoke(type2, [=](auto param2) {
100
69
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
69
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long double>(long double) const::{lambda(auto:1)#1}::operator()<unsigned char>(unsigned char) const
Line
Count
Source
99
51
      invoke(type2, [=](auto param2) {
100
51
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
51
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long double>(long double) const::{lambda(auto:1)#1}::operator()<short>(short) const
Line
Count
Source
99
67
      invoke(type2, [=](auto param2) {
100
67
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
67
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long double>(long double) const::{lambda(auto:1)#1}::operator()<unsigned short>(unsigned short) const
Line
Count
Source
99
167
      invoke(type2, [=](auto param2) {
100
167
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
167
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long double>(long double) const::{lambda(auto:1)#1}::operator()<int>(int) const
Line
Count
Source
99
483
      invoke(type2, [=](auto param2) {
100
483
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
483
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long double>(long double) const::{lambda(auto:1)#1}::operator()<unsigned int>(unsigned int) const
Line
Count
Source
99
280
      invoke(type2, [=](auto param2) {
100
280
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
280
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long double>(long double) const::{lambda(auto:1)#1}::operator()<long>(long) const
Line
Count
Source
99
142
      invoke(type2, [=](auto param2) {
100
142
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
142
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long double>(long double) const::{lambda(auto:1)#1}::operator()<unsigned long>(unsigned long) const
Line
Count
Source
99
45
      invoke(type2, [=](auto param2) {
100
45
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
45
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long double>(long double) const::{lambda(auto:1)#1}::operator()<float>(float) const
Line
Count
Source
99
82
      invoke(type2, [=](auto param2) {
100
82
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
82
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long double>(long double) const::{lambda(auto:1)#1}::operator()<double>(double) const
Line
Count
Source
99
86
      invoke(type2, [=](auto param2) {
100
86
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
86
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long double>(long double) const::{lambda(auto:1)#1}::operator()<long double>(long double) const
Line
Count
Source
99
114
      invoke(type2, [=](auto param2) {
100
114
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
114
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long double>(long double) const::{lambda(auto:1)#1}::operator()<void*>(void*) const
Line
Count
Source
99
44
      invoke(type2, [=](auto param2) {
100
44
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
44
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<void*>(void*) const::{lambda(auto:1)#1}::operator()<bool>(bool) const
Line
Count
Source
99
38
      invoke(type2, [=](auto param2) {
100
38
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
38
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<void*>(void*) const::{lambda(auto:1)#1}::operator()<char>(char) const
Line
Count
Source
99
18
      invoke(type2, [=](auto param2) {
100
18
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
18
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<void*>(void*) const::{lambda(auto:1)#1}::operator()<signed char>(signed char) const
Line
Count
Source
99
38
      invoke(type2, [=](auto param2) {
100
38
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
38
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<void*>(void*) const::{lambda(auto:1)#1}::operator()<unsigned char>(unsigned char) const
Line
Count
Source
99
25
      invoke(type2, [=](auto param2) {
100
25
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
25
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<void*>(void*) const::{lambda(auto:1)#1}::operator()<short>(short) const
Line
Count
Source
99
25
      invoke(type2, [=](auto param2) {
100
25
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
25
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<void*>(void*) const::{lambda(auto:1)#1}::operator()<unsigned short>(unsigned short) const
Line
Count
Source
99
29
      invoke(type2, [=](auto param2) {
100
29
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
29
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<void*>(void*) const::{lambda(auto:1)#1}::operator()<int>(int) const
Line
Count
Source
99
30
      invoke(type2, [=](auto param2) {
100
30
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
30
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<void*>(void*) const::{lambda(auto:1)#1}::operator()<unsigned int>(unsigned int) const
Line
Count
Source
99
37
      invoke(type2, [=](auto param2) {
100
37
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
37
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<void*>(void*) const::{lambda(auto:1)#1}::operator()<long>(long) const
Line
Count
Source
99
31
      invoke(type2, [=](auto param2) {
100
31
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
31
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<void*>(void*) const::{lambda(auto:1)#1}::operator()<unsigned long>(unsigned long) const
Line
Count
Source
99
29
      invoke(type2, [=](auto param2) {
100
29
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
29
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<void*>(void*) const::{lambda(auto:1)#1}::operator()<float>(float) const
Line
Count
Source
99
20
      invoke(type2, [=](auto param2) {
100
20
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
20
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<void*>(void*) const::{lambda(auto:1)#1}::operator()<double>(double) const
Line
Count
Source
99
22
      invoke(type2, [=](auto param2) {
100
22
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
22
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<void*>(void*) const::{lambda(auto:1)#1}::operator()<long double>(long double) const
Line
Count
Source
99
27
      invoke(type2, [=](auto param2) {
100
27
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
27
      });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<void*>(void*) const::{lambda(auto:1)#1}::operator()<void*>(void*) const
Line
Count
Source
99
32
      invoke(type2, [=](auto param2) {
100
32
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
32
      });
102
11.9k
    });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<bool>(bool) const
Line
Count
Source
98
561
    invoke(type1, [=](auto param1) {
99
561
      invoke(type2, [=](auto param2) {
100
561
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
561
      });
102
561
    });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<char>(char) const
Line
Count
Source
98
526
    invoke(type1, [=](auto param1) {
99
526
      invoke(type2, [=](auto param2) {
100
526
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
526
      });
102
526
    });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<signed char>(signed char) const
Line
Count
Source
98
370
    invoke(type1, [=](auto param1) {
99
370
      invoke(type2, [=](auto param2) {
100
370
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
370
      });
102
370
    });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned char>(unsigned char) const
Line
Count
Source
98
359
    invoke(type1, [=](auto param1) {
99
359
      invoke(type2, [=](auto param2) {
100
359
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
359
      });
102
359
    });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<short>(short) const
Line
Count
Source
98
408
    invoke(type1, [=](auto param1) {
99
408
      invoke(type2, [=](auto param2) {
100
408
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
408
      });
102
408
    });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned short>(unsigned short) const
Line
Count
Source
98
314
    invoke(type1, [=](auto param1) {
99
314
      invoke(type2, [=](auto param2) {
100
314
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
314
      });
102
314
    });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<int>(int) const
Line
Count
Source
98
526
    invoke(type1, [=](auto param1) {
99
526
      invoke(type2, [=](auto param2) {
100
526
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
526
      });
102
526
    });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned int>(unsigned int) const
Line
Count
Source
98
609
    invoke(type1, [=](auto param1) {
99
609
      invoke(type2, [=](auto param2) {
100
609
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
609
      });
102
609
    });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long>(long) const
Line
Count
Source
98
886
    invoke(type1, [=](auto param1) {
99
886
      invoke(type2, [=](auto param2) {
100
886
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
886
      });
102
886
    });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<unsigned long>(unsigned long) const
Line
Count
Source
98
800
    invoke(type1, [=](auto param1) {
99
800
      invoke(type2, [=](auto param2) {
100
800
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
800
      });
102
800
    });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<float>(float) const
Line
Count
Source
98
1.76k
    invoke(type1, [=](auto param1) {
99
1.76k
      invoke(type2, [=](auto param2) {
100
1.76k
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
1.76k
      });
102
1.76k
    });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<double>(double) const
Line
Count
Source
98
2.69k
    invoke(type1, [=](auto param1) {
99
2.69k
      invoke(type2, [=](auto param2) {
100
2.69k
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
2.69k
      });
102
2.69k
    });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<long double>(long double) const
Line
Count
Source
98
1.73k
    invoke(type1, [=](auto param1) {
99
1.73k
      invoke(type2, [=](auto param2) {
100
1.73k
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
1.73k
      });
102
1.73k
    });
two-args.cc:auto LLVMFuzzerTestOneInput::$_0::operator()<void*>(void*) const
Line
Count
Source
98
402
    invoke(type1, [=](auto param1) {
99
402
      invoke(type2, [=](auto param2) {
100
402
        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
101
402
      });
102
402
    });
103
11.9k
  } catch (std::exception&) {
104
7.53k
  }
105
11.9k
  return 0;
106
11.9k
}